Segnale di emergenza
Durata: 1 minuto
La tua capsula di salvataggio sfreccia nell'atmosfera di un mondo sconosciuto. Le spie lampeggiano su ogni pannello. Il sistema di navigazione è bruciato. Le comunicazioni non sono attive. Quando si attivano i protocolli di emergenza del pod, l'assistente AI si riattiva:
"Superstite rilevato. Atterraggio di emergenza riuscito. Avvio del protocollo di localizzazione di emergenza…"
"AVVISO: è richiesta la verifica dell'identità. La rete di soccorso galattica non riesce a localizzare gli esploratori non registrati. Conferma la tua identità per attivare il beacon."
Guardate fuori dall'oblò. Un paesaggio alieno si estende fino all'orizzonte: strane formazioni rocciose, vegetazione sconosciuta, un cielo di colore strano. Da qualche parte, altri sopravvissuti della tua missione sono sparsi sulla superficie di questo pianeta.
Ma prima di tutto: devi esistere nel sistema.
Cosa creerai
In questo livello, creerai la tua identità unica di esploratore spaziale utilizzando la generazione di immagini multi-turn con i modelli di generazione di immagini Gemini di Google (noti anche come Nano Banana 🍌). Il tuo avatar verrà visualizzato sulla mappa di salvataggio globale, visibile a tutti gli altri sopravvissuti all'evento del workshop.
Obiettivi didattici
| Concetto | Descrizione |
|---|---|
| Generazione di immagini in più turni | Come mantenere la coerenza dei personaggi in più generazioni di immagini utilizzando le sessioni di chat |
| Prompt engineering per le immagini | Creare prompt efficaci per output stilizzati e coerenti con vincoli specifici |
| API Gemini Image (Nano Banana) | Utilizzo delle funzionalità di generazione di immagini native di Gemini tramite l'SDK Python |
| Sessioni di chat | Sfruttare il contesto della conversazione per il perfezionamento iterativo e la coerenza dei personaggi |
Al termine di questo livello, avrai:
✅ Ha generato un ritratto dell'esploratore utilizzando l'AI text-to-image
✅ Ha creato un'icona della mappa coerente utilizzando la conversazione multi-turn
✅ Ha registrato la tua identità presso la rete di soccorso
✅ È apparso sulla mappa del mondo in tempo reale insieme ad altri esploratori
Inseriamo la tua attività sulla mappa. 📍
Preparare l'ambiente
Durata: 2 minuti
Accedere a Cloud Shell
Innanzitutto, apri Cloud Shell, un terminale basato su browser con Google Cloud SDK e altri strumenti essenziali preinstallati.
Hai bisogno di crediti Google Cloud?
• Se partecipi a un workshop guidato da un insegnante: l'insegnante ti fornirà un codice credito. Utilizza quello fornito.
• Se stai seguendo questo codelab in autonomia: puoi riscattare un credito Google Cloud senza costi per coprire i costi del workshop. Fai clic su questo link per ottenere un credito e segui i passaggi della guida video riportata di seguito per applicarlo al tuo account.
Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud (è l'icona del terminale nella barra di navigazione in alto a destra).
Trova l'ID progetto Google Cloud:
- Apri la console Google Cloud: https://console.cloud.google.com
- Seleziona il progetto che vuoi utilizzare per questo workshop dal menu a discesa dei progetti nella parte superiore della pagina.
- Il tuo ID progetto viene visualizzato nella scheda Informazioni sul progetto della dashboard
Una volta aperto Cloud Shell, verifica di aver eseguito l'autenticazione:
# Check that you are logged in
gcloud auth list
Dovresti vedere il tuo account elencato come (ACTIVE).
Configurare il progetto
Verifica che il progetto sia impostato correttamente:
export PROJECT_ID=$(gcloud config get-value project)
echo "Using project: $PROJECT_ID"
Se non è impostato alcun progetto o se devi modificarlo:
gcloud config set project YOUR_PROJECT_ID
Abilita le API richieste
Abilita l'API Vertex AI per la generazione di immagini:
gcloud services enable aiplatform.googleapis.com
Clona il repository
Clona il repository Way Back Home e vai al progetto:
git clone https://github.com/ayoisio/way-back-home.git
cd way-back-home
Installa le dipendenze
Vai al livello 0 e installa i pacchetti Python richiesti:
cd level_0
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
Le dipendenze principali sono:
| Pacchetto | Finalità |
|---|---|
google-genai |
Client API Gemini per la generazione di immagini |
requests |
Client HTTP per le chiamate API a Mission Control |
Pillow |
Elaborazione delle immagini e gestione dei file |
Verifica la configurazione
Esegui una rapida verifica per assicurarti che tutto sia configurato correttamente:
cd ~/way-back-home
python scripts/verify_setup.py
Dovresti vedere:
✓ Google Cloud project configured: your-project-id
✓ Vertex AI API enabled
✓ Dependencies installed
✓ Ready to proceed!
Cosa hai appena completato
✅ Hai aperto Cloud Shell
✅ Hai configurato il tuo progetto Google Cloud
✅ Hai abilitato le API Vertex AI
✅ Hai clonato il repository di Codelab
✅ Hai installato le dipendenze di Python
✅ Hai verificato la configurazione
Passaggio successivo:connettiti a Mission Control e rivendica il tuo nome di esploratore.
Connettersi a Mission Control
Durata: 2 minuti
Esegui lo script di configurazione
Lo script di configurazione ti connette alla rete di soccorso Way Back Home e riserva la tua identità di esploratore. Esegui il comando dalla radice del progetto:
cd ~/way-back-home
chmod +x scripts/setup.sh
./scripts/setup.sh
Ti verranno chiesti due dati.
Inserisci il codice evento
Il codice evento identifica l'evento del workshop a cui partecipi.
Se ti trovi a un workshop: inserisci il codice evento dal codice QR, dalla slide o dall'istruttore del workshop.
🚀 Welcome to Way Back Home!
Enter event code (from QR/slide): devfest-nyc-26
Validating event...
✓ Connected to: DevFest NYC 2026
Se stai imparando in autonomia:inserisci sandbox per accedere all'ambiente di apprendimento pubblico.
🚀 Welcome to Way Back Home!
Enter event code (from QR/slide): sandbox
Validating event...
✓ Connected to: Way Back Home Sandbox
Scegliere il nome dell'esploratore
Scegli un nome univoco per l'explorer. Ecco come apparirai sulla mappa del mondo e nella classifica.
Choose your explorer name: AstroAyo
✓ Username available!
Se il nome che hai scelto è già stato utilizzato da un altro partecipante allo stesso evento:
Choose your explorer name: SpaceExplorer
⚠️ That name is taken. Try another.
Choose your explorer name: SpaceExplorer42
✓ Username available!
Configurazione completata
Una volta completata l'operazione, vedrai la conferma:
Initializing your explorer profile...
✓ Environment configured!
Explorer ID: a1b2c3d4
Starting coordinates: (47, 23)
Next: cd level_0 && python customize.py
Vai al livello 0
Ora vai alla directory di livello 0 (le dipendenze sono già installate dal modulo 2):
cd level_0
Esaminare la configurazione
Dai un'occhiata a ciò che è stato salvato (config.json si trova nella radice del progetto):
cat ../config.json
{
"event_code": "devfest-nyc-26",
"event_name": "DevFest NYC 2026",
"username": "AstroAyo",
"participant_id": "a1b2c3d4",
"starting_x": 47,
"starting_y": 23,
"api_base": "https://api.waybackhome.dev",
"project_id": "your-project-id"
}
Questo file di configurazione verrà utilizzato dagli script successivi per identificarti nella rete di recupero.
Cosa hai appena completato
✓ Connessione all'API Mission Control
✓ Prenotazione del nome dell'esploratore univoco
✓ Ricezione dell'ID partecipante e delle coordinate iniziali
✓ Configurazione salvata per i passaggi successivi
Avanti:personalizza l'aspetto di Explorer.
Personalizzare Explorer
Durata: 1 minuto
Esegui lo script di personalizzazione
Prima di generare l'avatar, dovrai fare alcune scelte sull'aspetto dell'esploratore:
python customize.py
Seleziona il colore dell'abito
Scegli un colore per la tuta spaziale dell'esploratore:
🎨 Let's create your explorer identity!
Select suit color:
1. Deep Blue
2. Crimson Red
3. Forest Green
4. Royal Purple
5. Solar Gold
6. Silver
Choice [1-6, default=6]: 1
✓ Deep Blue selected
Descrivi il tuo esploratore (facoltativo)
Puoi fornire una breve descrizione dell'aspetto dell'esploratore o premere Invio per un'assegnazione casuale:
Brief description of your explorer (or Enter for random):
Example: 'short dark hair, glasses, friendly smile'
> short dark hair, glasses, determined expression
✓ Preferences saved!
Se premi Invio senza digitare nulla, otterrai tratti casuali:
>
✓ Random traits: confident expression, short styled hair
Configurazione aggiornata
Le tue preferenze sono state salvate:
✓ Preferences saved!
Next: Open generator.py and follow the codelab instructions
Then run: python create_identity.py
Verifica la configurazione aggiornata:
cat ../config.json
Vedrai le tue preferenze aggiunte:
{
"event_code": "devfest-nyc-26",
"event_name": "DevFest NYC 2026",
"username": "AstroAyo",
"participant_id": "a1b2c3d4",
"starting_x": 47,
"starting_y": 23,
"api_base": "https://api.waybackhome.dev",
"project_id": "your-project-id",
"suit_color": "deep blue with silver accents",
"appearance": "short dark hair, glasses, determined expression"
}
Cosa hai appena completato
✓ Hai selezionato il colore della tuta
✓ Hai definito l'aspetto dell'esploratore
✓ La configurazione è pronta per la generazione delle immagini
Passaggio successivo:l'evento principale, ovvero la scrittura del codice di generazione dell'immagine.
Crea il generatore di avatar
Durata: 4 minuti
Questo è il modulo di apprendimento principale. Scriverai codice Python che genera il tuo avatar esploratore unico utilizzando le funzionalità di generazione di immagini multi-turn di Gemini (Nano Banana).
Apri il file del generatore
Apri il generatore di avatar nell'editor di Cloud Shell:
cloudshell edit generator.py
In alternativa, fai clic su Apri editor in Cloud Shell e vai a generator.py nella cartella level_0.
Informazioni sulla struttura dei file
Il file contiene il codice iniziale e tre sezioni segnaposto in cui aggiungerai l'implementazione:
"""
Level 0: Avatar Generator
This module generates your unique space explorer avatar using
multi-turn image generation with Gemini (Nano Banana) for
character consistency across portrait and icon.
"""
from google import genai
from google.genai import types
from PIL import Image
import json
import os
import io
# Load configuration from setup (config.json is in project root)
CONFIG_PATH = "../config.json"
with open(CONFIG_PATH) as f:
config = json.load(f)
USERNAME = config["username"]
SUIT_COLOR = config["suit_color"]
APPEARANCE = config["appearance"]
# Initialize the Gemini client for Vertex AI
client = genai.Client(
vertexai=True,
project=os.environ.get("GOOGLE_CLOUD_PROJECT", config.get("project_id")),
location="us-central1"
)
def generate_explorer_avatar() -> dict:
"""
Generate portrait and icon using multi-turn chat for consistency.
The key technique here is using a CHAT SESSION rather than independent
API calls. This allows Gemini to "remember" the character it created
in the first turn, ensuring the icon matches the portrait.
Returns:
dict with portrait_path and icon_path
"""
# MODULE_5_STEP_1_CREATE_CHAT_SESSION
# TODO: Create a chat session for multi-turn generation
chat = None # Replace this line
# MODULE_5_STEP_2_GENERATE_PORTRAIT
# TODO: Generate the explorer portrait
portrait_image = None # Replace this section
# MODULE_5_STEP_3_GENERATE_ICON
# TODO: Generate a consistent map icon
icon_image = None # Replace this section
return {
"portrait_path": "outputs/portrait.png",
"icon_path": "outputs/icon.png"
}
if __name__ == "__main__":
# Create outputs directory if it doesn't exist
os.makedirs("outputs", exist_ok=True)
print(f"Generating avatar for {USERNAME}...")
result = generate_explorer_avatar()
print(f"✅ Avatar created!")
print(f" Portrait: {result['portrait_path']}")
print(f" Icon: {result['icon_path']}")
Sostituisci le tre sezioni TODO con la tua implementazione.
Passaggio 1: crea la sessione di chat
Trova il segnaposto MODULE_5_STEP_1_CREATE_CHAT_SESSION e sostituisci la riga chat = None # Replace this line con:
# MODULE_5_STEP_1_CREATE_CHAT_SESSION
# Create a chat session to maintain character consistency across generations.
# The chat session preserves context between turns, so Gemini "remembers"
# what it generated and can create consistent variations.
chat = client.chats.create(
model="gemini-2.5-flash-image", # Nano Banana - Gemini with image generation
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"]
)
)
Passaggio 2: genera il ritratto
Trova MODULE_5_STEP_2_GENERATE_PORTRAIT e sostituisci portrait_image = None # Replace this section con il seguente codice:
# MODULE_5_STEP_2_GENERATE_PORTRAIT
# First turn: Generate the explorer portrait.
# This establishes the character that will be referenced in subsequent turns.
portrait_prompt = f"""Create a stylized space explorer portrait.
Character appearance: {APPEARANCE}
Name on suit patch: "{USERNAME}"
Suit color: {SUIT_COLOR}
CRITICAL STYLE REQUIREMENTS:
- Digital illustration style, clean lines, vibrant saturated colors
- Futuristic but weathered space suit with visible mission patches
- Background: Pure solid white (#FFFFFF) - absolutely no gradients, patterns, or elements
- Frame: Head and shoulders only, 3/4 view facing slightly left
- Lighting: Soft diffused studio lighting, no harsh shadows
- Expression: Determined but approachable
- Art style: Modern animated movie character portrait (similar to Pixar or Dreamworks style)
The white background is essential - the avatar will be composited onto a map."""
print("🎨 Generating your portrait...")
portrait_response = chat.send_message(portrait_prompt)
# Extract the image from the response.
# Gemini returns a response with multiple "parts" - we need to find the image part.
portrait_image = None
for part in portrait_response.candidates[0].content.parts:
if part.inline_data is not None:
# Found the image! Convert from bytes to PIL Image and save.
image_bytes = part.inline_data.data
portrait_image = Image.open(io.BytesIO(image_bytes))
portrait_image.save("outputs/portrait.png")
break
if portrait_image is None:
raise Exception("Failed to generate portrait - no image in response")
print("✓ Portrait generated!")
Passaggio 3: genera l'icona della mappa
Trova MODULE_5_STEP_3_GENERATE_ICON e sostituisci icon_image = None # Replace this section con:
# MODULE_5_STEP_3_GENERATE_ICON
# Second turn: Generate a consistent icon for the map.
# Because we're in the same chat session, Gemini remembers the character
# from the portrait and will maintain visual consistency.
icon_prompt = """Now create a circular map icon of this SAME character.
CRITICAL REQUIREMENTS:
- SAME person, SAME face, SAME expression, SAME suit — maintain perfect consistency with the portrait
- Tighter crop: just the head and very top of shoulders
- Background: Pure solid white (#FFFFFF)
- Optimized for small display sizes (will be used as a 64px map marker)
- Keep the exact same art style, colors, and lighting as the portrait
- Square 1:1 aspect ratio
This icon must be immediately recognizable as the same character from the portrait."""
print("🖼️ Creating map icon...")
icon_response = chat.send_message(icon_prompt)
# Extract the icon image from the response
icon_image = None
for part in icon_response.candidates[0].content.parts:
if part.inline_data is not None:
image_bytes = part.inline_data.data
icon_image = Image.open(io.BytesIO(image_bytes))
icon_image.save("outputs/icon.png")
break
if icon_image is None:
raise Exception("Failed to generate icon - no image in response")
print("✓ Icon generated!")
Il codice completato
Dopo aver aggiunto tutte e tre le sezioni, la funzione generate_explorer_avatar() dovrebbe avere il seguente aspetto:
def generate_explorer_avatar() -> dict:
"""
Generate portrait and icon using multi-turn chat for consistency.
The key technique here is using a CHAT SESSION rather than independent
API calls. This allows Gemini to "remember" the character it created
in the first turn, ensuring the icon matches the portrait.
Returns:
dict with portrait_path and icon_path
"""
# MODULE_5_STEP_1_CREATE_CHAT_SESSION
# Create a chat session to maintain character consistency across generations.
# The chat session preserves context between turns, so Gemini "remembers"
# what it generated and can create consistent variations.
chat = client.chats.create(
model="gemini-2.5-flash-image", # Nano Banana - Gemini with image generation
config=types.GenerateContentConfig(
response_modalities=["TEXT", "IMAGE"]
)
)
# MODULE_5_STEP_2_GENERATE_PORTRAIT
# First turn: Generate the explorer portrait.
# This establishes the character that will be referenced in subsequent turns.
portrait_prompt = f"""Create a stylized space explorer portrait.
Character appearance: {APPEARANCE}
Name on suit patch: "{USERNAME}"
Suit color: {SUIT_COLOR}
CRITICAL STYLE REQUIREMENTS:
- Digital illustration style, clean lines, vibrant saturated colors
- Futuristic but weathered space suit with visible mission patches
- Background: Pure solid white (#FFFFFF) - absolutely no gradients, patterns, or elements
- Frame: Head and shoulders only, 3/4 view facing slightly left
- Lighting: Soft diffused studio lighting, no harsh shadows
- Expression: Determined but approachable
- Art style: Modern animated movie character portrait (similar to Pixar or Dreamworks style)
The white background is essential - the avatar will be composited onto a map."""
print("🎨 Generating your portrait...")
portrait_response = chat.send_message(portrait_prompt)
# Extract the image from the response.
# Gemini returns a response with multiple "parts" - we need to find the image part.
portrait_image = None
for part in portrait_response.candidates[0].content.parts:
if part.inline_data is not None:
# Found the image! Convert from bytes to PIL Image and save.
image_bytes = part.inline_data.data
portrait_image = Image.open(io.BytesIO(image_bytes))
portrait_image.save("outputs/portrait.png")
break
if portrait_image is None:
raise Exception("Failed to generate portrait - no image in response")
print("✓ Portrait generated!")
# MODULE_5_STEP_3_GENERATE_ICON
# Second turn: Generate a consistent icon for the map.
# Because we're in the same chat session, Gemini remembers the character
# from the portrait and will maintain visual consistency.
icon_prompt = """Now create a circular map icon of this SAME character.
CRITICAL REQUIREMENTS:
- SAME person, SAME face, SAME expression, SAME suit — maintain perfect consistency with the portrait
- Tighter crop: just the head and very top of shoulders
- Background: Pure solid white (#FFFFFF)
- Optimized for small display sizes (will be used as a 64px map marker)
- Keep the exact same art style, colors, and lighting as the portrait
- Square 1:1 aspect ratio
This icon must be immediately recognizable as the same character from the portrait."""
print("🖼️ Creating map icon...")
icon_response = chat.send_message(icon_prompt)
# Extract the icon image from the response
icon_image = None
for part in icon_response.candidates[0].content.parts:
if part.inline_data is not None:
image_bytes = part.inline_data.data
icon_image = Image.open(io.BytesIO(image_bytes))
icon_image.save("outputs/icon.png")
break
if icon_image is None:
raise Exception("Failed to generate icon - no image in response")
print("✓ Icon generated!")
return {
"portrait_path": "outputs/portrait.png",
"icon_path": "outputs/icon.png"
}
Salvare il file
Assicurati di salvare generator.py:
- Cloud Shell Editor: Ctrl+S (Windows/Linux) o Cmd+S (Mac)
- vim: premi Esc, quindi digita
:wqe premi Invio
Cosa hai appena creato
✓ Creazione di una sessione di chat per la generazione di immagini in più passaggi
✓ Elaborazione di un prompt dettagliato per la generazione di ritratti con vincoli di stile
✓ Generazione di un'icona della mappa coerente utilizzando il contesto della conversazione
✓ Apprendimento dell'analisi dei dati delle immagini dalle risposte di Gemini
Concetti chiave acquisiti:
| Concetto | Che cosa hai imparato |
|---|---|
| Sessioni di chat | client.chats.create() mantiene il contesto in più turni |
| Modalità di risposta | ["TEXT", "IMAGE"] consente la generazione di immagini nelle risposte |
| Struttura del prompt | Oggetto → Variabili → Stile → Vincoli tecnici |
| Coerenza dei personaggi | Stessa sessione di chat = stesso personaggio in tutte le immagini |
| Analisi della risposta | Estrazione di immagini da inline_data nelle parti della risposta |
Passaggio successivo:esegui il codice e guarda la tua posizione sulla mappa.
Genera e registra
Durata: 2 minuti
Impostare l'ID progetto
Assicurati che l'ID progetto sia disponibile come variabile di ambiente:
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
Esegui Identity Creator
Ora esegui lo script principale che coordina la generazione, il caricamento e la registrazione:
python create_identity.py
Vedrai l'avanzamento della generazione in tempo reale:
🚀 Creating identity for AstroAyo...
🎨 Generating your portrait...
✓ Portrait generated!
🖼️ Creating map icon...
✓ Icon generated!
☁️ Uploading to mission database...
✓ Avatar uploaded!
📍 Registering with rescue network...
✓ Registration complete!
╔═══════════════════════════════════════════════════════════════╗
║ ✅ IDENTITY CONFIRMED! ║
╠═══════════════════════════════════════════════════════════════╣
║ ║
║ Explorer: AstroAyo ║
║ Location: (47, 23) — unconfirmed ║
║ ║
║ 🗺️ You're now on the map! ║
║ https://waybackhome.dev/e/devfest-nyc-26 ║
║ ║
║ NEXT: Proceed to Level 1 to pinpoint your exact location! ║
║ ║
╚═══════════════════════════════════════════════════════════════╝
Visualizzare l'avatar generato
Controlla le immagini generate in locale:
# List the generated files
ls -la outputs/
# Download to view on your local machine
cloudshell download outputs/portrait.png
cloudshell download outputs/icon.png
Oppure visualizzali direttamente nell'editor di Cloud Shell andando alla cartella outputs/ e facendo clic sui file immagine.
Il ritratto e l'icona generati avranno un aspetto simile a queste immagini:
Vedere la propria posizione sulla mappa
Apri l'URL della mappa del mondo mostrato nell'output:
https://waybackhome.dev/e/{your-event-code}
Ad esempio: https://waybackhome.dev/e/devfest-nyc-26
Trova il tuo avatar sulla mappa. Visualizzerai:
- La tua icona che indica la tua posizione sulla superficie del pianeta
- Il tuo nome di esploratore come etichetta sotto l'icona
- Un beacon attenuato che pulsa lentamente intorno al tuo indicatore
Fai clic sul tuo indicatore per visualizzare il tuo ritratto completo nella scheda dei dettagli.
Non ti piace il tuo avatar? Rigenera.
Se vuoi un avatar diverso, puoi rigenerarlo:
# Option 1: Change your appearance settings first
python customize.py
# Option 2: Just regenerate with current settings
python create_identity.py
Ogni volta che esegui create_identity.py, viene generato un avatar completamente nuovo (nuova sessione di chat = nuovo personaggio) e viene aggiornata la registrazione. Sentiti libero di ripetere la procedura finché il risultato non ti soddisfa.
Risoluzione dei problemi
Cosa hai appena completato
✓ Hai generato il tuo ritratto unico di esploratore
✓ Hai creato un'icona della mappa coerente
✓ Hai caricato gli asset in Mission Control
✓ Hai registrato la tua identità nella rete di soccorso
✓ Sei apparso sulla mappa del mondo in tempo reale.
Congratulazioni, esploratore! Ora fai parte della rete di soccorso. Il tuo segnale è attivo (anche se debole) e gli altri sopravvissuti possono vederti sulla mappa.
Conclusione
Durata: 1 minuto
Cosa hai creato
In soli 10 minuti, hai creato un sistema completo di generazione di avatar utilizzando la generazione di immagini basata sull'AI multiconversazione:
┌─────────────────────────────────────────────────────────────┐
│ Your Creation │
├─────────────────────────────────────────────────────────────┤
│ │
│ 📝 Input 🖼️ Output │
│ ────────── ──────── │
│ • Explorer name • Stylized portrait │
│ • Suit color • Consistent map icon │
│ • Appearance description • Live map presence │
│ │
├─────────────────────────────────────────────────────────────┤
│ │
│ 🧠 Techniques You Used │
│ ────────────────────── │
│ • Multi-turn chat sessions for character consistency │
│ • Structured prompt engineering with style constraints │
│ • Response parsing to extract generated images │
│ • API integration for cloud registration │
│ │
└─────────────────────────────────────────────────────────────┘
Concetti principali
| Lezione | Perché è importante |
|---|---|
| Le sessioni di chat mantengono il contesto | Essenziale per generare personaggi coerenti in più immagini senza variazioni |
| La struttura del prompt è importante | Vincoli chiari (sfondo bianco, stile specifico, inquadratura) producono risultati prevedibili e pronti per la produzione |
| Multi-turn beats independent calls | Ogni messaggio in una chat si basa sul contesto precedente, consentendo un perfezionamento iterativo e la coerenza. |
| Response modalities control output | L'impostazione ["TEXT", "IMAGE"] è necessaria per la generazione di immagini. Senza questa impostazione, riceverai solo testo. |
Riepilogo dei costi
Per questo livello, hai generato 2 immagini utilizzando Gemini 2.5 Flash (Nano Banana):
| Elemento | Token | Costo |
|---|---|---|
| Verticale (1024×1024) | Circa 1290 token di output | ~0,039 $ |
| Icona (1024×1024) | Circa 1290 token di output | ~0,039 $ |
| Totale | Circa 2580 token | ~0,08$ |
Il viaggio continua
La tua identità di esploratore è confermata, ma c'è un problema: la tua posizione non è confermata.
Guarda la mappa del mondo: il tuo segnale è debole e pulsa lentamente. La rete di soccorso sa che esisti, ma non sa esattamente dove ti trovi. Potresti trovarti ovunque in una vasta regione della superficie del pianeta.
Nel Livello 1: individua la tua posizione, dovrai:
- Crea un sistema multi-agente utilizzando Agent Development Kit (ADK) di Google
- Crea server MCP per analisi geologiche, botaniche e astronomiche
- Elaborare l'input multimodale (immagini del luogo dell'incidente)
- Generare una mappa topografica della tua posizione confermata utilizzando l'AI
- Accendi il tuo beacon per davvero, in modo che le squadre di soccorso possano trovarti.
Il livello 1 introduce concetti molto più avanzati: orchestrazione multi-agente, Model Context Protocol (MCP) e pattern di deployment di produzione. Passerai dall'utilizzo di una singola funzionalità del modello alla creazione di un sistema agentico completo.
Pulizia (facoltativo)
Se vuoi pulire i file locali (esegui il comando dalla directory level_0):
rm -rf outputs/
rm ../config.json
deactivate # Exit virtual environment
La tua registrazione alla rete di soccorso rimane valida: continuerai a essere visualizzato sulla mappa anche dopo l'eliminazione dei file locali. Le immagini vengono archiviate nel cloud, non localmente.
Risorse
- Documentazione sulla generazione di immagini di Gemini
- Guida all'ingegneria dei prompt per le immagini
- Blog sull'annuncio di Nano Banana
- Repository Way Back Home
- Livello 1: individua la tua posizione
Il tuo beacon è in attesa di conferma. Ci vediamo al livello 1, esploratore. 🚀
Bonus: avatar basato su foto (facoltativo)
Durata: 3 minuti
Quando utilizzare la funzionalità Foto in avatar
Potresti preferire questo approccio se:
- Vuoi che il tuo avatar ti assomigli davvero
- Hai una foto specifica che vuoi stilizzare
- Vuoi esplorare le funzionalità di trasformazione da immagine a immagine di Gemini
Come funziona
Invece di generare un personaggio puramente dalla descrizione testuale, fornisci una foto e chiedi a Gemini di trasformarla preservando la somiglianza della persona:
Carica la tua foto
Per prima cosa, carica una foto su Cloud Shell:
- In Cloud Shell, fai clic sul menu con tre puntini (⋮) nella barra degli strumenti del terminale.
- Seleziona Carica.
- Scegli una foto ritratto nitida (JPEG o PNG)
- Prendi nota del percorso caricato (ad es.
/home/your-username/my_photo.jpg)
Modificare il generatore
Per utilizzare una foto, devi modificare il passaggio di generazione del ritratto in generator.py. Sostituisci il prompt di solo testo con un prompt multimodale che includa la tua foto:
# MODULE_5_STEP_2_GENERATE_PORTRAIT (Photo-based version)
# Load your photo
photo_path = "/home/your-username/my_photo.jpg" # Update this path!
user_photo = Image.open(photo_path)
# Convert photo to bytes for the API
photo_buffer = io.BytesIO()
user_photo.save(photo_buffer, format="JPEG")
photo_bytes = photo_buffer.getvalue()
portrait_prompt = f"""Transform this person into a stylized space explorer portrait.
PRESERVE from the original photo:
- The person's facial features, face shape, and likeness
- Their general expression and personality
- Any distinctive features (glasses, facial hair, etc.)
TRANSFORM with this style:
- Digital illustration style, clean lines, vibrant saturated colors
- Add a futuristic space suit with the name "{USERNAME}" on a shoulder patch
- Suit color: {SUIT_COLOR}
- Background: Pure solid white (#FFFFFF) - no gradients or elements
- Frame: Head and shoulders, 3/4 view
- Lighting: Soft diffused studio lighting
- Art style: Modern animated movie character (Pixar/Dreamworks aesthetic)
The result should be clearly recognizable as THIS specific person, but illustrated as a heroic space explorer."""
print("🎨 Transforming your photo into an explorer portrait...")
# Send both the prompt AND the image
portrait_response = chat.send_message([
portrait_prompt,
types.Part.from_bytes(data=photo_bytes, mime_type="image/jpeg")
])
# Rest of the extraction code stays the same...
La coerenza multi-turn funziona ancora
L'approccio multi-turn funziona allo stesso modo con la generazione basata su foto:
- Turno 1: foto + prompt → ritratto stilizzato (la tua somiglianza, illustrata)
- Turno 2: "Crea un'icona di questo STESSO personaggio" → Icona coerente
Poiché la sessione di chat ricorda la versione stilizzata che ha creato (non la foto originale), l'icona corrisponderà perfettamente al ritratto trasformato.
Considerazioni sulla privacy
Prova in Vertex AI Studio
Puoi anche sperimentare la trasformazione delle foto in modo interattivo nella console Google Cloud prima di scrivere il codice:
- Vai a Vertex AI Studio
- Seleziona un modello Gemini con funzionalità di immagine
- Carica la tua foto utilizzando il pulsante degli allegati
- Inserisci il prompt di trasformazione
- Modifica lo stile finché non ottieni il risultato che ti soddisfa.
- Scarica il risultato e salvalo come
outputs/portrait.png - Esegui:
python create_identity.py --skip-generation(se questo flag è supportato) per caricare le immagini generate manualmente
Questo approccio interattivo è ideale per sperimentare i prompt e visualizzare i risultati in tempo reale prima di impegnarsi con il codice.
Che cosa hai imparato (bonus)
✓ Come utilizzare la trasformazione da immagine a immagine con Gemini
✓ Invio di contenuti multimodali (testo + immagine) in un unico messaggio
✓ Conservazione della somiglianza durante l'applicazione del trasferimento dello stile artistico
✓ Considerazioni sulla privacy per la generazione di AI basata su foto