1. Descripción general
Elegir un buen durián en un puesto callejero es un rompecabezas sensorial. Los compradores deben distinguir un Musang King (D197) genuino de uno similar, juzgar si la fruta cayó esta mañana o hace días, y adivinar si les gustará su sabor.
En este codelab, crearás y probarás un sistema multiagente multimodal de sommelier de durián con el Kit de desarrollo de agentes (ADK) y Agents CLI, y, de forma opcional, lo implementarás en Cloud Run con la CLI de Antigravity (los pasos principales tardan unos 45 minutos; los dos pasos opcionales de Antigravity agregan unos 20 minutos). Elegir un durián muestra dónde termina la percepción de la IA y dónde comienzan los sentidos humanos:
- Qué puede ver la IA: Gemini puede inspeccionar una foto de la cáscara y detectar marcadores de variedades, como la estrella de cinco puntas en la base de un Musang King, la punta oscura y hundida de un Black Thorn (D200), el anillo del tamaño de una moneda de un D24 o un tallo seco y arrugado.
- Lo que solo un humano puede percibir: Un modelo no puede oler la costura para detectar una nota alcohólica, golpear la cáscara para escuchar un sonido hueco ni presionar dos espinas para sentir si vuelven a su posición original.
- Qué debe recordar el agente: Dos durianes perfectamente maduros siguen dividiendo a los compradores. A una persona le encanta el sabor amargo y fuerte de un XO D24 de un árbol viejo, mientras que otra prefiere la crema dulce y sin amargor de un Red Prawn (D175).

Qué compilarás
- Etapa 1: Agente de visión única: Un agente de ADK, estructurado con Agents CLI, que identifica el cultivar y la frescura de un durián a partir de una foto.
- Etapa 2: Sentidos humanos y memoria del paladar: Herramientas que califican lo que el comprador huele, oye y siente, además de una herramienta que guarda su perfil de sabor en las sesiones.
- Etapa 3: Coordinador y especialistas: Un coordinador de
durian_advisorque llama a un inspector visual y a un sommelier sensorial, y luego emite un veredicto claro. - Etapa 4: Servicio de agente de Cloud Run: En un paso opcional, la CLI de Antigravity implementa tu agente con las habilidades de la CLI de Agents.
- Etapa 5: Chatbot web de Cloud Run: En otro paso opcional, la CLI de Antigravity compila e implementa una app de chat optimizada para dispositivos móviles que se comunica con tu agente.
Arquitectura

Los dos servicios de Cloud Run provienen de los pasos opcionales de Antigravity. Sin ellos, ejecutas los mismos agentes en el entorno de pruebas del ADK en Cloud Shell.
Requisitos previos
- Dominio básico de la programación en Python
- Conocimientos de las herramientas de línea de comandos y los conceptos de IA generativa
- No se requiere experiencia previa con ADK, Agents CLI ni la CLI de Antigravity.
Qué aprenderás
- Cómo crear un proyecto de ADK con
agents-cli createy un agente multimodal que lea fotos - Dónde se detiene la percepción de la IA (olfato, sonido, tacto y gusto personal) y cómo diseñar herramientas con intervención humana para esos sentidos
- Cómo recordar las preferencias de cada usuario en todas las sesiones con el estado del ADK con alcance de
user: - Cómo dividir un agente en un coordinador y agentes especializados de un solo turno a los que llama como herramientas
- De manera opcional, cómo otorgarle a la CLI de Antigravity las habilidades de la CLI de Agents para que pueda implementar tu agente y un chatbot web en Cloud Run
Requisitos
- Una Cuenta de Google (usa una cuenta personal de
@gmail.comsi reclamas créditos del taller) - Un vínculo de crédito para el taller que te haya proporcionado el instructor (además de la cámara de un teléfono para escanear el código QR) o una cuenta de Facturación de Cloud activa
- Google Chrome (se recomienda usar una ventana de incógnito para evitar mezclar cuentas personales y laborales)
2. Reclama créditos de Google Cloud (opcional)
Si estás completando este codelab por tu cuenta y cumples con los requisitos, usa el banner de créditos del Google Developer Program que aparece en esta página para solicitar créditos sin una tarjeta de crédito. Si asistes a un taller con un vínculo de créditos para eventos que te proporcionó el instructor, sigue los pasos de esta sección para obtenerlos.
Reclama tu crédito para eventos
Puedes reclamar créditos de eventos de talleres a través de Google Builders Hub (parte de Google Developer Program).
Para reclamar tu crédito del evento, sigue estos pasos:
- Abre el vínculo de crédito del taller en una ventana de incógnito y accede con tu cuenta personal de
@gmail.com. - En la tarjeta Reclama tu beneficio, haz clic en Reclamar crédito.

- Opcional: Si ves un mensaje para crear un perfil del Google Developer Program, completa el formulario.
- Cuando aparezca el cuadro de diálogo Escanea para verificar que eres un ser humano, escanea el código QR con tu teléfono y completa la verificación. Si no aparece el código QR, actualiza la página y vuelve a hacer clic en Reclamar crédito.
- Confirma que aparezca el mensaje Successfully claimed your event credit! y, luego, haz clic en Open Billing Account.

🔍 Revisa tu trabajo
El aprovisionamiento de la cuenta de facturación puede tardar hasta cinco minutos. Para confirmar que tu crédito está activo, completa los siguientes pasos:
- Si la página Administración de cuentas de facturación aún no está abierta, abre Facturación de Google Cloud (o copia la URL en tu ventana de incógnito):
https://console.cloud.google.com/billing
- Haz clic en la pestaña Tus cuentas de facturación y actualiza la página hasta que una cuenta que contenga Crédito de GDP muestre Activa en la columna Estado.

3. Crea un proyecto de Google Cloud (opcional)
Crea un proyecto de Google Cloud dedicado para mantener aislados todos los recursos de este codelab y poder quitarlos de forma limpia cuando termines.
Para crear un proyecto de Google Cloud, sigue estos pasos:
- Abre Crear un proyecto (o copia la URL en tu ventana de incógnito):
https://console.cloud.google.com/projectcreate
- Ingresa los detalles de tu proyecto:
- Nombre del proyecto: Ingresa un nombre descriptivo, como
google-cloud-workshop. - Cuenta de facturación (si se muestra): Selecciona tu cuenta de crédito de GDP (o tu cuenta de facturación activa).
- Recurso superior: Deja seleccionada la opción Sin organización (o selecciona tu organización si es necesario).
- Nombre del proyecto: Ingresa un nombre descriptivo, como
- Toma nota del ID del proyecto generado y, luego, haz clic en Crear.

🔍 Revisa tu trabajo
Cuando finalice la creación del proyecto, abre Notificaciones en la barra de herramientas de la consola de Google Cloud y, luego, haz clic en Seleccionar proyecto.

4. Configura tu entorno
En esta sección, configurarás Google Cloud Shell, habilitarás la API de Agent Platform y, luego, instalarás Agents CLI con uv.
Configura Cloud Shell
Inicia Cloud Shell
Abre Google Cloud Shell con el editor de código y la vista de terminal habilitados (o copia la URL en tu ventana de incógnito) y haz clic en Autorizar si se te solicita:
https://shell.cloud.google.com/?show=ide,terminal

Establece el ID del proyecto de Google Cloud
Copia y pega el siguiente fragmento en la terminal de Cloud Shell. Se muestra un menú numerado de tus proyectos de Google Cloud disponibles. Escribe el número que aparece junto a tu proyecto (por ejemplo, 1) y presiona Intro:
unset CLOUDSDK_CORE_PROJECT
PS3="Select your project (e.g. 1): "
select PROJECT_ID in $(gcloud projects list --format="value(projectId)"); do
[ -n "$PROJECT_ID" ] && gcloud config set project "$PROJECT_ID" && break
done
Instrucción esperada:
1) durian-sommelier-workshop-4210 2) my-cloud-project-8812 Select your project (e.g. 1): 1 Updated property [core/project]. [environment: untagged] Read more to tag: g.co/cloud/project-env-tag.
Ahora deberías ver el ID del proyecto que seleccionaste destacado en amarillo en la instrucción de la terminal de Cloud Shell:

Habilita la API de Agent Platform
Habilita la API de Agent Platform, que tus agentes usan para llamar a Gemini:
gcloud services enable aiplatform.googleapis.com
🔍 Revisa tu trabajo
Deberías ver un resultado similar a este:
Operation "operations/acat.p2-..." finished successfully.
Instala la CLI de Agents
Asegúrate de que uv esté disponible y de que su carpeta de herramientas esté en tu PATH:
which uv || curl -LsSf https://astral.sh/uv/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"
Instala la CLI de Agents como una herramienta de uv:
uv tool install google-agents-cli==1.7.0
uv instala cada herramienta en su propio entorno aislado y solo agrega el comando agents-cli a tu PATH, por lo que el Python de tu sistema no se modifica. Tampoco es necesario que instales el ADK por tu cuenta. Cada proyecto que crea Agents CLI obtiene su propio entorno virtual con una versión de ADK con la que se probó la plantilla.
🔍 Revisa tu trabajo
Confirma que Agents CLI esté lista:
agents-cli --version
Deberías ver un resultado similar a este:
agents-cli, version 1.7.0
5. Crea un agente de visión multimodal
Comienza con algo pequeño: usa la Agents CLI para generar un proyecto de ADK y, luego, convierte su agente de muestra en un clasificador de imágenes de durianes.
Crea la estructura del proyecto
Genera el proyecto de durian-advisor. --agent adk_python elige la plantilla de ADK de Python, --deployment-target cloud_run y --region us-central1 la preparan para Cloud Run, --prototype omite la configuración de CI/CD y --yes acepta los valores predeterminados:
cd ~ && agents-cli create durian-advisor \
--agent adk_python \
--deployment-target cloud_run \
--region us-central1 \
--prototype \
--yes
Deberías ver un resultado similar a este:
> Verifying GCP credentials... > ✓ Connected to project: your-project-id ✅ Success! Your agent project is ready.
Abre el proyecto en el editor de Cloud Shell. Esto vuelve a cargar la ventana y reinicia la terminal:
cloudshell workspace ~/durian-advisor
Instala las dependencias del proyecto en su propia carpeta .venv:
cd ~/durian-advisor && agents-cli install
Verifica el archivo de entorno
Agents CLI también escribió un archivo .env que le indica al ADK que llame a Gemini a través de tu proyecto de Google Cloud:
grep GOOGLE_ ~/durian-advisor/.env
Deberías ver un resultado similar a este:
GOOGLE_GENAI_USE_VERTEXAI=true GOOGLE_CLOUD_PROJECT=your-project-id GOOGLE_CLOUD_LOCATION=global
Conserva GOOGLE_CLOUD_LOCATION=global. Gemini 3.8 Flash se entrega desde el extremo global, no desde extremos regionales como us-central1, aunque tus servicios de Cloud Run se ejecuten en us-central1.
Si GOOGLE_CLOUD_PROJECT muestra your-gcp-project-id, la CLI de Agents no pudo detectar tu proyecto. Establécelo con lo siguiente:
sed -i "s/your-gcp-project-id/$(gcloud config get-value project)/" ~/durian-advisor/.env
Escribe el clasificador de visión
Cada cultivar tiene marcadores de cáscara que Gemini puede detectar en una foto:

Abre app/agent.py:
cloudshell edit ~/durian-advisor/app/agent.py
Reemplaza su contenido por el siguiente código:
"""A single multimodal agent that inspects durian photos."""
from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.models import Gemini
from google.genai import types
MODEL = "gemini-3.8-flash"
INSTRUCTION = """You are a durian visual classifier. Inspect the durian photo or shell description.
1. Base seam: a 5-point star means Musang King (D197). A dark sunken tip means Black Thorn (D200). A coin-sized brown ring means D24. An oval body with widely spaced, hooked thorns means Red Prawn (D175).
2. Stem: plump, moist, and greenish means it fell within about 12 hours. Dry and shriveled means it is days old.
3. Husk: closed seams mean natural ripening. Wide splits or mold mean it is past its best.
Give the likely cultivar and a visual freshness score from 1 to 10. Then list what a photo cannot tell you: the aroma, the tap sound, the thorn springiness, and whether the buyer will enjoy the taste."""
root_agent = Agent(
name="durian_advisor",
model=Gemini(model=MODEL, retry_options=types.HttpRetryOptions(attempts=3)),
description="Classifies durian cultivars and visual freshness from photos.",
instruction=INSTRUCTION,
)
app = App(root_agent=root_agent, name="app")
Aquí hay algunos detalles importantes:
MODELes el único lugar en el que aparece el ID del modelo. Cada agente que agregues más adelante lo heredará, por lo que cambiar de modelo es un cambio de una sola línea.retry_optionsreintenta los errores temporales, como los límites de frecuencia, hasta tres veces.app = App(...)une el agente para el patio de juegos y el servidor de Cloud Run. Mantén el nombre de la appappy el nombre del agentedurian_advisor, que coinciden con el servidor generado yagents-cli-manifest.yaml.
Prueba el agente en la zona de pruebas
Inicia la zona de pruebas del ADK:
cd ~/durian-advisor && agents-cli playground
Deberías ver un resultado similar a este:
INFO: Uvicorn running on http://127.0.0.1:8080 (Press CTRL+C to quit)
Haz clic en Vista previa en la Web en la barra de herramientas de Cloud Shell y selecciona Vista previa en el puerto 8080. Si la IU de desarrollo del ADK te pide que elijas un agente, selecciona app. Luego, envía esta instrucción o adjunta tu propia foto de un durián con el botón de carga:
I'm at a stall looking at a round durian with pyramid-shaped thorns and a 5-point star at the base. The stem is green and moist. What cultivar is this, and will it taste sweet?
🔍 Revisa tu trabajo
El agente identifica el Musang King (D197) y le otorga una puntuación de frescura alta por el tallo verde húmedo. Luego, admite lo que una foto no puede decirle: el aroma, el sonido de los golpecitos, la elasticidad de las espinas y si te gustará el sabor.
Presiona Ctrl + C en la terminal para detener el playground antes de continuar.
6. Agrega los sentidos humanos y la memoria del paladar
Una cámara no puede oler, oír ni sentir, por lo que crearás herramientas que le pidan al comprador que lo haga. También le darás al agente una memoria a largo plazo de los gustos de cada comprador. En este paso, escribirás las herramientas y, en el siguiente, las conectarás a los agentes.
Agrega el catálogo de cultivares
Crea app/durian_data.py:
cloudshell edit ~/durian-advisor/app/durian_data.py
Pega este catálogo de referencia. Mantener los datos en su propio módulo hace que el código del agente sea breve:
"""Reference catalog of durian cultivars."""
CULTIVAR_CATALOG = {
"musang_king": {
"code": "D197",
"name": "Musang King (Mao Shan Wang)",
"visual_markers": "5-point star seam at the base, pyramid-shaped thorns",
"flavor": "rich, bittersweet, buttery custard",
"bitterness": "medium",
},
"black_thorn": {
"code": "D200",
"name": "Black Thorn (Ochee)",
"visual_markers": "Dark sunken tip at the base, round pumpkin-like body",
"flavor": "sweet, creamy, slightly winey",
"bitterness": "low",
},
"red_prawn": {
"code": "D175",
"name": "Red Prawn (Udang Merah)",
"visual_markers": "Oval body, widely spaced and slightly hooked thorns",
"flavor": "sweet, floral, soft and sticky",
"bitterness": "none",
},
"xo_d24": {
"code": "D24",
"name": "XO D24 (Sultan, old tree)",
"visual_markers": "Coin-sized brown ring at the base, dense sharp thorns",
"flavor": "intense, bitter, with a boozy finish",
"bitterness": "high",
},
}
Agrega las herramientas sensoriales
Crea app/sensory_tools.py:
cloudshell edit ~/durian-advisor/app/sensory_tools.py
Pega el siguiente código:
"""Tools for cultivar lookup and human-in-the-loop sensory checks."""
from typing import Any, Literal
from .durian_data import CULTIVAR_CATALOG
AROMA_POINTS = {"sweet_fragrant": 4, "boozy_fermented": 3, "faint_grassy": 0, "sour_rotten": 0}
TAP_POINTS = {"hollow": 3, "solid": 0}
THORN_POINTS = {"springy": 3, "rigid": 0}
def get_cultivar_profile(cultivar_key: str) -> dict[str, Any]:
"""Looks up the visual markers, flavor, and bitterness of a durian cultivar.
Args:
cultivar_key: One of 'musang_king', 'black_thorn', 'red_prawn', or 'xo_d24'.
"""
key = cultivar_key.strip().lower().replace(" ", "_").replace("-", "_")
if key not in CULTIVAR_CATALOG:
return {"status": "NOT_FOUND", "supported": list(CULTIVAR_CATALOG)}
return {"status": "OK", "cultivar": CULTIVAR_CATALOG[key]}
def evaluate_human_sensory_clues(
aroma: Literal["sweet_fragrant", "boozy_fermented", "faint_grassy", "sour_rotten"],
tap_sound: Literal["hollow", "solid"],
thorn_feel: Literal["springy", "rigid"],
) -> dict[str, Any]:
"""Scores the ripeness clues that only a human buyer can smell, hear, and feel.
Args:
aroma: What the buyer smells at the seam of the husk.
tap_sound: What the buyer hears when tapping the husk.
thorn_feel: How two thorns feel when the buyer presses them together.
"""
score = AROMA_POINTS[aroma] + TAP_POINTS[tap_sound] + THORN_POINTS[thorn_feel]
if aroma == "sour_rotten":
verdict = "SPOILED"
elif score >= 7:
verdict = "RIPE"
elif score >= 4:
verdict = "NOT_QUITE_READY"
else:
verdict = "UNRIPE"
return {"status": "OK", "ripeness_score": score, "max_score": 10, "verdict": verdict}
Cómo funcionan estas herramientas:
- El ADK convierte cada función en una herramienta a la que el modelo puede llamar. La cadena de documentación se convierte en la descripción de la herramienta, y la sección
Argsexplica cada parámetro. - Las sugerencias de tipo
Literal[...]se convierten en opciones fijas en el esquema de la herramienta, por lo que Gemini debe asignar "huele un poco a alcohol" a exactamente un valor permitido, comoboozy_fermented. get_cultivar_profiledevuelve un estadoNOT_FOUNDexplícito con las claves admitidas en lugar de inventar un cultivar.
Agrega la herramienta de memoria del paladar
Crea app/memory_tools.py:
cloudshell edit ~/durian-advisor/app/memory_tools.py
Pega el siguiente código:
"""Tool that remembers each buyer's durian palate across sessions."""
from typing import Any, Literal
from google.adk.tools import ToolContext
def save_palate_preference(
favorite_flavors: str,
bitterness_tolerance: Literal["none", "low", "medium", "high"],
tool_context: ToolContext,
) -> dict[str, Any]:
"""Saves the buyer's durian taste preferences to their long-term profile.
Args:
favorite_flavors: Flavors and textures the buyer enjoys, such as
'sweet, creamy custard'.
bitterness_tolerance: How much bitterness the buyer enjoys.
"""
profile = {
"favorite_flavors": favorite_flavors,
"bitterness_tolerance": bitterness_tolerance,
}
# The "user:" prefix scopes this key to the buyer, so it follows them
# into every future session of this app.
tool_context.state["user:palate_profile"] = profile
return {"status": "SAVED", "palate_profile": profile}
Cómo funciona la memoria del paladar:
- El ADK pasa
tool_contextautomáticamente y lo oculta del modelo, por lo que Gemini solo ve los dos parámetros de gusto. - El prefijo
user:limita el alcance de la clave de estado al usuario en lugar de la sesión actual, por lo que el perfil sigue al comprador en cada conversación nueva. - No necesitas una herramienta "get" independiente. Los agentes leen el perfil directamente en sus instrucciones con el marcador de posición
{user:palate_profile?}. El?hace que el marcador de posición esté vacío cuando aún no existe un perfil, en lugar de generar un error.
🔍 Revisa tu trabajo
Consigue un durián que huela a alcohol, suene hueco y tenga espinas flexibles:
cd ~/durian-advisor && uv run python -c "from app.sensory_tools import evaluate_human_sensory_clues as score; print(score('boozy_fermented', 'hollow', 'springy'))"
Deberías ver un resultado similar a este:
{'status': 'OK', 'ripeness_score': 9, 'max_score': 10, 'verdict': 'RIPE'}
7. Coordinar agentes especialistas
Un solo agente que intenta manejar reglas de visión, puntuación sensorial y maridaje en una sola instrucción suele confundirse. En su lugar, le darás cada tarea a un especialista enfocado y dejarás que un coordinador combine sus respuestas:
vision_inspector_agentlee el cultivar y la frescura de la foto, y devuelve un informe estructurado.sensory_sommelier_agentcalifica lo que el comprador olió, escuchó y sintió, y compara el cultivar con su paladar.durian_advisorhabla con el comprador, guarda su paladar, llama a cada especialista y escribe el veredicto final.
Crea el inspector de visión
Crea app/vision_agent.py:
cloudshell edit ~/durian-advisor/app/vision_agent.py
Pega el siguiente código:
"""Vision inspector: reads the cultivar and freshness from a durian photo."""
from google.adk.agents import Agent
from pydantic import BaseModel, Field
class VisionReport(BaseModel):
cultivar_key: str = Field(
description="musang_king, black_thorn, red_prawn, xo_d24, or unknown"
)
visual_freshness: int = Field(description="1 (stale) to 10 (freshly fallen)")
evidence: str = Field(description="The visual markers behind your answer")
vision_inspector_agent = Agent(
name="vision_inspector_agent",
description="Identifies a durian's cultivar and visual freshness from the buyer's photo or shell description.",
mode="single_turn",
# Specialists only see their tool-call input by default. Opt in to the
# conversation history so this agent can see the uploaded photo.
include_contents="default",
# Report back to the coordinator instead of taking over the conversation.
disallow_transfer_to_parent=True,
disallow_transfer_to_peers=True,
output_schema=VisionReport,
instruction="""You are a durian vision inspector. Examine the durian photo or shell description in the conversation.
Cultivar markers:
- 5-point star seam at the base: musang_king
- Dark sunken tip at the base: black_thorn
- Oval body with widely spaced, slightly hooked thorns: red_prawn
- Coin-sized brown ring at the base and dense, sharp thorns: xo_d24
Freshness: a plump, moist, greenish stem and closed seams score high. A dry, shriveled stem or a split, moldy husk scores low.
If the markers are unclear, use 'unknown'.""",
)
output_schema=VisionReporthace que el especialista devuelva datos estructurados en los que el coordinador puede confiar.include_contents="default"permite que este especialista vea la conversación, incluida la foto que subiste. Sin él, un especialista de un solo turno solo ve la solicitud que pasa el coordinador.disallow_transfer_to_parentydisallow_transfer_to_peersquitan la herramientatransfer_to_agentque, de lo contrario, el ADK le daría a este agente secundario. Un especialista que ve toda la conversación se siente tentado a devolver el chat al coordinador en lugar de devolver su informe.
Crea el sommelier sensorial
Crea app/sensory_agent.py:
cloudshell edit ~/durian-advisor/app/sensory_agent.py
Pega el siguiente código:
"""Sensory sommelier: scores the buyer's senses and checks palate fit."""
from google.adk.agents import Agent
from pydantic import BaseModel, Field
from .sensory_tools import evaluate_human_sensory_clues, get_cultivar_profile
class SensoryClues(BaseModel):
cultivar_key: str = Field(description="Cultivar from the vision inspector")
aroma: str = Field(description="What the buyer smelled at the seam")
tap_sound: str = Field(description="What the buyer heard when tapping the husk")
thorn_feel: str = Field(description="How the thorns felt when pressed together")
sensory_sommelier_agent = Agent(
name="sensory_sommelier_agent",
description="Scores the smell, sound, and touch clues the buyer reports, and checks the cultivar against their palate.",
mode="single_turn",
# Report back to the coordinator instead of taking over the conversation.
disallow_transfer_to_parent=True,
disallow_transfer_to_peers=True,
input_schema=SensoryClues,
instruction="""You are a durian sensory sommelier.
Buyer palate profile: {user:palate_profile?}
1. Call evaluate_human_sensory_clues with the buyer's aroma, tap sound, and thorn feel.
2. Call get_cultivar_profile for the cultivar.
3. Compare the cultivar's bitterness with the buyer's bitterness tolerance.
Report the ripeness verdict, the palate fit, and one sentence of advice.""",
tools=[evaluate_human_sensory_clues, get_cultivar_profile],
)
input_schema=SensoryCluesdefine lo que el coordinador debe pasar: el cultivar y los tres informes sensoriales del comprador, en sus propias palabras. El especialista asigna esas palabras a los valores permitidos de la herramienta.{user:palate_profile?}coloca el paladar guardado del comprador en la instrucción, de modo que el especialista pueda juzgar la idoneidad sin una búsqueda en la memoria.- Ninguno de los especialistas establece
model. Ambos heredan elMODELdel coordinador. - Ambos especialistas usan las mismas dos marcas de transferencia, por lo que cada uno siempre informa al coordinador.
Conecta el coordinador
Abre app/agent.py:
cloudshell edit ~/durian-advisor/app/agent.py
Reemplaza su contenido por el coordinador:
"""Durian advisor: a concierge that coordinates vision and sensory specialists."""
from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.models import Gemini
from google.genai import types
from .memory_tools import save_palate_preference
from .sensory_agent import sensory_sommelier_agent
from .vision_agent import vision_inspector_agent
MODEL = "gemini-3.8-flash"
root_agent = Agent(
name="durian_advisor",
model=Gemini(model=MODEL, retry_options=types.HttpRetryOptions(attempts=3)),
description="Durian concierge that combines what the camera sees with what the buyer senses.",
instruction="""You are a friendly durian concierge helping a buyer at a fruit stall.
Buyer palate profile: {user:palate_profile?}
1. When the buyer shares taste preferences, call save_palate_preference.
2. When the buyer shows or describes a durian, call vision_inspector_agent.
3. A camera cannot smell, hear, or feel. Unless the buyer already reported the seam aroma, tap sound, and thorn feel, ask them to check. Then call sensory_sommelier_agent.
4. Call one specialist at a time. Finish with ONE verdict covering the cultivar, ripeness, and palate fit. If the durian does not suit their palate, suggest a cultivar that does.""",
tools=[save_palate_preference],
sub_agents=[vision_inspector_agent, sensory_sommelier_agent],
)
app = App(root_agent=root_agent, name="app")
Como ambos especialistas usan mode="single_turn", el ADK le brinda al coordinador dos herramientas adicionales llamadas vision_inspector_agent y sensory_sommelier_agent. La instrucción hace referencia a ellos por esos nombres.
Prueba el coordinador en el playground
Vuelve a iniciar el playground:
cd ~/durian-advisor && agents-cli playground
Abre la vista previa en la Web en el puerto 8080 y ten esta breve conversación con el agente.
Enséñale tus gustos:
Hi! Please remember my taste: I love sweet, creamy custard durians and I can't stand bitterness.
Abre la pestaña State. Deberías ver tu perfil guardado, similar al siguiente:
{
"user:palate_profile": {
"favorite_flavors": "sweet, creamy custard",
"bitterness_tolerance": "none"
}
}
Muéstrale un durián (descríbelo o adjunta una foto):
The vendor is showing me a round durian with a coin-sized brown ring at the base and dense, sharp thorns. The stem is green and moist. Should I buy it?
El coordinador llama a vision_inspector_agent, que identifica un XO D24. Luego, te pide que huelas la costura, golpees la cáscara y presiones dos espinas.
Informa lo que percibiste:
It smells a bit boozy, the knock sounds hollow, and the thorns spring back when I press them.
Empieza de cero: Haz clic en Nueva sesión y haz la siguiente pregunta:
Which durian should I pick today?
🔍 Revisa tu trabajo
- Después de que informes tus sentidos, el coordinador llama a
sensory_sommelier_agenty da un veredicto: el XO D24 está maduro (9 de 10), pero su alto amargor choca con tu paladar, así que pide un Red Prawn (D175) o Black Thorn (D200) en su lugar. - En la pestaña Eventos, puedes ver que
durian_advisorllama a cada especialista, y quesensory_sommelier_agentllama aevaluate_human_sensory_cluesyget_cultivar_profile. - En la nueva sesión, el agente ya conoce tu paladar y te recomienda un cultivar dulce y sin amargor sin volver a preguntarte.
Presiona Ctrl + C en la terminal para detener el playground.
8. Implementa con Antigravity (opcional)
Creaste y probaste el agente de forma manual. Ahora, permitirás que la CLI de Antigravity (agy), el agente de programación con IA de Google para la terminal, la implemente. Las habilidades de Agents CLI le enseñan a Antigravity a implementar un agente del ADK correctamente.
Habilita las APIs de implementación
Habilita las APIs de Cloud Run, Cloud Build y Artifact Registry, que Agents CLI usa para compilar y alojar tu agente:
gcloud services enable \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com
Deberías ver un resultado similar a este:
Operation "operations/acat.p2-..." finished successfully.
Instala las habilidades de la CLI de Agents
Instala las siete habilidades de Agents CLI en la carpeta de tu proyecto, donde Antigravity las descubrirá automáticamente:
cd ~/durian-advisor && agents-cli setup --workspace
🔍 Revisa tu trabajo
ls -1 ~/durian-advisor/.agents/skills
Deberías ver un resultado similar a este:
google-agents-cli-adk-code google-agents-cli-deploy google-agents-cli-eval google-agents-cli-observability google-agents-cli-publish google-agents-cli-scaffold google-agents-cli-workflow
Inicia la CLI de Antigravity
La CLI de Antigravity está preinstalada en Cloud Shell. Inícialo desde la carpeta de tu proyecto:
cd ~/durian-advisor && agy --dangerously-skip-permissions
La primera vez que ejecutes Antigravity, se te pedirá que accedas con tu Cuenta de Google, elijas un tema de color, aceptes las Condiciones del Servicio y confíes en la carpeta actual.
Pídele a Antigravity que implemente
Pega esta instrucción en Antigravity:
Use the google-agents-cli-deploy skill to deploy this ADK agent to Cloud Run in us-central1 as a private service. Keep GOOGLE_CLOUD_LOCATION=global so Gemini keeps working, save the exact service URL to .env as AGENT_BASE_URL, and smoke-test the deployed agent with agents-cli run.
Antigravity lee la habilidad y puede ejecutar primero las pruebas del proyecto. Luego, ejecuta agents-cli deploy, que compila el contenedor con Cloud Build, implementa el servicio durian-advisor y envía un mensaje de prueba al servicio activo. Todo el proceso tarda entre cinco y ocho minutos.
Cuando Antigravity termine, presiona Ctrl + D dos veces para salir.
🔍 Revisa tu trabajo
Envía un mensaje al agente implementado con la URL que guardó Antigravity:
cd ~/durian-advisor && source .env && agents-cli run --url "$AGENT_BASE_URL" --mode adk "Which durian suits a beginner?"
Deberías ver un resultado similar a este:
Querying remote agent: https://durian-advisor-123456789012.us-central1.run.app (mode: adk) [user]: Which durian suits a beginner? [durian_advisor]: For beginners, you want a durian that is sweet, creamy, and gentle on the palate, with little to no bitterness...
Ahora, confirma que el servicio rechaza las llamadas sin un token:
curl -s -o /dev/null -w "%{http_code}\n" "$AGENT_BASE_URL"
Deberías ver un resultado similar a este:
403
9. Crea el chatbot web con vibe coding (opcional)
Tu agente está publicado, pero es privado. Ahora, reanudarás la conversación con Antigravity, que ya conoce a tu agente, sus claves de estado y su URL, y le pedirás que cree e implemente un chatbot web para los compradores de durianes.
Reanudar Antigravity
cd ~/durian-advisor && agy --dangerously-skip-permissions
En Antigravity, ejecuta el siguiente comando de barra y selecciona tu conversación de implementación de la lista:
/resume
Pídele a Antigravity que cree el chatbot
Pega esta instrucción:
Build a mobile-friendly "Durian Sommelier" web chatbot in a new web/ folder that talks to our deployed agent at AGENT_BASE_URL (ADK app name "app").
- Add palate quick-set buttons, a photo upload, and one-tap sensory chips: Smells sweet, Smells boozy, Hollow knock, Solid knock, Thorns spring back, Thorns feel stiff.
- Use a small FastAPI server that proxies chat requests to the agent with a Google ID token, because the agent service is private.
- Show only durian_advisor's replies in the chat, not the specialists' intermediate output.
- Keep a stable user ID per browser and reuse one ADK session, creating a new one if it is missing.
Deploy it to Cloud Run as durian-sommelier-web in us-central1 with public access. Run it as a new service account named durian-sommelier-web that can invoke durian-advisor, and print the URL.
Antigravity escribe la app, crea la cuenta de servicio, le otorga el rol de Invocador de Cloud Run en durian-advisor y, luego, implementa la app con Cloud Build. Por lo general, prueba el extremo de chat antes de que finalice. La ejecución completa tarda unos diez minutos. Cuando se imprima la URL, presiona Ctrl + D dos veces para salir.
🔍 Revisa tu trabajo
Abre la URL de https://durian-sommelier-web-....run.app que imprimió Antigravity y, luego, haz lo siguiente:
- Presiona un botón de paladar, como el de dulce y cremoso. El agente confirma que guardó tu paladar.
- Sube una foto de un durián o escribe una descripción breve de la cáscara. El agente identifica el cultivar y te pide que realices las verificaciones sensoriales.
- Presiona los chips sensoriales que coincidan con tu durián. El agente responde con un veredicto que abarca la madurez y la adecuación al paladar.
10. Limpia
Borra los recursos que creaste para que dejen de generar cargos.
Borra los servicios de Cloud Run
Borra el chatbot web:
gcloud run services delete durian-sommelier-web --region us-central1 --quiet
Borra el servicio del agente:
gcloud run services delete durian-advisor --region us-central1 --quiet
Borra la cuenta de servicio
Borra la cuenta de servicio con la que se ejecutó el chatbot web:
gcloud iam service-accounts delete "durian-sommelier-web@$(gcloud config get-value project).iam.gserviceaccount.com" --quiet
Borra las imágenes de contenedor
Las implementaciones de código fuente de Cloud Run envían la imagen de contenedor de cada servicio a un repositorio de Artifact Registry llamado cloud-run-source-deploy, que otras implementaciones de tu proyecto pueden compartir. Borra solo las dos imágenes de este codelab y conserva el repositorio.
Borra la imagen del agente:
gcloud artifacts packages delete durian-advisor --repository cloud-run-source-deploy --location us-central1 --quiet
Borra la imagen del chatbot web:
gcloud artifacts packages delete durian-sommelier-web --repository cloud-run-source-deploy --location us-central1 --quiet
🔍 Revisa tu trabajo
gcloud run services list --region us-central1
Deberías ver un resultado similar a este:
Listed 0 items.
Borra los archivos locales
Quita la carpeta del proyecto, incluidas sus habilidades y el entorno virtual:
rm -rf ~/durian-advisor
De manera opcional, desinstala la CLI de Agents:
uv tool uninstall google-agents-cli
Borra todo el proyecto de Google Cloud (opcional)
PROJECT_ID=$(gcloud config get-value project)
gcloud projects delete "$PROJECT_ID" --quiet
11. Felicitaciones
¡Felicitaciones! Creaste y probaste un sistema multiagente multimodal de sommelier de durián con el ADK y la CLI de agentes. Si realizaste los pasos opcionales, también lo implementaste en Cloud Run con la CLI de Antigravity.
Qué lograste
- Creaste un proyecto de ADK con
agents-cli createy un agente de visión multimodal con un solo parámetro de configuración deMODEL. - Se crearon herramientas con intervención humana para el olfato, el sonido y el tacto, además de una memoria del paladar almacenada en el estado del ADK con alcance de
user: - Dividir el agente en un coordinador
durian_advisory dos especialistassingle_turna los que llama como herramientas - Usaste la CLI de Antigravity con las habilidades de la CLI de Agents para implementar el agente y un chatbot web en Cloud Run (opcional).
Próximos pasos
- Si los omitiste, vuelve a los pasos opcionales de Antigravity para implementar tu agente y un chatbot web en Cloud Run.
- Haz que la memoria de Palate sea duradera con un servicio de sesión respaldado por una base de datos
- Mide la calidad de las respuestas con
agents-cli eval - Explora la documentación del Kit de desarrollo de agentes (ADK)
- Más información sobre la CLI de agentes
- Explora la documentación de Cloud Run
- Únete al programa GEAR (Gemini Enterprise Agent Ready) para acceder a talleres y rutas de aprendizaje