Guida completa a Nano Banana 2 Lite e Gemini Omni Flash: pipeline multimediali in Python

Che cos'è Nano Banana 2 Lite?

Nano Banana 2 Lite (gemini-3.1-flash-lite-image) è il modello di generazione di immagini più veloce e conveniente di Google finora. 

Costruito specificamente per pipeline di sviluppo ad alta velocità e applicazioni ad alto throughput, è ottimizzato per scenari in cui la bassa latenza e budget operativi contenuti sono vincoli primari.

Per le piattaforme che utilizzano attualmente il modello legacy di Google (gemini-2.5-flash-image), Nano Banana 2 Lite funge da sostituzione diretta, offrendo miglioramenti immediati in termini di velocità, costo e fedeltà visiva.

Metriche chiave di performance

• Latenza ultra-bassa: Fornisce output testo-immagine in circa 4 secondi, ideale per prototipazione interattiva e applicazioni in tempo reale.
• Convenienza: Prezzo di $0,034 per immagine a risoluzione 1K, riduce significativamente la barriera per la generazione ad alti volumi.
• Mantenimento della qualità: Nonostante il focus sulla velocità, il modello mantiene una buona aderenza al prompt, una resa coerente dei personaggi e una generazione affidabile di testo all'interno delle immagini.

Che cos'è Gemini Omni Flash?

Gemini Omni Flash (gemini-omni-flash-preview) è il modello conveniente di Google per la generazione video e il montaggio video conversazionale.

A differenza dei generatori video stand-alone che si basano esclusivamente su prompt testuali statici, Omni Flash porta il ragionamento multimodale di Gemini direttamente nel processo di creazione video. 

Accetta nativamente combinazioni di input di testo, immagini e video, consentendo un controllo programmatico sulla generazione video con una precisione senza precedenti.

Funzionalità principali e prezzi di Omni Flash

• Prezzi competitivi: $0,10 per secondo di output video, in linea con la tariffa di Veo 3.1 Fast.
• Montaggio video conversazionale: Invece di rigenerare i video da zero per modifiche minori, le applicazioni possono usare istruzioni in linguaggio naturale per affinare sequenze esistenti.
• Referenziazione multimodale: I prompt testuali possono essere combinati con immagini o clip di riferimento per garantire coerenza visiva e controllo granulare sugli elementi della scena.
• Ancoraggio al mondo reale: Sfruttando le conoscenze fondamentali di Gemini, il modello costruisce animazioni realistiche basate su logica e fisica.
• Sincronizzazione testo e azioni: Testo su schermo e sovrimpressioni grafiche possono essere collegati direttamente alle azioni video tramite prompt semplici.

Come generare e configurare una chiave API Gemini

Prima di poter usare l'API Gemini, dobbiamo creare e configurare una chiave API in modo che il nostro codice possa comunicare con l'API.

Il modo più semplice per farlo è:

• Visita la pagina delle chiavi API di Google AI Studio ed esegui l'accesso.
• Clicca sul pulsante “Create API key” nell'angolo in alto a destra.
• Copia la chiave API in un file chiamato .env nella stessa cartella in cui si troverà il codice Python con il seguente formato:

GEMINI_API_KEY=replace_with_api_keyOfferto da

Nota: L'uso dell'API comporta dei costi. Per usarla, dobbiamo assicurarci di avere un metodo di pagamento configurato sulla pagina di fatturazione di Google AI Studio.

Come generare immagini con Nano Banana 2 Lite in Python

Prerequisiti per la generazione di immagini IA in Python

Prima di iniziare a programmare il nostro generatore di immagini IA in Python, assicurati di avere pronti i seguenti strumenti:

• Python 3.9+ installato sul sistema.
• Chiave API Google Gemini: Una chiave API Google Gemini valida per autenticare le richieste. Vedi i passaggi sopra per creare e configurare la chiave.
• Librerie Python necessarie: Useremo l'SDK ufficiale google-genai per l'integrazione con l'API e Pillow per gestire l'output delle immagini.

I pacchetti Python necessari possono essere installati con pip:

pip install google-genai pillow python-dotenvOfferto da

Passaggio 1: importare i moduli e caricare le variabili d'ambiente

Crea un nuovo file (ad esempio, generate_image.py) e aggiungi i seguenti import e la sequenza di caricamento per impostare l'ambiente:

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()Offerto da

Passaggio 2: inizializzare il client Google GenAI

Per interagire con il modello Nano Banana 2 Lite, dobbiamo prima inizializzare il client Google GenAI. 

Poiché l'SDK controlla automaticamente le variabili d'ambiente di sistema per GEMINI_API_KEY (che è stata caricata dal file .env nel passaggio precedente), possiamo inizializzare il client senza passare la chiave API esplicitamente nel codice.

# Initialize the Gemini API client
client = Client()Offerto da

Passaggio 3: scrivere la funzione di generazione immagini IA

Ecco ora la logica centrale del nostro script Python. Scriveremo una funzione dedicata, generate_image(), che accetta il client inizializzato e un prompt testuale come input.

Nano Banana 2 Lite viene invocato specificando model="gemini-3.1-flash-lite-image". Configuriamo la richiesta all'API per aspettarsi una modalità immagine e specifichiamo il rapporto d'aspetto desiderato per la generazione dell'immagine IA.

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 NoneOfferto da

Comprendere la richiesta di generazione immagini in Python:

• response_modalities: Costringe il modello Google Gemini a restituire un'immagine anziché testo.
• inline_data: L'API Gemini restituisce l'immagine generata come byte grezzi. Usiamo io.BytesIO di Python per incapsulare questi byte in modo che Pillow (Image.open) possa leggerli come un normale file immagine.
• image_config: Impostiamo aspect_ratio su "1:1" (quadrato), ma può essere facilmente regolato in base al caso d'uso specifico dell'applicazione IA.

Rapporti d'aspetto supportati:

Passaggio 4: eseguire lo script di generazione immagini in Python

Mettiamo tutto insieme e chiediamo a Nano Banana 2 Lite di generare un'immagine! 

Gli daremo un prompt creativo, chiameremo la funzione show() sull'immagine risultante per visualizzare l'opera generata dall'IA e chiuderemo il client per rilasciare le risorse.

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()Offerto da

Ecco l'immagine generata da Nano Banana 2 Flash:

Come promesso da Google nel loro annuncio, il modello ha impiegato solo pochi secondi per generare l'immagine. A prima vista, sembra molto più veloce di qualsiasi altro modello che ho provato finora.

Lo script completo si trova nello script generate_image.py dal repository di questo tutorial.

Estendere lo script all'editing delle immagini

Scriviamo una funzione edit_image() che modifica un'immagine. L'unica cosa da cambiare nella richiesta è fornire l'immagine insieme al prompt nel parametro contents come 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 NoneOfferto da

Test di Nano Banana 2 Flash

Abbiamo valutato le prestazioni reali del modello conducendo una serie di stress test mirati. 

Queste valutazioni si concentrano sulla capacità del modello di gestire compiti visivi complessi, come il rendering di testo leggibile, il mantenimento di layout spaziali rigorosi e la coerenza in interazioni multi-turn, per verificare se mantiene davvero la promessa di un'alta fedeltà di generazione a velocità elevate.

Test del rendering di testo leggibile all'interno dell'immagine

Test del controllo spaziale rigoroso e aderenza a due soggetti

Test di prototipazione rapida UI e precisione del layout

Test di contrasti di materiali complessi e illuminazione

Test di coerenza del personaggio su più turni

Francamente, sono piuttosto impressionato dai risultati per un modello così veloce. Nell'ultimo esempio, il modello è persino riuscito in qualche misura a mantenere la coerenza del testo nel giornale. 

Per la mia esperienza, mantenere la coerenza è uno degli aspetti più importanti che un modello di generazione di immagini deve centrare per essere davvero utile.

Come generare video con Gemini Omni Flash in Python

In questa sezione, vedremo come creare uno script Python per generare video, partendo da un semplice prompt testo-video ed espandendolo per includere immagini di riferimento.

A differenza della generazione di immagini standard, la generazione di video con Gemini Omni Flash avviene tramite l'Interactions API dell'SDK (client.interactions.create). Questo endpoint è progettato specificamente per gestire interazioni ricche, multi-turn e multimodali.

Poiché gli import dell'SDK richiesti, la configurazione delle variabili d'ambiente e l'inizializzazione del client Google GenAI sono identici al processo di generazione di immagini illustrato nella sezione precedente, possiamo concentrarci direttamente sulla scrittura delle nostre funzioni di generazione video.

Passaggio 1: Text-to-Video (semplice prompt-to-video)

Per generare un video dal solo prompt testuale, passiamo un singolo blocco di input di testo all'Interactions API. Possiamo scrivere una semplice funzione Python per gestirlo:

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 interactionOfferto da

Possiamo invocare questa funzione e salvare i byte del video restituiti su un file, così:

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.")Offerto da

Il prompt che abbiamo usato è stato:

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

Quella posizione specifica è il Colosseo romano. Ho usato le coordinate per testare la conoscenza del mondo del modello. Questo è il video che è stato generato:

In confronto, ecco cosa ha generato il modello quando ho sostituito l'anno 1000 con l'anno 1980:

A mio avviso, piuttosto interessante. Controlla il file text_to_video.py per vedere lo script completo.

Passaggio 2: implementare le funzionalità Image-to-Video

Per animare un'immagine statica o usarla semplicemente come riferimento per guidare la generazione video, dobbiamo passare sia l'immagine sia un prompt testuale al modello.

Poiché l'Interactions API si aspetta input immagine codificati in base64, definiamo prima una funzione di supporto per convertire oggetti PIL Image in stringhe 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()Offerto da

Ora possiamo costruire una funzione più generale, generate_video(), che gestisca sia le immagini opzionali sia il prompt testuale.

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 interactionOfferto da

Infine, ecco come possiamo usare queste funzioni per generare un video che anima questa immagine di uno scarabeo che ho generato 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)Offerto da

Questo è il video che ha generato:

Lo script completo è disponibile qui.

Passaggio 3: implementare l'editing video con Video-to-Video

Modificare un video in modo conversazionale con l'API Gemini Omni Flash è incredibilmente semplice grazie all'uso delle interazioni. Quando generiamo un video, otteniamo un identificatore di interazione accessibile come interaction.id. 

Per modificare un video, possiamo quindi fornire un prompt e l'identificatore della precedente interazione. Se è la prima modifica, forniamo l'identificatore dell'interazione usata per generare il video. Per le modifiche successive, forniamo l'identificatore della modifica precedente.

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

Costruire uno Studio Video IA interattivo: architettura e sinergia multi-modello

Nelle sezioni precedenti, abbiamo imparato a generare programmaticamente immagini con Nano Banana 2 Lite e video con Gemini Omni Flash. Ora vedremo come riunire queste capacità in un'unica applicazione web coesa e interattiva: uno Studio Video IA.

L'architettura dello Studio Video IA

Creare video IA di alta qualità richiede di solito un alto grado di tentativi ed errori. Lo Studio Video IA risolve questo problema implementando una pipeline a due fasi e multi-modello che sfrutta i punti di forza unici di due modelli distinti:

• Sourcing degli asset: Grazie a Nano Banana 2 Lite, gli utenti possono generare rapidamente risorse e immagini di riferimento per il video da combinare con immagini esistenti in loro possesso.
• Generazione video: Usiamo Gemini Omni Flash per generare un video basato su questi asset.
• Edizione video: Dopo la generazione, possiamo modificare il video in modo conversazionale.

Fase 1: prototipazione rapida con Nano Banana 2 Lite

Nella prima fase, l'applicazione ci consente di reperire immagini di riferimento (keyframe). Possiamo caricare un'immagine locale oppure generarne una al volo. 

È qui che Nano Banana 2 Lite dà il meglio di sé. 

Con una latenza inferiore a 4 secondi e un costo di solo una frazione di centesimo per immagine, funge da sandbox ultra-rapida. Possiamo prototipare rapidamente decine di stili visivi, composizioni e soggetti diversi finché non otteniamo il keyframe perfetto.

Fase 2: generazione multimodale con Gemini Omni Flash

Una volta ottenuta l'immagine di riferimento perfetta, passiamo alla fase di produzione video. 

L'immagine di riferimento e il prompt di animazione (ad esempio, descrivendo movimenti di camera, cambi di illuminazione o azioni) vengono codificati in base64 e inviati a Gemini Omni Flash usando l'Interactions API dell'SDK. 

Gemini Omni Flash elabora questi input e restituisce una clip video ad alta fedeltà in formato widescreen (16:9) o verticale (9:16).

Ecco il video ottenuto:

Implementazione dell'app di generazione video con Streamlit

Per costruire l'interfaccia utente, usiamo Streamlit, un popolare framework open-source per Python che rende estremamente semplice creare app web condivisibili per machine learning e data science. 

Se sei nuovo a Streamlit o vuoi un ripasso su come funziona, ti consigliamo vivamente di leggere questo tutorial su Streamlit in Python. 

Non ci concentreremo sul codice dell'interfaccia Streamlit in sé, ma piuttosto sull'architettura della pipeline di generazione video ed esploreremo le possibilità creative combinando questi due potenti modelli.

Lo script gemini_api.py contiene le funzioni che abbiamo implementato sopra per generare immagini e video. L'interfaccia utente è implementata con Streamlit nello script app.py.

Se vuoi eseguirla in locale e sperimentare, fai quanto segue:

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

Ecco un esempio di workflow completo che combina un'immagine esistente di un marchio di tè immaginario con un'immagine generata di una piantagione di tè per realizzare uno shot pubblicitario per quella lattina di tè. 

Poi modifichiamo il video usando un prompt.

Il video è stato velocizzato durante la generazione perché questa può richiedere alcuni minuti.

Conclusione

Le affermazioni di Google sulla velocità del nuovo modello Nano Banana 2 Lite sono vere. 

3Il modello è incredibilmente veloce e si avvicina a qualcosa che potrebbe generare immagini in tempo reale. Sebbene le immagini generate siano buone, non sono esattamente rivoluzionarie. L'innovazione principale del modello è senza dubbio la sua impressionante velocità piuttosto che una qualità d'immagine rivoluzionaria.

Se usati insieme, i modelli Gemini Omni Flash e Nano Banana 2 Lite creano una pipeline potente. Il modello Omni è particolarmente efficace nel mantenere la fedeltà al materiale di riferimento.

Per saperne di più su Nano Banana 2, leggi questo articolo: Nano Banana 2: guida completa con Python.

Per approfondire la serie Gemini Omni, consiglio di leggere Gemini Omni: un unico modello per testo, immagini, audio e video.