Der komplette Guide zu Nano Banana 2 Lite und Gemini Omni Flash: Medien-Pipelines in Python

Was ist Nano Banana 2 Lite?

Nano Banana 2 Lite (gemini-3.1-flash-lite-image) ist Googles bisher schnellstes und kosteneffizientestes Modell zur Bildgenerierung. 

Es wurde speziell für schnelle Developer-Pipelines und Anwendungen mit hohem Durchsatz entwickelt und ist für Szenarien optimiert, in denen geringe Latenz und enge Budgets entscheidend sind.

Für Plattformen, die aktuell Googles Legacy-Modell (gemini-2.5-flash-image) nutzen, ist Nano Banana 2 Lite ein nahtloser Drop-in-Ersatz und liefert sofort sichtbare Verbesserungen bei Geschwindigkeit, Kosten und visueller Qualität.

Wichtige Leistungskennzahlen

• Extrem geringe Latenz: Liefert Text-zu-Bild-Ergebnisse in etwa 4 Sekunden – ideal für interaktives Prototyping und Echtzeitanwendungen.
• Kosteneffizienz: Zum Preis von $0,034 pro Bild in 1K-Auflösung senkt es die Hürden für hohe Volumina deutlich.
• Qualitätserhalt: Trotz Fokus auf Geschwindigkeit hält das Modell Prompts zuverlässig ein, rendert Charaktere konsistent und generiert stabil lesbaren Text im Bild.

Was ist Gemini Omni Flash?

Gemini Omni Flash (gemini-omni-flash-preview) ist Googles kosteneffizientes Modell für Videogenerierung und dialogbasierte Videobearbeitung.

Anders als reine Videogeneratoren, die strikt auf statischen Textprompts basieren, bringt Omni Flash Geminis multimodales Reasoning direkt in den Videoprozess. 

Es akzeptiert nativ Kombinationen aus Text-, Bild- und Videoeingaben und erlaubt so eine programmatische Steuerung der Videogenerierung mit bislang unerreichter Präzision.

Kernfunktionen und Preise von Omni Flash

• Wettbewerbsfähige Preise: $0,10 pro Sekunde Videoausgabe – identisch mit Veo 3.1 Fast.
• Dialogbasierte Videobearbeitung: Statt komplette Videos für kleine Anpassungen neu zu rendern, lassen sich Sequenzen mit natürlichen Sprachbefehlen verfeinern.
• Multimodale Referenzen: Textprompts können mit Referenzbildern oder -clips kombiniert werden, um visuelle Konsistenz und feine Kontrolle über Szenenelemente sicherzustellen.
• Realitätsnahe Physik: Dank des Grundwissens von Gemini erzeugt das Modell realistische Animationen basierend auf Logik und Physik.
• Synchronisation von Text und Aktion: On-Screen-Text und grafische Overlays lassen sich per einfachem Prompt direkt mit Videoaktionen verknüpfen.

So erzeugst und richtest du einen Gemini API-Schlüssel ein

Bevor wir die Gemini API nutzen, brauchen wir einen API-Schlüssel, damit unser Code mit der API kommunizieren kann.

Am einfachsten gehst du so vor:

• Besuche die API-Key-Seite von Google AI Studio und melde dich an.
• Klicke oben rechts auf „Create API key“.
• Kopiere den API-Schlüssel in eine Datei namens .env im selben Ordner wie der Python-Code, und zwar in folgendem Format:

GEMINI_API_KEY=replace_with_api_keyBereitgestellt von

Hinweis: Die Nutzung der API verursacht Kosten. Um sie zu verwenden, musst du eine Zahlungsmethode auf der Abrechnungsseite von Google AI Studio hinterlegen.

So generierst du Bilder mit Nano Banana 2 Lite in Python

Voraussetzungen für KI-Bildgenerierung in Python

Bevor wir mit dem Python-Bildgenerator starten, sollten folgende Tools bereitstehen:

• Python 3.9+ ist installiert.
• Google Gemini API Key: Ein gültiger Google Gemini API-Schlüssel zur Authentifizierung. Siehe oben für Erstellung und Konfiguration.
• Erforderliche Python-Bibliotheken: Wir verwenden das offizielle google-genai-SDK für die API-Integration sowie Pillow zur Bildverarbeitung.

Die notwendigen Pakete installierst du mit pip:

pip install google-genai pillow python-dotenvBereitgestellt von

Schritt 1: Module importieren und Umgebungsvariablen laden

Lege eine neue Datei an (z. B. generate_image.py) und füge folgende Imports und Lade-Sequenz hinzu, um die Umgebung zu initialisieren:

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()Bereitgestellt von

Schritt 2: Google GenAI-Client initialisieren

Um mit dem Nano Banana 2 Lite Modell zu interagieren, initialisieren wir zuerst den Google GenAI-Client. 

Da das SDK automatisch die Umgebungsvariable GEMINI_API_KEY prüft (die im vorherigen Schritt aus der .env-Datei geladen wurde), können wir den Client ohne explizite Übergabe des Schlüssels initialisieren.

# Initialize the Gemini API client
client = Client()Bereitgestellt von

Schritt 3: Die Bildgenerierungsfunktion schreiben

Jetzt kommt die Kernlogik unseres Python-Skripts. Wir schreiben eine Funktion generate_image(), die den initialisierten Client und einen Text-Prompt entgegennimmt.

Nano Banana 2 Lite wird über model="gemini-3.1-flash-lite-image" aufgerufen. Wir konfigurieren die Anfrage so, dass ein Bild als Antwort erwartet wird und legen das gewünschte Seitenverhältnis fest.

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 NoneBereitgestellt von

Die Bildanfrage in Python verstehen:

• response_modalities: Erzwingt, dass das Google Gemini-Modell ein Bild statt Text zurückgibt.
• inline_data: Die Gemini API liefert das generierte Bild als Rohbytes. Mit io.BytesIO verpacken wir die Bytes, sodass Pillow (Image.open) sie als Bilddatei lesen kann.
• image_config: Wir setzen das aspect_ratio auf "1:1" (quadratisch). Je nach Anwendungsfall lässt sich das leicht ändern.

Unterstützte Seitenverhältnisse:

Schritt 4: Das Skript zur Bildgenerierung ausführen

Setzen wir alles zusammen und lassen Nano Banana 2 Lite ein Bild generieren! 

Wir geben einen kreativen Prompt, rufen show() auf, um das KI-generierte Bild anzuzeigen, und schließen den Client zum Freigeben der Ressourcen.

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()Bereitgestellt von

Hier ist das von Nano Banana 2 Flash generierte Bild:

Wie in Googles Ankündigung versprochen, dauerte die Generierung nur wenige Sekunden. Auf den ersten Blick wirkt es deutlich schneller als alle Modelle, die ich bisher ausprobiert habe.

Das vollständige Skript findest du im generate_image.py-Skript im Repository zu diesem Tutorial.

Das Skript zur Bildbearbeitung erweitern

Schreiben wir eine Funktion edit_image(), die ein Bild bearbeitet. Dafür müssen wir in der Anfrage lediglich das Bild zusammen mit dem Prompt im Parameter contents als Liste [image, prompt] übergeben.

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 NoneBereitgestellt von

Nano Banana 2 Flash im Test

Wir haben die Praxisleistung des Modells mit einer Reihe gezielter Stresstests evaluiert. 

Dabei lag der Fokus auf komplexen visuellen Aufgaben wie lesbarer Text im Bild, strenge räumliche Layouts und Konsistenz über mehrere Interaktionen hinweg – um zu prüfen, ob das Modell sein Versprechen einer hochqualitativen Generierung bei hoher Geschwindigkeit einlöst.

Lesbare Textgenerierung im Bild testen

Strenge räumliche Kontrolle und Einhaltung von zwei Motiven testen

Schnelles UI-Prototyping und Layoutpräzision testen

Komplexe Materialkontraste und Beleuchtung testen

Mehrstufige Charakterkonsistenz testen

Ehrlich gesagt bin ich für ein so schnelles Modell ziemlich beeindruckt. Im letzten Beispiel hat das Modell sogar die Textkonsistenz in der Zeitung einigermaßen beibehalten. 

Aus meiner Erfahrung ist Konsistenz einer der wichtigsten Faktoren, damit ein Bildgenerierungsmodell in der Praxis wirklich nützlich ist.

So generierst du Videos mit Gemini Omni Flash in Python

In diesem Abschnitt bauen wir ein Python-Skript zur Videogenerierung: Zuerst ein einfaches Text-zu-Video-Beispiel, danach erweitern wir es um Referenzbilder.

Im Gegensatz zur Bildgenerierung erfolgt die Videogenerierung mit Gemini Omni Flash über die Interactions API des SDK (client.interactions.create). Dieser Endpunkt ist speziell für reichhaltige, mehrstufige und multimodale Interaktionen ausgelegt.

Da Imports, Umgebungsvariablen und Client-Initialisierung identisch mit dem Bildteil sind, konzentrieren wir uns direkt auf die Videofunktionen.

Schritt 1: Text-zu-Video (einfaches Prompt-to-Video)

Um ein Video nur aus einem Textprompt zu erzeugen, übergeben wir einen einzelnen Textblock an die Interactions API. Eine einfache Python-Funktion dafür sieht so aus:

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 interactionBereitgestellt von

Wir rufen die Funktion auf und speichern die Videodaten als Datei:

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.")Bereitgestellt von

Der verwendete Prompt war:

Generate a first-person view of what daily life would look like in the year 1000 at this location: 41.89030621184054, 12.492266126772481Bereitgestellt von

Dieser Ort ist das Römische Kolosseum. Ich habe Koordinaten genutzt, um das Weltwissen des Modells zu testen. Das ist das generierte Video:

Zum Vergleich: So sah das Ergebnis aus, als ich das Jahr 1000 durch 1980 ersetzt habe:

Ziemlich spannend, wie ich finde. Sieh dir die Datei text_to_video.py an, um das vollständige Skript zu sehen.

Schritt 2: Image-to-Video-Fähigkeiten implementieren

Um ein statisches Bild zu animieren oder es als Referenz für die Videogenerierung zu nutzen, übergeben wir Bild und Textprompt gemeinsam an das Modell.

Da die Interactions API Bilder base64-codiert erwartet, definieren wir zuerst eine Hilfsfunktion, die PIL-Images in Base64-Strings umwandelt:

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()Bereitgestellt von

Nun bauen wir eine allgemeinere Funktion generate_video(), die optionale Bilder und den Textprompt verarbeitet.

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 interactionBereitgestellt von

Abschließend ein Beispiel, wie wir damit ein von Gemini generiertes Käferbild animieren:

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)Bereitgestellt von

Das ist das erzeugte Video:

Das vollständige Skript findest du hier.

Schritt 3: Videobearbeitung mit Video-to-Video umsetzen

Die dialogbasierte Bearbeitung mit der Gemini Omni Flash API ist dank der Interactions äußerst einfach. Bei der Generierung erhalten wir eine Interaktions-ID unter interaction.id. 

Zur Bearbeitung geben wir dann einen Prompt und die ID der vorherigen Interaktion an. Beim ersten Edit ist das die ID der ursprünglichen Generierung, danach jeweils die der letzten Bearbeitung.

client.interactions.create(
        model="gemini-omni-flash-preview",
        input=edit_prompt,
        previous_interaction_id=previous_interaction_id,
)Bereitgestellt von

Ein interaktives KI-Video-Studio bauen: Architektur und Multimodell-Synergien

In den vorherigen Abschnitten haben wir gesehen, wie sich Bilder mit Nano Banana 2 Lite und Videos mit Gemini Omni Flash programmatisch erzeugen lassen. Jetzt führen wir beides in einer interaktiven Web-App zusammen: dem AI Video Studio.

Die Architektur des AI Video Studio

Hochwertige KI-Videos erfordern oft viel Trial-and-Error. Das AI Video Studio löst das mit einer zweistufigen Multimodell-Pipeline, die die Stärken zweier Modelle ausspielt:

• Asset-Erstellung: Mit Nano Banana 2 Lite generieren Nutzende schnell Ressourcen und Referenzbilder und kombinieren sie mit vorhandenen Bildern.
• Videogenerierung: Auf Basis dieser Assets generieren wir mit Gemini Omni Flash das Video.
• Videobearbeitung: Nach der Generierung bearbeiten wir das Video dialogbasiert weiter.

Stufe 1: Schnelles Prototyping mit Nano Banana 2 Lite

In der ersten Stufe beschaffen wir Referenzbilder (Keyframes). Wir können lokale Bilder hochladen oder ad hoc generieren. 

Hier spielt Nano Banana 2 Lite seine Stärken aus. 

Mit unter 4 Sekunden Latenz und Kosten im Bruchteil eines Cents pro Bild ist es ein ultraschneller Spielplatz. So können wir in kürzester Zeit dutzende Stile, Kompositionen und Motive ausprobieren, bis das perfekte Keyframe steht.

Stufe 2: Multimodale Generierung mit Gemini Omni Flash

Sobald das perfekte Referenzbild steht, geht es in die Videoproduktion. 

Das Referenzbild und unser Animationsprompt (z. B. Kamerabewegung, Lichtwechsel oder Aktionen) werden base64-codiert und über die Interactions API des SDK an Gemini Omni Flash gesendet. 

Gemini Omni Flash verarbeitet die Eingaben und liefert einen hochqualitativen Clip im Querformat (16:9) oder Hochformat (9:16).

Hier ist das Ergebnisvideo:

Streamlit-App zur Videogenerierung

Für die Oberfläche nutzen wir Streamlit – ein beliebtes Open-Source-Python-Framework, mit dem sich ML- und Data-Science-Apps extrem einfach bauen und teilen lassen. 

Wenn du neu bei Streamlit bist oder eine Auffrischung brauchst, empfehlen wir dieses Python Streamlit Tutorial. 

Wir konzentrieren uns hier nicht auf den Streamlit-UI-Code, sondern auf die Architektur der Videopipeline und die kreativen Möglichkeiten der Kombination beider Modelle.

Das Skript gemini_api.py enthält die oben implementierten Funktionen für Bild- und Videogenerierung. Die Benutzeroberfläche ist in app.py mit Streamlit umgesetzt.

Wenn du es lokal starten und experimentieren möchtest, führe Folgendes aus:

git clone [email protected]:fran-aubry/nano-banana-2-flash-tutorial.git
pip install -r requirement.txt
streamlit run app.pyBereitgestellt von

Hier ein kompletter Workflow: Wir kombinieren ein vorhandenes Bild einer imaginären Teemarke mit einem generierten Bild einer Teeplantage zu einem Werbeshot der Dose. 

Anschließend bearbeiten wir das Video per Prompt.

Das Video wurde während der Generierung beschleunigt, da diese Vorgänge einige Minuten dauern können.

Fazit

Die Geschwindigkeitsangaben von Google zum neuen Nano Banana 2 Lite stimmen. 

Das Modell ist beeindruckend schnell und rückt in die Nähe von Echtzeit-Bildgenerierung. Die Bildqualität ist gut, aber nicht bahnbrechend – die eigentliche Innovation liegt klar in der Geschwindigkeit, nicht in revolutionärer Bildqualität.

In Kombination bilden Gemini Omni Flash und Nano Banana 2 Lite eine starke Pipeline. Besonders das Omni-Modell hält Referenzmaterial bemerkenswert treu ein.

Mehr zu Nano Banana 2 findest du in diesem Artikel: Nano Banana 2: A Full Guide With Python.

Für einen tieferen Einblick in die Gemini Omni-Serie lies Gemini Omni: One Model for Text, Image, Audio, and Video.