Guía completa de Nano Banana 2 Lite y Gemini Omni Flash: canalizaciones multimedia en Python

¿Qué es Nano Banana 2 Lite?

Nano Banana 2 Lite (gemini-3.1-flash-lite-image) es el modelo de generación de imágenes más rápido y económico de Google hasta la fecha. 

Creado específicamente para canalizaciones de desarrollo de alta velocidad y aplicaciones de alto volumen, está optimizado para escenarios donde la baja latencia y los presupuestos ajustados son críticos.

Para plataformas que usan el modelo heredado de Google (gemini-2.5-flash-image), Nano Banana 2 Lite actúa como sustituto directo, con mejoras inmediatas en velocidad, coste y fidelidad visual.

Métricas clave de rendimiento

• Latencia ultrabaja: genera imágenes a partir de texto en unos 4 segundos, ideal para prototipado interactivo y apps en tiempo real.
• Eficiencia de coste: precio de 0,034 $ por imagen a resolución 1K, reduce notablemente la barrera para la generación a gran escala.
• Calidad constante: pese a priorizar la velocidad, mantiene buena adherencia al prompt, consistencia de personajes y generación fiable de texto dentro de la imagen.

¿Qué es Gemini Omni Flash?

Gemini Omni Flash (gemini-omni-flash-preview) es el modelo de Google optimizado en costes para generación de vídeo y edición de vídeo conversacional.

A diferencia de los generadores de vídeo que dependen solo de prompts de texto estáticos, Omni Flash incorpora el razonamiento multimodal de Gemini directamente en el proceso de creación.

Admite de forma nativa combinaciones de texto, imagen y vídeo, lo que permite controlar la generación de vídeo con una precisión inédita.

Capacidades clave y precios de Omni Flash

• Precio competitivo: 0,10 $ por segundo de vídeo generado, igualando la tarifa de Veo 3.1 Fast.
• Edición de vídeo conversacional: en lugar de regenerar desde cero por cambios menores, puedes dar instrucciones en lenguaje natural para refinar secuencias existentes.
• Referencias multimodales: combina prompts de texto con imágenes o clips de referencia para asegurar consistencia visual y control granular de la escena.
• Aterrizaje en el mundo real: aprovechando el conocimiento base de Gemini, construye animaciones realistas basadas en lógica y física.
• Sincronización de texto y acciones: el texto en pantalla y las superposiciones gráficas pueden vincularse directamente a acciones del vídeo con prompts sencillos.

Cómo generar y configurar una clave de la API de Gemini

Antes de usar la API de Gemini, necesitamos crear y configurar una clave de API para que nuestro código se comunique con ella.

La forma más sencilla de hacerlo es:

• Visita la página de claves de API de Google AI Studio e inicia sesión.
• Haz clic en el botón «Create API key» en la esquina superior derecha.
• Copia la clave en un archivo llamado .env en la misma carpeta donde estará el código de Python, con el siguiente formato:

GEMINI_API_KEY=replace_with_api_keyCon la tecnología de

Nota: usar la API tiene costes. Para utilizarla, asegúrate de tener un método de pago configurado en la página de facturación de Google AI Studio.

Cómo generar imágenes con Nano Banana 2 Lite en Python

Requisitos previos para generar imágenes con IA en Python

Antes de programar nuestro generador de imágenes con IA en Python, asegúrate de tener listo lo siguiente:

• Python 3.9+ instalado en tu sistema.
• Clave de la API de Google Gemini: una clave válida para autenticar las peticiones. Consulta los pasos anteriores para crearla y configurarla.
• Librerías de Python necesarias: usaremos el SDK oficial google-genai para la integración con la API y Pillow para manejar la imagen de salida.

Puedes instalar los paquetes necesarios con pip:

pip install google-genai pillow python-dotenvCon la tecnología de

Paso 1: importar módulos y cargar variables de entorno

Crea un archivo nuevo (p. ej., generate_image.py) y añade los siguientes imports y la carga del entorno:

import io
from dotenv import load_dotenv
from google.genai import types
from PIL import Image
from google.genai import Client

# Load environment variables from the .env file
load_dotenv()Con la tecnología de

Paso 2: inicializar el cliente de Google GenAI

Para interactuar con el modelo Nano Banana 2 Lite, primero debemos inicializar el cliente de Google GenAI. 

Como el SDK comprueba automáticamente la variable de entorno GEMINI_API_KEY (que cargamos del archivo .env en el paso anterior), podemos inicializar el cliente sin pasar la clave explícitamente en el código.

# Initialize the Gemini API client
client = Client()Con la tecnología de

Paso 3: escribir la función de generación de imágenes con IA

Ahora, la lógica central de nuestro script en Python. Escribiremos una función generate_image() que recibe el cliente inicializado y un prompt de texto.

Nano Banana 2 Lite se invoca especificando model="gemini-3.1-flash-lite-image". Configuramos la petición para solicitar modalidad de imagen y fijamos la relación de aspecto deseada.

def generate_image(client, prompt: str, ratio: str = "1:1") -> Image.Image | None:
    """
    Generates an AI image using the Nano Banana 2 Lite model via the Gemini API.
    """
    print(f"Generating AI image for prompt: '{prompt}'...")
    
    # 1. Call the Nano Banana 2 Lite model
    response = client.models.generate_content(
        model="gemini-3.1-flash-lite-image",
        contents=prompt,
        config=types.GenerateContentConfig(
            response_modalities=[types.Modality.IMAGE],
            image_config=types.ImageConfig(aspect_ratio=ratio),
        ),
    )
    
    # 2. Extract and convert the generated image data
    if response and response.candidates:
        for part in response.candidates[0].content.parts:
            if part.inline_data:
                # Load the bytes into a PIL Image and convert to RGB
                image = Image.open(io.BytesIO(part.inline_data.data)).convert("RGB")
                return image
                
    return NoneCon la tecnología de

Cómo entender la petición de generación de imágenes en Python:

• response_modalities: fuerza a Google Gemini a devolver una imagen en lugar de texto.
• inline_data: la API devuelve la imagen generada como bytes en bruto. Usamos io.BytesIO para envolverlos y que Pillow (Image.open) los lea como archivo estándar.
• image_config: fijamos aspect_ratio a "1:1" (cuadrado), pero se puede ajustar según el caso de uso.

Relaciones de aspecto admitidas:

Paso 4: ejecutar el script de generación de imágenes en Python

Vamos a juntarlo todo y pedir a Nano Banana 2 Lite que genere una imagen. 

Le daremos un prompt creativo, mostraremos el resultado con show() y cerraremos el cliente para liberar recursos.

if __name__ == "__main__":
    # Define our creative prompt for the AI model
    my_prompt = "A futuristic city skyline at sunset, cyberpunk style, highly detailed"
    
    # Generate the AI image
    result_image = generate_image(client, my_prompt)
    
    # Display the resulting image
    if result_image:
        print("AI Image generated successfully!")
        result_image.show()
    else:
        print("Failed to generate AI image.")
        
    # Close the client to prevent shutdown exceptions
    client.close()Con la tecnología de

Esta es la imagen generada por Nano Banana 2 Flash:

Tal y como prometió Google en su anuncio, el modelo tardó solo unos segundos en generar la imagen. A simple vista, se siente mucho más rápido que cualquier otro modelo que he probado.

El script completo está en el generate_image.py del repositorio de este tutorial.

Ampliar el script para editar imágenes

Vamos a escribir una función edit_image() que edite una imagen. Lo único que debemos cambiar es pasar la imagen junto con el prompt en el parámetro contents como una lista [image, prompt].

def edit_image(client, image: Image.Image, prompt: str, aspect_ratio: str = "1:1") -> Image.Image | None:
    """
    Edits an AI image using the Gemini 3.1 Flash Lite model via the Gemini API.
    """
    response = client.models.generate_content(
        model="gemini-3.1-flash-lite-image",
        contents=[image, prompt],
        config=types.GenerateContentConfig(
            response_modalities=[types.Modality.IMAGE],
            image_config=types.ImageConfig(aspect_ratio=aspect_ratio),
        ),
    )
    if response and response.candidates:
        for part in response.candidates[0].content.parts:
            if part.inline_data:
                return Image.open(io.BytesIO(part.inline_data.data)).convert("RGB")
    return NoneCon la tecnología de

Pruebas con Nano Banana 2 Flash

Evaluamos el rendimiento del modelo en situaciones reales con una serie de pruebas de estrés dirigidas. 

Estas pruebas se centran en su capacidad para manejar tareas visuales complejas: renderizado legible de texto, mantenimiento de diseños espaciales estrictos y consistencia a lo largo de varias iteraciones, para ver si realmente cumple su promesa de alta fidelidad a gran velocidad.

Prueba de renderizado de texto legible dentro de la imagen

Prueba de control espacial estricto y adherencia a dos sujetos

Prueba de prototipado rápido de UI y precisión de maquetación

Prueba de contrastes de materiales complejos e iluminación

Prueba de consistencia de personaje en varias iteraciones

Francamente, me han sorprendido los resultados para un modelo tan rápido. En el último ejemplo, incluso consiguió mantener en parte la consistencia del texto del periódico. 

En mi experiencia, la consistencia es una de las cualidades más importantes que debe clavar un modelo de generación de imágenes para ser realmente útil.

Cómo generar vídeos con Gemini Omni Flash en Python

En esta sección veremos cómo crear un script en Python para generar vídeos, empezando por un simple texto-a-vídeo y ampliándolo para incorporar imágenes de referencia.

A diferencia de la generación de imágenes, los vídeos con Gemini Omni Flash se generan mediante la Interactions API del SDK (client.interactions.create). Este endpoint está diseñado para manejar interacciones ricas, multimodales y de varias vueltas.

Como las importaciones, variables de entorno e inicialización del cliente son idénticas a la sección anterior, podemos centrarnos directamente en las funciones de generación de vídeo.

Paso 1: texto a vídeo (prompt simple a vídeo)

Para generar un vídeo solo a partir de texto, pasamos un único bloque de texto a la Interactions API. Podemos escribir una función sencilla en Python para esto:

def text_to_video(client, prompt: str, aspect_ratio: str = "16:9", duration: str = "5s"):
    """
    Generates a video from a text prompt using Gemini Omni Flash.
    """
    interaction = client.interactions.create(
        model="gemini-omni-flash-preview",
        input=[{"type": "text", "text": prompt}],
        response_format={
            "type": "video",
            "aspect_ratio": aspect_ratio,
            "duration": duration,
        },
    )
    return interactionCon la tecnología de

Podemos invocar esta función y guardar los bytes del vídeo devuelto en un archivo así:

if __name__ == "__main__":
    import base64

    # Define a creative video prompt
    text_prompt = """
    Generate a first person view of what daily life would look like in the year
    1000 at this location: 41.89030621184054, 12.492266126772481
    """

    # Call the video generator
    interaction = text_to_video(
        client=client,
        prompt=text_prompt,
        aspect_ratio="16:9",
        duration="5s"
    )

    # Extract and save the generated video file
    if interaction and hasattr(interaction, "output_video") and interaction.output_video:
        # Decode the base64-encoded video data returned by the API
        video_bytes = base64.b64decode(interaction.output_video.data)
        
        # Save the bytes locally as an MP4 file
        with open("videos/video.mp4", "wb") as f:
            f.write(video_bytes)
    else:
        print("Failed to generate video.")Con la tecnología de

El prompt que usamos fue:

Generate a first-person view of what daily life would look like in the year 1000 at this location: 41.89030621184054, 12.492266126772481Con la tecnología de

Esa ubicación concreta es el Coliseo romano. Usé coordenadas para poner a prueba el conocimiento del mundo del modelo. Este es el vídeo generado:

En cambio, esto es lo que generó el modelo cuando cambié el año 1000 por 1980:

Bastante interesante, en mi opinión. Consulta el archivo text_to_video.py para ver el script completo.

Paso 2: implementar capacidades de imagen a vídeo

Para animar una imagen estática o usarla como referencia para guiar la generación, debemos pasar tanto la imagen como un prompt de texto al modelo.

Como la Interactions API espera imágenes codificadas en base64, primero definimos una función auxiliar para convertir objetos PIL Image a cadenas base64:

import io
from PIL import Image
import base64

def _image_to_base64(img: Image.Image) -> str:
    """
    Converts a PIL Image object to a base64-encoded string.
    """
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    return base64.b64encode(buffered.getvalue()).decode()Con la tecnología de

Ahora podemos crear una función más general, generate_video(), que gestione tanto imágenes opcionales como el prompt de texto.

from google.genai import types

def generate_video(client, valid_images: list[Image.Image], animation_prompt: str, aspect_ratio: str):
    """
    Generates a commercial-quality AI video using Google's Gemini Omni Flash model.
    Supports image-to-video and text-to-video multimodal inputs using the Gemini API.
    """
    omni_inputs = []
    
    # 1. Base64 encode and append any input images
    for img in valid_images:
        img_b64 = _image_to_base64(img)
        omni_inputs.append({
            "type": "image",
            "data": img_b64,
            "mime_type": "image/png",
        })

    # 2. Append the text animation prompt
    omni_inputs.append({"type": "text", "text": animation_prompt})

    # 3. Request video generation from the interactions endpoint
    interaction = client.interactions.create(
        model="gemini-omni-flash-preview",
        input=omni_inputs,
        response_format={
            "type": "video",
            "aspect_ratio": aspect_ratio,
        },
    )
    return interactionCon la tecnología de

Por último, así es como usamos estas funciones para generar un vídeo que anime este escarabajo que generé con Gemini:

if __name__ == "__main__":
    # Load our reference image
    reference_image = Image.open("images/beetle.png").convert("RGB")

    # Describe how we want the image to be animated
    animation_prompt = """
    A detailed, close-up photograph of an iridescent biomechanical stag beetle, 
    shimmering with metallic green, blue, and violet hues, as it traverses a 
    rugged amethyst crystal formation in a subterranean grotto. 
    The cavern walls are lined with a dense matrix of glowing crystals emitting 
    deep purple, blue, and green light. The air is misty, with bioluminescent 
    flora clinging to the rock. As the camera maintains focus, the beetle 
    subtly activates a soft internal orange glow from its mandibles, begins 
    vibrating its wings, and slowly crawls upward across the crystalline 
    surface, reflecting the surrounding light.
    """

    # Call the generator with the reference image
    interaction = generate_video(
        client=client,
        valid_images=[reference_image],
        animation_prompt=animation_prompt,
        aspect_ratio="16:9"
    )

    # Extract and save the animated video
    if interaction and hasattr(interaction, "output_video") and interaction.output_video:
        video_bytes = base64.b64decode(interaction.output_video.data)
        with open("videos/video.mp4", "wb") as f:
            f.write(video_bytes)Con la tecnología de

Este fue el vídeo generado:

El script completo está disponible aquí.

Paso 3: implementar edición con vídeo a vídeo

Editar un vídeo de forma conversacional con la API de Gemini Omni Flash es muy sencillo gracias a su sistema de interacciones. Al generar un vídeo, obtenemos un identificador de interacción accesible como interaction.id. 

Para editar un vídeo, proporcionamos un prompt y el identificador de la interacción previa. Si es la primera edición, usamos el identificador de la interacción que generó el vídeo; para las siguientes, el de la edición anterior.

client.interactions.create(
        model="gemini-omni-flash-preview",
        input=edit_prompt,
        previous_interaction_id=previous_interaction_id,
)Con la tecnología de

Crear un estudio de vídeo con IA interactivo: arquitectura y sinergia multimodelo

En las secciones anteriores aprendimos a generar imágenes con Nano Banana 2 Lite y vídeos con Gemini Omni Flash. Ahora vamos a combinar ambas capacidades en una aplicación web interactiva: un estudio de vídeo con IA.

Arquitectura del AI Video Studio

Crear vídeos de calidad con IA suele implicar mucho ensayo y error. El AI Video Studio lo resuelve con una canalización en dos etapas y multimodelo que aprovecha los puntos fuertes de dos modelos distintos:

• Obtención de recursos: con Nano Banana 2 Lite, los usuarios pueden generar rápidamente recursos e imágenes de referencia y combinarlas con imágenes propias.
• Generación de vídeo: usamos Gemini Omni Flash para crear el vídeo a partir de esos recursos.
• Edición de vídeo: tras generar el vídeo, podemos editarlo de forma conversacional.

Etapa 1: prototipado rápido con Nano Banana 2 Lite

En la primera etapa, la aplicación nos permite obtener imágenes de referencia (keyframes). Podemos subir una imagen local o generarla al vuelo. 

Aquí es donde Nano Banana 2 Lite brilla. 

Con una latencia inferior a 4 segundos y costando solo una fracción de céntimo por imagen, funciona como un sandbox ultrarrápido. Podemos prototipar decenas de estilos, composiciones y sujetos hasta dar con el keyframe perfecto.

Etapa 2: generación multimodal con Gemini Omni Flash

Una vez tenemos la imagen de referencia perfecta, pasamos a la producción de vídeo. 

La imagen de referencia y nuestro prompt de animación (por ejemplo, describiendo el movimiento de cámara, cambios de luz o acciones) se codifican en base64 y se envían a Gemini Omni Flash con la Interactions API del SDK. 

Gemini Omni Flash procesa estas entradas y devuelve un clip de alta fidelidad en formato panorámico (16:9) o vertical (9:16).

Este es el vídeo que obtuvimos:

Implementación de la app de generación de vídeo con Streamlit

Para construir la interfaz usamos Streamlit, un framework open source de Python que facilita mucho crear apps web compartibles para machine learning y data science. 

Si eres nuevo en Streamlit o quieres un repaso de cómo funciona, te recomendamos este tutorial de Streamlit en Python. 

No nos centraremos en el código de la UI, sino en la arquitectura de la canalización de generación de vídeo y en explorar las posibilidades creativas de combinar estos dos potentes modelos.

El script gemini_api.py contiene las funciones que implementamos arriba para generar imágenes y vídeos. La interfaz está hecha con Streamlit en el script app.py.

Si quieres ejecutarla en local y experimentar, haz lo siguiente:

git clone [email protected]:fran-aubry/nano-banana-2-flash-tutorial.git
pip install -r requirement.txt
streamlit run app.pyCon la tecnología de

Aquí tienes un flujo completo que combina una imagen existente de una marca de té imaginaria con una imagen generada de una plantación de té para crear un plano comercial de la lata. 

Luego editamos el vídeo usando un prompt.

El metraje se aceleró durante la generación porque estos procesos pueden tardar unos minutos.

Conclusión

Las afirmaciones de Google sobre la velocidad de su nuevo Nano Banana 2 Lite se cumplen. 

El modelo es increíblemente rápido y se acerca a algo capaz de generar imágenes en tiempo real. Aunque las imágenes que produce son buenas, no son revolucionarias. Su innovación principal es, sin duda, la velocidad, más que una calidad de imagen rompedora.

Combinados, los modelos Gemini Omni Flash y Nano Banana 2 Lite crean una canalización muy potente. Omni destaca especialmente al mantener la fidelidad con el material de referencia.

Para saber más sobre Nano Banana 2, echa un vistazo a este artículo: Nano Banana 2: guía completa con Python.

Para profundizar en la serie Gemini Omni, te recomiendo leer Gemini Omni: un modelo para texto, imagen, audio y vídeo.