Primeros pasos con Gemini Omni Flash 1.1

Copyright 2026 Google LLC.

# @title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Ejecutar en Google Colab Ver en GitHub

Gemini Omni Flash 1.1 (gemini-omni-1.1-flash) es un modelo multimodal de alto rendimiento diseñado para la generación, edición y control cinematográfico de video conversacional rápido. Gemini Omni Flash 1.1 reemplaza completamente las versiones anteriores de Gemini Omni Flash, ofreciendo una calidad de generación mejorada, multimodalidad nativa y capacidades de edición de video con estado a través de la API de Interactions:

• Multimodalidad nativa: Procesa simultáneamente texto, imagen, audio y video para un movimiento cohesivo y consistente.
• Edición conversacional: Itera y refina escenas de video a lo largo de turnos de conversación usando previous_interaction_id.
• Conocimiento del mundo: Aprovecha la profunda comprensión física, científica y cultural de Gemini para contar historias visuales ricas.

Configuración

Instalar el SDK

La API de Interactions requiere el SDK google-genai más reciente.

%pip install -U -q "google-genai>=2.10.0" # 2.10 is needed for the task parameter

Para ejecutar las siguientes celdas, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API, crea una en Google AI Studio. Para obtener instrucciones detalladas sobre las claves de API y la autenticación, consulta la guía de autenticación.

from google import genai
from google.colab import userdata

GEMINI_API_KEY = userdata.get("GEMINI_API_KEY")
client = genai.Client(api_key=GEMINI_API_KEY)

Selecciona el modelo que quieres usar en esta guía:

MODEL_ID = "gemini-omni-1.1-flash"  # @param ["gemini-omni-1.1-flash", "gemini-omni-flash-preview"] {"allow-input": true, "isTemplate": true}

Generar videos con Omni

Para generar un video puramente a partir de instrucciones de texto, llama a client.interactions.create con model=MODEL_ID y especifica "type": "video" dentro de response_format:

interaction = client.interactions.create(
    model=MODEL_ID,
    input="A golden retriever running joyfully through a field of wildflowers at sunset.",
    response_format={"type": "video"},  # Optionnal
)

Comprender las salidas de la API y el atajo .output_video

Cuando llamas a client.interactions.create(...), la API devuelve un objeto de respuesta Interaction. Debido a que Omni es nativamente multimodal y está estructurado en torno a turnos conversacionales, la respuesta contiene una secuencia ordenada de steps que representa la trayectoria de ejecución del modelo.

import json

# Trim 'data' and 'signature' fields across all steps and nested content parts
print(json.dumps([
    {**s.__dict__,
     **{k: v[:70] + '... (trimmed)' for k, v in s.__dict__.items() if k in ['data', 'signature'] and isinstance(v, str) and len(v) > 100},
     'content': [{**c.__dict__,
                  **{k: v[:70] + '... (trimmed)' for k, v in c.__dict__.items() if k == 'data' and isinstance(v, str) and len(v) > 100}}
                 for c in getattr(s, 'content', []) or []]}
    for s in interaction.steps
], indent=2))

[
  {
    "type": "thought",
    "signature": "EpcwCpQwAQw51sdIHNZALkCs5IRZCnpYdhlELCSywDOHgqahPhmAsSLONU9GcNCGhR5dhN... (trimmed)",
    "summary": null,
    "content": []
  },
  {
    "type": "model_output",
    "content": [
      {
        "type": "video",
        "data": "AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAABf5dXVpZNj+w9YbDkg8kpdYKI... (trimmed)",
        "uri": null,
        "mime_type": "video/mp4",
        "resolution": null
      }
    ],
    "error": null
  }
]

Recorriendo los pasos de salida

Cada paso en interaction.steps tiene un type:

• thought: Contiene resúmenes de razonamiento cuando el pensamiento está habilitado.
• model_output: Contiene el contenido multimedia generado final.

Dentro de un paso model_output, step.content es una lista de partes multimedia (text, image, audio o video). Puedes recorrer manualmente estas partes para inspeccionar metadatos o extraer bytes de video:

from IPython.display import Video, display

# Manually loop through steps to find the video part
for step in reversed(interaction.steps):
    if step.type == "model_output" and step.content:
        for part in reversed(step.content):
            if part.type == "video":
                display(Video(data=part.data, embed=True, mimetype=part.mime_type))
                break

<IPython.core.display.HTML object>

La propiedad de conveniencia .output_video

Para simplificar la incorporación y el scripting diario, el SDK google-genai proporciona una propiedad de atajo directo .output_video en la respuesta de interacción que siempre contiene el último video generado:

# Access the generated video directly without inspecting steps
video_part = interaction.output_video
print(video_part.mime_type)  # e.g., 'video/mp4'
display(Video(data=video_part.data, embed=True, mimetype=video_part.mime_type))

video/mp4

<IPython.core.display.HTML object>

Para simplificar los siguientes bloques de código, definamos funciones de ayuda usando IPython.display.Video y Markdown:

# @title Display helpers
import base64
from IPython.display import Image, Markdown, Video, display


def get_output_video(interaction):
    """Retrieve the video part using .output_video or manual traversal."""
    if hasattr(interaction, "output_video") and interaction.output_video:
        return interaction.output_video
    if hasattr(interaction, "steps") and interaction.steps:
        for step in reversed(interaction.steps):
            if step.type == "model_output" and step.content:
                for content in reversed(step.content):
                    if content.type == "video":
                        return content
    return None


def get_output_image(interaction):
    """Retrieve the image part using .output_image or manual traversal."""
    if hasattr(interaction, "output_image") and interaction.output_image:
        return interaction.output_image
    if hasattr(interaction, "steps") and interaction.steps:
        for step in reversed(interaction.steps):
            if step.type == "model_output" and step.content:
                for content in reversed(step.content):
                    if content.type == "image":
                        return content
    return None


def show_video(interaction, width=640):
    """Render a video output inline in Colab using Video()."""
    output = get_output_video(interaction)
    if output is None or not getattr(output, "data", None):
        print("No video content found in interaction.")
        return
    mime = getattr(output, "mime_type", "video/mp4") or "video/mp4"
    display(Video(data=output.data, embed=True, mimetype=mime))


def show_thoughts(interaction):
    """Extract and display model thinking summaries formatted as Markdown."""
    if not hasattr(interaction, "steps") or not interaction.steps:
        return
    for step in interaction.steps:
        if step.type == "thought" and getattr(step, "summary", None):
            summary_items = step.summary
            if not isinstance(summary_items, list):
                summary_items = [summary_items]
            for item in summary_items:
                text = getattr(item, "text", str(item))
                display(Markdown(f"**🤔 Thought Summary:**\n\n{text}"))

Gestionar el pensamiento y el razonamiento del modelo

Gemini Omni Flash incorpora razonamiento interno para planificar la física, la iluminación, las interacciones de objetos y el tiempo cinematográfico antes de sintetizar los fotogramas. Puedes gestionar el comportamiento de pensamiento dentro de generation_config:

• Habilitar/controlar el nivel: Establece thinking_level en 'low' o 'high' según la complejidad de la tarea. Establecer thinking_level='low' deshabilita efectivamente el razonamiento activo profundo (aunque aún ocurre una planificación mínima de la trayectoria interna), mientras que 'high' habilita el razonamiento completo de varios pasos.
• Mostrar resúmenes: Pasa thinking_summaries="auto" para instruir a la API a devolver un resumen estructurado del proceso de pensamiento del modelo dentro de un paso thought.

Prueba a generar un video stop-motion científicamente preciso con un alto razonamiento habilitado:

thinking_prompt = """
    claymation explainer of protein folding, everything is made out of clay,
    no hands, stop motion, accurate
"""

interaction_thinking = client.interactions.create(
    model=MODEL_ID,
    input=thinking_prompt,
    generation_config={
        "thinking_level": "high",
        "thinking_summaries": "auto",
    },
)

show_thoughts(interaction_thinking)
show_video(interaction_thinking)

<IPython.core.display.Markdown object>

<IPython.core.display.HTML object>

Controlar la relación de aspecto

Por defecto, Omni genera videos en formato panorámico estándar 16:9. Puedes generar videos verticales para dispositivos móviles o redes sociales estableciendo aspect_ratio en "9:16" dentro de response_format:

portrait_prompt = """
    A futuristic cyberpunk street corner at night with glowing neon rain, reflections on
    wet pavement, and flying vehicles passing overhead. Cinematic vertical establishing shot.
"""

interaction_portrait = client.interactions.create(
    model=MODEL_ID,
    input=portrait_prompt,
    response_format={
        "type": "video",  # optionnal
        "aspect_ratio": "9:16",
    },
)

show_video(interaction_portrait, width=360)

<IPython.core.display.HTML object>

Controles de resolución

Establece el parámetro resolution en response_format para controlar la calidad y velocidad del video:

• Modo borrador 360p: Genera clips de vista previa ligeros aproximadamente 2 veces más rápido con un consumo reducido de tokens.
• Alta resolución (1080p, 4k): Genera videos nítidos de alta resolución.

# Generate high-resolution (1080p) video with URI delivery
interaction_1080p = client.interactions.create(
    model=MODEL_ID,
    input="A cinematic drone shot gliding smoothly through misty pine mountains at sunrise.",
    response_format={
        "type": "video",
        "resolution": "1080p",  # Supported values: "360p", "720p", "1080p", "4k"
        "delivery": "uri"
    }
)

print(f"1080p Video Requested: {interaction_1080p.id}")

<IPython.core.display.HTML object>

Conocimiento del mundo

Aquí tienes un ejemplo que demuestra un profundo conocimiento del mundo y una precisión científica en stop-motion:

world_knowledge_prompt = """
    The video shows items of the alphabet. An unusual item starting with each
    letter is shown sitting on a table (like a Capybara for C, disco globe for D
    and Lava Lamp for L). Show 3 to 5 letters at the same time, then move to the
    next group. All 26 letters must be represented by 26 items with matching lower
    thirds displaying the letter. Rapid fire, roughly 9 frames per item at 24FPS.
    Accompanied by calm smooth music.
"""

interaction_wk = client.interactions.create(
    model=MODEL_ID,
    input=world_knowledge_prompt,
)

show_video(interaction_wk)

<IPython.core.display.HTML object>

Imagen a video

Generar imágenes de referencia

En lugar de depender de archivos externos o gráficos rudimentarios, puedes usar el modelo de generación de imágenes de Gemini (Nano-Banana 2 Lite, a través de gemini-3.5-flash-lite-image) para generar rápidamente ilustraciones de referencia personalizadas de alta calidad en formato 16:9:

prompt = "Create a vibrant, detailed pixel art illustration of a cheerful robot adventurer holding a glowing amber lantern in an ancient crystal cavern." # @param {type:"string"}

# Generate a custom 16:9 reference image using Nano-Banana
interaction_img = client.interactions.create(
    model="gemini-3.5-flash-lite-image",
    input=prompt,
    response_modalities=["image"],
    generation_config={"image_config": {"aspect_ratio": "16:9"}},
)

# Extract image using .output_image or helper
image_part = get_output_image(interaction_img)

display(Markdown("**Generated 16:9 Nano-Banana Reference Image:**"))
if isinstance(image_part.data, str):
    display(Image(data=base64.b64decode(image_part.data)))
else:
    display(Image(data=image_part.data))

<IPython.core.display.Markdown object>

<IPython.core.display.Image object>

Imagen a video (primer fotograma)

Para crear un video que comience desde la imagen personalizada que generaste, pasa tanto la imagen como tus instrucciones de animación a input.

Observa que input está estructurado como una lista de diccionarios con diferentes tipos ({"type": "image", ...} emparejado con {"type": "text", ...}). Esta lista de entrada multimodal te permite combinar composiciones visuales de inicio explícitas con instrucciones de animación en lenguaje natural simultáneamente:

animate_prompt = "Animate the robot raising its lantern high as shimmering crystal dust swirls gently around the cavern." # @param {type:"string"}

interaction_i2v = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {
            "type": "text",
            "text": animate_prompt,
        },
    ],
)

show_video(interaction_i2v)

<IPython.core.display.HTML object>

Transición directa de múltiples turnos de Nano-Banana a Omni

Debido a que Nano-Banana (gemini-3.5-flash-lite-image) y Omni Flash comparten la API de Interactions unificada, puedes omitir la extracción de bytes de imagen sin procesar por completo. En su lugar, pasa previous_interaction_id=interaction_img.id directamente a Omni Flash para animar suavemente la imagen creada en tu turno anterior:

animate_prompt = "Everything shakes as the cavern crumbles and and a dragon wakes up." # @param {type:"string"}

# Transition directly from Nano-Banana interaction_img.id into Omni Flash
interaction_nb_turn = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=interaction_img.id,
    input=animate_prompt,
)

show_video(interaction_nb_turn)

<IPython.core.display.HTML object>

Referencia(s) a video

En los flujos de trabajo de Referencia a Video, la imagen proporcionada no se usa como el fotograma inicial literal. En su lugar, el modelo extrae el sujeto, la identidad del personaje o la composición artística y la incrusta en un entorno o perspectiva de cámara completamente diferente.

En este ejemplo, observa cómo nuestra ilustración de robot de Nano-Banana se extrae como sujeto de referencia y se representa como una pintura enmarcada que cuelga dentro de una acogedora habitación victoriana:

ref_prompt = "A continuous handheld shot moving slowly through a cozy Victorian study with warm fireplace lighting. Hanging framed on the wooden wall is a painting depicting the exact scene from the reference image." # @param {type:"string"}

interaction_ref = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {"type": "text", "text": ref_prompt},
    ],
    generation_config={"video_config": {"task": "reference_to_video"}},
)

show_video(interaction_ref)

<IPython.core.display.HTML object>

Interpolación de fotogramas clave

Genera video continuo que transiciona suavemente entre un fotograma inicial y un fotograma final. Esto es ideal para órbitas de cámara, efectos de zoom, progresiones de timelapse y clips de bucle sin interrupciones.

# Keyframe interpolation with start and end frames
# The task parameter is optional. If omitted, the model automatically infers the mode.
interaction_interp = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {"type": "text", "text": "Smooth continuous timelapse from sunrise to sunset over a mountain lake."}
    ],
    generation_config={
        "video_config": {
            "task": "image_to_video"
        }
    },
    response_format={"type": "video"}
)

print(f"Interpolation Interaction ID: {interaction_interp.id}")

<IPython.core.display.HTML object>

Avanzado: Controlar los fotogramas iniciales frente a las referencias (parámetro task)

Cuando se le dan imágenes y texto, Omni Flash infiere si usar una imagen como el fotograma de apertura literal (image_to_video) o como una referencia indirecta de estilo/sujeto (reference_to_video). Ocasionalmente, las indicaciones multimodales ambiguas pueden hacer que el modelo confunda una imagen de referencia con un fotograma inicial literal.

Para garantizar una ejecución precisa en los pipelines de producción, establece explícitamente el parámetro task dentro de generation_config.video_config en "image_to_video" o "reference_to_video".

Nota importante: Especificar un parámetro task explícito fuerza un flujo de trabajo de generación independiente y te impide encadenar ediciones usando previous_interaction_id.

# Explicit task parameter example
task_prompt = "A dragon's lair, but who's footsteps do we hear?" # @param {type:"string"}
interaction_task = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {"type": "text", "text": task_prompt},
    ],
    generation_config={"video_config": {"task": "image_to_video"}},
)

show_video(interaction_task)

<IPython.core.display.HTML object>

# Explicit task parameter example
task_prompt = "A dragon's lair, but who's footsteps do we hear?" # @param {type:"string"}
interaction_task = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": image_part.data, "mime_type": image_part.mime_type},
        {"type": "text", "text": task_prompt},
    ],
    generation_config={"video_config": {"task": "reference_to_video"}},
)

show_video(interaction_task)

<IPython.core.display.HTML object>

Avanzado: Usar etiquetas de referencia para controlar ejemplos complejos

Para escenas intrincadas con múltiples sujetos, usa etiquetas de referencia explícitas dentro de tu prompt de texto para vincular imágenes subidas específicas a roles distintos:

• <FIRST_FRAME>: Vincula la imagen como el fotograma de apertura exacto del clip.
• <IMAGE_REF_0>, <IMAGE_REF_1>, etc.: Vincula imágenes (indexadas desde 0, coincidiendo con el orden en input) a identidades de personajes, objetos o prendas de vestir específicos.

Omni Flash admite la combinación de hasta 5 imágenes de referencia en una sola llamada. Usa Nano-Banana 2 Lite (gemini-3.5-flash-lite-image) a continuación para generar 3 personajes distintos junto con 3 accesorios a juego (6 imágenes en total), y luego combínalos en una escena unificada de fogata donde cada personaje usa su accesorio a juego:

# Generate 3 distinct characters and 3 matching accessories using Nano-Banana
char1 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed digital illustration of a cheerful golden retriever puppy sitting happily on a plain white background.", response_modalities=["image"])
acc1 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed illustration of a flowing bright red superhero cape on a plain white background.", response_modalities=["image"])
char2 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed digital illustration of a wise little brown owl perched on a plain white background.", response_modalities=["image"])
acc2 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed illustration of antique brass steampunk goggles on a plain white background.", response_modalities=["image"])
char3 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed digital illustration of a friendly orange tabby cat sitting on a plain white background.", response_modalities=["image"])
acc3 = client.interactions.create(model="gemini-3.5-flash-lite-image", input="Create a detailed illustration of a pointed blue wizard hat decorated with golden stars on a plain white background.", response_modalities=["image"])

img_c1, img_a1 = get_output_image(char1), get_output_image(acc1)
img_c2, img_a2 = get_output_image(char2), get_output_image(acc2)
img_c3, img_a3 = get_output_image(char3), get_output_image(acc3)

def to_bytes(part):
    return base64.b64decode(part.data) if isinstance(part.data, str) else part.data

display(Markdown("**6 Nano-Banana Reference Images (3 Characters + 3 Accessories):**"))
display(Image(data=to_bytes(img_c1)))
display(Image(data=to_bytes(img_a1)))
display(Image(data=to_bytes(img_c2)))
display(Image(data=to_bytes(img_a2)))
display(Image(data=to_bytes(img_c3)))
display(Image(data=to_bytes(img_a3)))

<IPython.core.display.Markdown object>

<IPython.core.display.Image object>

<IPython.core.display.Image object>

<IPython.core.display.Image object>

<IPython.core.display.Image object>

<IPython.core.display.Image object>

<IPython.core.display.Image object>

Combina las seis referencias en una escena unificada usando las etiquetas <IMAGE_REF_0> a <IMAGE_REF_5>:

multi_char_prompt = """
    In a single unbroken scene around a twilight campfire in a forest:
    <IMAGE_REF_0> is wearing <IMAGE_REF_5>,
    <IMAGE_REF_2> is wearing <IMAGE_REF_3>,
    and <IMAGE_REF_4> is wearing <IMAGE_REF_1>.
    They smile happily together as embers float into the evening sky.
"""

interaction_6refs = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "image", "data": img_c1.data, "mime_type": img_c1.mime_type},
        {"type": "image", "data": img_a1.data, "mime_type": img_a1.mime_type},
        {"type": "image", "data": img_c2.data, "mime_type": img_c2.mime_type},
        {"type": "image", "data": img_a2.data, "mime_type": img_a2.mime_type},
        {"type": "image", "data": img_c3.data, "mime_type": img_c3.mime_type},
        {"type": "image", "data": img_a3.data, "mime_type": img_a3.mime_type},
        {"type": "text", "text": multi_char_prompt},
    ],
    generation_config={"video_config": {"task": "reference_to_video"}},
)

show_video(interaction_6refs)

<IPython.core.display.HTML object>

Observa cómo Omni Flash vinculó con precisión cada par de imágenes subidas a su respectivo personaje y accesorio: el cachorro de golden retriever (<IMAGE_REF_0>) lleva el sombrero de mago azul estrellado (<IMAGE_REF_5>), el búho marrón (<IMAGE_REF_2>) lleva las gafas steampunk (<IMAGE_REF_3>), y el gato atigrado naranja (<IMAGE_REF_4>) lleva la capa roja de superhéroe (<IMAGE_REF_1>), todos interactuando naturalmente en un entorno de fogata compartido sin mezclar identidades.

Extensión de video

Extiende un video existente generando una continuación sin interrupciones al final del clip. Describe cómo quieres que el video continúe en tu prompt, por ejemplo "Extend this video" o "Continue the scene: the camera pans across the mountains". Gemini Omni Flash analiza hasta 10 segundos de contexto previo para generar una continuación natural de 3 a 10 segundos, manteniendo la continuidad temporal, la identidad del personaje, el impulso de la cámara y la iluminación ambiental.

Puedes extender:

• Videos generados por el modelo (varios turnos): Extiende un video generado previamente haciendo referencia a su previous_interaction_id.
• Videos subidos: Proporciona un archivo de video subido (a través de la API de Files) junto con tu prompt de extensión.

⚠️ Importante: Restricciones y pautas de extensión de video

• Solo añadir: La extensión se limita estrictamente a añadir al final de un video. No se admite añadir contenido al principio o extender el medio de un clip.
• Límite de duración: Los videos de entrada para la extensión deben tener una duración de 10 segundos o menos al subirlos (a menos que se extiendan videos generados por el modelo en varios turnos).
• Diálogo hablado en videos subidos: Actualmente, no puedes extender un video subido donde alguien está hablando para añadir diálogo adicional (se admite si el personaje permanece en silencio o si el prompt no añade diálogo).
• Extensión de voz en varios turnos: La generación de diálogo hablado o voz es totalmente compatible al extender videos generados previamente a través de varios turnos (previous_interaction_id).
• Disponibilidad regional: La extensión de videos subidos no está actualmente disponible para usuarios en el Espacio Económico Europeo (EEE), Suiza y el Reino Unido (la extensión de videos generados por el modelo es compatible en todas las regiones disponibles).
• Prompting vs. task="extend": Recomendamos confiar principalmente en el prompting en lenguaje natural. Opcionalmente, puedes establecer "task": "extend" bajo generation_config.video_config si el prompting por sí solo no produce el modo de extensión esperado, pero ten en cuenta que el campo task explícito añade restricciones estrictas (como deshabilitar las entradas de referencia multimodales).

Ejemplo 1: Extensión en varios turnos (continuación de cámara y escena)

Primero, genera un clip de video base. Luego, extiende la escena a lo largo de los turnos de conversación pasando previous_interaction_id:

# Generate the base video (Turn 1)
turn1_prompt = "[0-10s] Single unbroken continuous camera shot from a locked perspective gliding forward along a scenic coastal road at sunset. A sleek silver sports car cruises smoothly in front of the camera. Completely continuous unbroken take."  # @param {type:"string"}
turn1 = client.interactions.create(
    model=MODEL_ID,
    input=turn1_prompt,
    response_format={"type": "video"},
)

print("Base Video (Turn 1):")
show_video(turn1)

<IPython.core.display.HTML object>

# Extend the shot from Turn 1 using prompt-based extension
# The model analyzes the prior interaction and seamlessly appends a continuation
extended_turn2 = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=turn1.id,
    input="Continue the shot: the car turns smoothly onto a scenic coastal bridge at twilight as distant lighthouses begin to glow.",
    response_format={"type": "video"},
)

print(f"Extended Video ID: {extended_turn2.id}")
show_video(extended_turn2)

<IPython.core.display.HTML object>

Ejemplo 2: Extensión en varios turnos con medios de referencia

La extensión basada en prompts te permite proporcionar imágenes o videos de referencia en el array input junto con previous_interaction_id para introducir nuevos personajes, objetos o estilos sin problemas en la escena extendida:

# Generate a reference image for an asset or character to introduce
ref_traveler = client.interactions.create(
    model="gemini-3.1-flash-lite-image",
    input="A cheerful traveler with a yellow backpack standing by the side of a coastal highway, plain white background.",
    response_modalities=["image"],
)
traveler_img = ref_traveler.output_image

# Extend the previous video while introducing the reference subject
extended_with_ref = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=extended_turn2.id,
    input=[
        {"type": "image", "data": traveler_img.data, "mime_type": traveler_img.mime_type},
        {"type": "text", "text": "[0-10s] The single continuous tracking shot continues unbroken from the exact same camera perspective behind the car. The silver sports car gently slows down as it approaches the shoulder of the road. Ahead on the roadside, the traveler shown in <IMAGE_REF_0> with her yellow backpack comes into view standing by the railing and waves cheerfully."}
    ],
    response_format={"type": "video"},
)

print(f"Extended with Reference ID: {extended_with_ref.id}")
show_video(extended_with_ref)

<IPython.core.display.HTML object>

Ejemplo 3: Extender un archivo de video subido (API de Files)

También puedes extender tu propio material de video externo o pregrabado (10 segundos o menos) subiéndolo a través de la API de Files y pasando su URI a la API de Interactions:

import time

# 1. Save and upload a source clip (must be 10 seconds or less)
upload_video_path = "sample_clip.mp4"  # @param {type:"string"}

# Save our base video locally to demonstrate uploading an external file:
with open(upload_video_path, "wb") as f:
    f.write(base64.b64decode(get_output_video(turn1).data))

video_file = client.files.upload(file=upload_video_path)

while video_file.state.name == "PROCESSING":
    time.sleep(5)
    video_file = client.files.get(name=video_file.name)

# 2. Extend the uploaded video file
extended_uploaded = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "text", "text": "Extend this video: the car accelerates smoothly forward along the empty highway as twilight fades into starry night."}
    ],
    response_format={"type": "video"},
)

print(f"Extended Uploaded Video ID: {extended_uploaded.id}")
show_video(extended_uploaded)

<IPython.core.display.HTML object>

Edición de video conversacional en varios turnos

Una de las capacidades más potentes de Omni es la edición de video conversacional en varios turnos. Usando el parámetro previous_interaction_id, puedes refinar iterativamente un clip generado a lo largo de múltiples turnos de conversación. El modelo mantiene el contexto de estado completo, aplicando modificaciones específicas mientras preserva la continuidad visual.

Edita el video anterior describiendo solo los cambios a realizar:

# Edit the previous generation by referencing turn1.id
turn2_prompt = "Change the car color to metallic blue. Keep everything else the same."  # @param {type:"string"}
turn2 = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=turn1.id,
    input=turn2_prompt,
)

print("Turn 2 Video (Edited):")
show_video(turn2)

<IPython.core.display.HTML object>

Editar videos subidos

También puedes editar tu propio material de video del mundo real subiéndolo a través de la API de Files y pasando su URI a la API de Interactions.

Nota: La edición de videos de usuario subidos no está actualmente disponible para usuarios en el Espacio Económico Europeo (EEE), Suiza y el Reino Unido (la edición de clips generados por IA como se muestra arriba es compatible en todo el mundo).

import time

file_name = "my_clip.mp4" # @param {type:"string"}

video_file = client.files.upload(file=file_name)

while video_file.state.name == "PROCESSING":
    time.sleep(5)
    video_file = client.files.get(name=video_file.name)

interaction_edit = client.interactions.create(
    model=MODEL_ID,
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "text", "text": "Change the style of the video for a japanese animation. Keep main subject unchanged."},
    ],
)

show_video(interaction_edit)

<IPython.core.display.HTML object>

Recuperación de videos mediante entrega de URI (delivery="uri")

Al generar videos en entornos de producción, el beneficio clave de solicitar delivery="uri" dentro de response_format es la fiabilidad de la conexión y la resiliencia de la red. Si bien la entrega en línea estándar transmite datos base64 directamente a tu cliente, una interrupción temporal de la red o una actualización de la pestaña del navegador podría interrumpir la transmisión y perder el medio generado.

Al especificar delivery="uri", la API aloja el video terminado de forma segura en el almacenamiento de Google Cloud y devuelve un identificador de archivo persistente. Tu aplicación puede sondear el estado de procesamiento y descargar el video de forma fiable, independientemente de las caídas de red:

import time

# 1. Request video with URI delivery for connection resilience
interaction_uri = client.interactions.create(
    model=MODEL_ID,
    input="A sweeping aerial drone shot of snowy mountain peaks at sunrise in a single unbroken scene.",
    response_format={
        "type": "video",
        "delivery": "uri"
    },
)

# 2. Extract file name and poll for ACTIVE state
video_output = interaction_uri.output_video
video_uri = video_output.uri
video_bytes = client.files.download(file=video_uri)
with open("mountain_sunrise.mp4", "wb") as f:
    f.write(video_bytes)

print(f"Downloaded mountain_sunrise.mp4 successfully from {video_uri}.")
display(Video("mountain_sunrise.mp4", embed=True))

Downloaded mountain_sunrise.mp4 successfully from https://generativelanguage.googleapis.com/v1beta/files/mwbiec5quubp:download?alt=media.

<IPython.core.display.HTML object>

Guía de prompts y mejores prácticas

Para aprovechar al máximo Gemini Omni Flash, aplica estas técnicas de prompting estructuradas:

Consejo 1: Continuidad de una sola escena

Por defecto, Omni puede introducir cortes cinematográficos de múltiples tomas para construir dinamismo narrativo. Para forzar una perspectiva continua de una sola cámara, especifica explícitamente:

• "In a single unbroken scene..."
• "Continuous handheld shot, no scene cuts..."

tip1_prompt = "Continuous unbroken handheld shot of an ornate antique golden pocket watch resting on an open leather notebook, its second hand ticking smoothly forward." # @param {type:"string"}

interaction_tip1 = client.interactions.create(
    model=MODEL_ID,
    input=tip1_prompt,
)

show_video(interaction_tip1)

<IPython.core.display.HTML object>

Consejo 2: Instrucciones negativas

Si aparecen elementos no deseados, establece prohibiciones claras directamente en lenguaje natural:

• "No dialogue or voiceover."
• "No text overlay on screen."

tip2_prompt = "A peaceful campfire glowing softly in a misty forest at dusk. No dialogue or voiceover. No text overlay on screen." # @param {type:"string"}

interaction_tip2 = client.interactions.create(
    model=MODEL_ID,
    input=tip2_prompt,
    response_format={"type": "video"},
)

show_video(interaction_tip2)

<IPython.core.display.HTML object>

Consejo 3: Prompts de edición concisos

Al realizar ediciones en varios turnos, mantén las instrucciones simples y precisas. Las descripciones excesivamente largas pueden confundir el motor de diferenciación.

• Haz: "Change the car color to metallic blue. Keep everything else the same."
• No hagas: "In the video showing the silver car driving down the road, please replace the silver paint with a metallic blue shade while making sure..."

# Surgical multi-turn edit example
edit_prompt = "Add glowing purple neon underglow lights under the car. Keep everything else the same." # @param {type:"string"}
interaction_edit = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=turn1.id,
    input=edit_prompt,
)
show_video(interaction_edit)

<IPython.core.display.HTML object>

Consejo 4: Sincronización y coreografía cronológica

Puedes solicitar que las acciones ocurran en momentos específicos dentro de tu video usando descripciones en lenguaje natural o sintaxis de código de tiempo entre corchetes ([0-3s], [3-6s]). Esto te da control directorial total sobre el ritmo de la escena, el ritmo y la narración de múltiples tiempos:

• Sincronización en lenguaje natural: "after 3 seconds, a woman enters the scene", "at 5s the chorus starts in the background audio".
• Sintaxis de código de tiempo entre corchetes: "[0-3s] A person is walking. [3-6s] They stop and turn around. [6-10s] They start running."

timing_prompt = "[0-3s] A continuous handheld shot of a woman in a red coat standing still on a snowy city sidewalk looking forward. [3-6s] She slowly opens a bright yellow umbrella as soft snowflakes fall around her." # @param {type:"string"}

interaction_timing = client.interactions.create(
    model=MODEL_ID,
    input=timing_prompt,
    response_format={"type": "video"},
)

show_video(interaction_timing)

<IPython.core.display.HTML object>

Consejo 5: Comprensión de momentos clave

También puedes pedirle al modelo que edite el video cuando ocurra alguna acción específica.

tip5_turn1_prompt = "A person stands in front of a mirror. At 0:05, she touches the mirror then she does it again at 0:07, 0:08 and 0:09" # @param {type:"string"}
tip5_turn1 = client.interactions.create(
    model=MODEL_ID,
    input=tip5_turn1_prompt,
)

print("Turn 1 Video (Base):")
show_video(tip5_turn1)

Turn 1 Video (Base):

<IPython.core.display.HTML object>

tip5_turn2_prompt = "The style of the video changes every time the person touches the mirror" # @param {type:"string"}
tip5_turn2 = client.interactions.create(
    model=MODEL_ID,
    input=tip5_turn2_prompt,
    previous_interaction_id=tip5_turn1.id,
)

print("Turn 2 Video (Edited):")
show_video(tip5_turn2)

Turn 2 Video (Edited):

<IPython.core.display.HTML object>

Veo vs. Omni: Elegir el modelo adecuado

Google ofrece dos familias de modelos de generación de video principales: Gemini Omni Flash y Veo. Comprender sus arquitecturas distintas te ayuda a seleccionar la herramienta adecuada para tu aplicación.

Cuándo preferir Gemini Omni Flash:

• Flujos de trabajo conversacionales: Edición iterativa en varios turnos donde los usuarios refinan clips a través del diálogo.
• Razonamiento complejo: Prompts que requieren un profundo conocimiento del mundo, comprensión de la física o fusión multimodal.
• Referencia rica: Tareas que combinan múltiples personajes de referencia, imágenes de productos y guías de estilo.

Cuándo seguir usando Veo:

• Economía de alto rendimiento: Veo 3.1 Lite ofrece la relación calidad-costo más competitiva para la generación de clips por lotes.
• Requisitos de resolución: Pipelines de salida de ultra alta definición 1080p y 4K.
• Tareas de video estructurales: Flujos de trabajo de extensión de video e interpolación de fotogramas de principio a fin.
• Síntesis de clips pura: Pipelines automatizados que requieren clips B-roll independientes sin cortes de toma o sobrecarga conversacional.

Próximos pasos

• Explora la Descripción general de la API de Interactions oficial.
• Lee la Documentación de Gemini Omni y la Documentación de Veo.
• Revisa los Precios de la API de Gemini para los niveles de generación de video.
• Consulta la Introducción al diseño de prompts para estrategias avanzadas de prompting.