Se usó la API de Cloud Translation para traducir esta página.

Crea un sistema multiagente con el ADK, impleméntalo en Agent Engine y comienza a usar el protocolo A2A

1. Objetivo de este lab

En este lab práctico, compilarás una aplicación multiagente con el ADK (Kit de desarrollo de agentes) que genera una imagen según tu instrucción y la evalúa en función de ella. Si la imagen no cumple con los requisitos descritos en la instrucción de manera satisfactoria, el agente generará imágenes de forma continua hasta que se genere la imagen que cumpla con tus requisitos. Cada uno de los agentes de este ejercicio práctico tiene un solo propósito, y los agentes cooperan entre sí para lograr el objetivo general. Aprenderás a probar la aplicación de forma local y a implementarla en Vertex AI Agent Engine.

Qué aprenderás

Comprende los conceptos básicos del ADK (Kit de desarrollo de agentes) y aprende a crear un sistema multiagente.
Aprende a implementar y usar fácilmente los agentes en Vertex AI Agent Engine.
Comprende los conceptos básicos del protocolo A2A
Aprende a usar el protocolo A2A y el ADK (kit de desarrollo de agentes) en conjunto para crear agentes abiertos.

2. Configuración del proyecto

Si aún no tienes un proyecto que puedas usar, deberás crear uno nuevo en la consola de GCP.
En este lab, usaremos GCP Cloud Shell para realizar nuestras tareas. Abre Cloud Shell y configura el proyecto con Cloud Shell.
Haz clic aquí para abrir GCP Cloud Shell Cloud Shell . Si ves la ventana emergente "Autorizar Shell", haz clic para autorizar el editor de Cloud Shell.
Puedes verificar si el proyecto ya está autenticado con el siguiente comando en la terminal de Cloud Shell.

gcloud auth list

En Cloud Shell, ejecuta el siguiente comando para confirmar tu proyecto.

gcloud config list project

Copia el ID del proyecto y usa el siguiente comando para configurarlo.

gcloud config set project <YOUR_PROJECT_ID>

Debemos habilitar algunos servicios para ejecutar este lab. Ejecuta el siguiente comando en Cloud Shell.

gcloud services enable aiplatform.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

3. Introducción al Kit de desarrollo de agentes

El Kit de desarrollo de agentes ofrece varias ventajas clave a los desarrolladores que crean aplicaciones de agente:

Sistemas multiagente: Crea aplicaciones modulares y escalables componiendo varios agentes especializados en una jerarquía. Permite la coordinación y delegación complejas.
Ecosistema de herramientas enriquecido: Equipa a los agentes con diversas capacidades: usa herramientas prediseñadas (búsqueda, ejecución de código, etcétera), crea funciones personalizadas, integra herramientas de frameworks de agentes externos (LangChain, CrewAI) o incluso usa otros agentes como herramientas.
Organización flexible: Define flujos de trabajo con agentes de flujo de trabajo (SequentialAgent, ParallelAgent y LoopAgent) para canalizaciones predecibles o aprovecha el enrutamiento dinámico basado en LLM (transferencia de LlmAgent) para un comportamiento adaptativo.
Experiencia integrada para desarrolladores: Desarrolla, prueba y depura de forma local con una CLI potente y una IU de desarrollo interactiva. Inspecciona eventos, estados y la ejecución del agente paso a paso.
Evaluación integrada: Evalúa sistemáticamente el rendimiento del agente analizando tanto la calidad de la respuesta final como la trayectoria de ejecución paso a paso en comparación con casos de prueba predefinidos.
Listo para la implementación: Crea contenedores y, luego, implementa tus agentes en cualquier lugar. Ejecútalos de manera local, escálalos con Vertex AI Agent Engine o intégralos en una infraestructura personalizada con Cloud Run o Docker.

Si bien otros SDK de IA generativa o frameworks de agentes también te permiten consultar modelos y hasta potenciarlos con herramientas, la coordinación dinámica entre varios modelos requiere una gran cantidad de trabajo de tu parte.

El Kit de desarrollo de agentes ofrece un framework de nivel superior en comparación con esas herramientas, lo que te permite conectar sin problemas varios agentes entre sí para flujos de trabajo complejos pero fáciles de mantener.

Figura 1: Posicionamiento del ADK (Kit de desarrollo de agentes)

4. Introducción a Vertex AI Agent Engine

Vertex AI Agent Engine es un servicio completamente administrado para implementar agentes en Google Cloud. Con Vertex AI Agent Engine, los desarrolladores pueden crear, personalizar, implementar, publicar y administrar agentes de IA de OSS (ADK [Kit de desarrollo de agentes] , LangChain, LangGraph, CrewAI, AutoGen y muchos más) en Vertex AI.

Agent Engine también proporciona servicios para controlar los datos del usuario, también conocidos como memoria del agente. Actualmente, hay dos tipos de servicios de memoria disponibles.

Memoria a corto plazo: Con las sesiones de Agent Engine, puedes almacenar, administrar y recuperar el historial de conversaciones (estado) en curso dentro de una sola sesión como memoria a corto plazo.
Memoria a largo plazo: Con Agent Engine Memory Bank, almacena, transforma y recupera recuerdos (estado), en particular, en varias sesiones como recuerdos a largo plazo.

También puedes implementar agentes en otros servicios de Google Cloud, como Cloud Run o GKE, pero debes considerar usar Vertex AI Agent Engine para los siguientes casos de uso.

Entorno de ejecución administrado con estado: Si necesitas un entorno de ejecución administrado con estado y completamente administrado para la implementación de tu agente, Vertex AI Agent Engine es una buena opción, ya que abstrae tareas comunes, como la administración de sesiones y la persistencia para los agentes de IA.
Ejecución de código: Si tu agente necesita ejecutar código que se genera de forma dinámica durante la sesión del usuario, Agent Engine proporciona una zona de pruebas segura en la que puedes ejecutar el código.
Memoria a largo plazo flexible: Si necesitas memoria a largo plazo flexible para tus agentes, Vertex AI Memory Bank, que se puede usar con Vertex AI Agent Engine, puede proporcionar una forma flexible de recordar la información sobre tu usuario que se puede usar en todas las sesiones.

También puedes combinar Vertex AI Agent Engine con otros tiempos de ejecución, como Cloud Run, para crear una arquitectura de aplicación flexible. A continuación, se muestra un ejemplo de una arquitectura de referencia que usa varios servicios para compilar un agente.

Figura 2: Ejemplo de una arquitectura de referencia para compilar agentes con varios servicios

5. Introducción a A2A

El protocolo Agent2Agent (A2A) es un estándar abierto diseñado para permitir la comunicación y colaboración fluidas y seguras entre agentes autónomos de IA de diferentes frameworks, proveedores y dominios.

Interoperabilidad universal: A2A permite que los agentes trabajen juntos independientemente de sus tecnologías subyacentes, lo que fomenta un ecosistema verdaderamente multiagente. Esto significa que los agentes creados por diferentes empresas en diferentes plataformas pueden comunicarse y coordinarse.
Descubrimiento de capacidades: Los agentes pueden anunciar sus capacidades con "tarjetas de agente" (documentos JSON) que describen su identidad, las funciones A2A compatibles, las habilidades y los requisitos de autenticación. Esto permite que otros agentes descubran y seleccionen el agente más adecuado para una tarea determinada.
Seguridad predeterminada: La seguridad es un principio fundamental. La A2A incorpora mecanismos de autenticación y autorización de nivel empresarial, y utiliza estándares como HTTPS/TLS, JWT, OIDC y claves de API para garantizar interacciones seguras y proteger los datos sensibles.
Independiente de la modalidad: El protocolo admite varias modalidades de comunicación, como la transmisión de texto, audio y video, así como formularios interactivos y elementos iframe incorporados. Esta flexibilidad permite que los agentes intercambien información en el formato más adecuado para la tarea y el usuario.
Administración de tareas estructurada: A2A define protocolos claros para la delegación, la supervisión y la finalización de tareas. Admite la agrupación de tareas relacionadas y su administración en diferentes agentes con IDs de tareas únicos. Las tareas pueden pasar por ciclos de vida definidos (p.ej., enviada, en curso, completada).
Ejecución opaca: Una característica importante es que los agentes no necesitan revelar sus procesos de razonamiento internos, su memoria ni sus herramientas específicas a otros agentes. Solo exponen sus servicios invocables, lo que promueve la modularidad y la privacidad.
Basada en estándares existentes: La A2A aprovecha tecnologías web establecidas, como HTTP, eventos enviados por el servidor (SSE) para la transmisión en tiempo real y JSON-RPC para el intercambio de datos estructurados, lo que facilita la integración con la infraestructura de TI existente.
Comunicación asíncrona: El protocolo se diseñó con la comunicación asíncrona como consideración principal, lo que facilita la progresión flexible de las tareas y habilita las notificaciones push para las actualizaciones, incluso cuando no se mantiene una conexión de forma persistente.

6. Arquitectura de agentes

En este lab, crearás una aplicación multiagente que genera una imagen según tus especificaciones y la evalúa antes de presentártela.

El sistema se estructura con un agente principal llamado image_scoring que coordina todo el proceso. Este agente principal tiene un agente secundario llamado image_generation_scoring_agent, que, a su vez, tiene sus propios agentes secundarios para tareas más específicas. Esto crea una relación jerárquica en la que el agente principal delega tareas a sus subagentes.

Figura 3: Flujo general del agente.

Lista de todos los agentes

Gemini Agent	Purpose	Subagentes
image_scoring (agente principal)	Este es el agente raíz que administra el flujo de trabajo general. Ejecuta de forma repetida image_generation_scoring_agent y checker_agent en un bucle hasta que se cumple una condición de finalización.	image_generation_scoring_agent checker_agent_instance
image_generation_scoring_agent (subagente de image_scoring)	Este agente es responsable de la lógica principal de la generación y la puntuación de imágenes. Para lograrlo, ejecuta una secuencia de tres subagentes.	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (subagente de image_scoring)	Este agente verifica si el proceso de calificación de imágenes debe continuar o finalizar. Utiliza la herramienta check_tool_condition para evaluar la condición de finalización.	-
checker_agent_instance (subagente de image_scoring)	Este agente es experto en crear instrucciones para la generación de imágenes. Toma un texto de entrada y genera un mensaje detallado adecuado para el modelo de generación de imágenes.	-
image_generation_prompt_agent (subagente de image_generation_scoring_agent)	Este agente es experto en crear instrucciones para la generación de imágenes. Toma un texto de entrada y genera un mensaje detallado adecuado para el modelo de generación de imágenes.	-
scoring_images_prompt (subagente de image_generation_scoring_agent):	Este agente es experto en evaluar y calificar imágenes según diversos criterios. Toma la imagen generada y le asigna una puntuación.	-

Lista de todas las herramientas utilizadas

Herramienta	Descripción	User Agent
check_tool_condition	Esta herramienta verifica si se cumple la condición de finalización del bucle o si se alcanzó la cantidad máxima de iteraciones. Si se cumple alguna de estas condiciones, se detiene el bucle.	checker_agent_instance
generate_images	Esta herramienta genera imágenes con el modelo Imagen 3. También puede guardar las imágenes generadas en un bucket de Google Cloud Storage.	image_generation_agent
get_policy	Esta herramienta recupera una política de un archivo JSON. El image_generation_prompt_agent usa la política para crear la instrucción de generación de imágenes, y el scoring_images_prompt la usa para calificar las imágenes.	image_generation_agent
get_image	Esta herramienta carga el artefacto de imagen generado para que se pueda calificar.	scoring_images_prompt
set_score	Esta herramienta establece la puntuación total de la imagen generada en el estado de la sesión.	scoring_images_prompt

7. Instala el ADK y configura tu entorno

En este ejercicio práctico, usaremos Cloud Shell para realizar las tareas.

Prepara una pestaña del Editor de Cloud Shell

Haz clic en este vínculo para navegar directamente al editor de Cloud Shell.
Haz clic en Continuar.
Cuando se te solicite que autorices Cloud Shell, haz clic en Autorizar.
Durante el resto de este lab, puedes trabajar en esta ventana como tu IDE con el editor de Cloud Shell y la terminal de Cloud Shell.
Abre una terminal nueva con Terminal> Nueva terminal en el editor de Cloud Shell. Todos los comandos que se indican a continuación se ejecutarán en esta terminal.

Descarga e instala el ADK y las muestras de código para este lab

Ejecuta los siguientes comandos para clonar el código fuente necesario desde GitHub y, luego, instalar las bibliotecas necesarias. Ejecuta los comandos en la terminal que se abrió en el editor de Cloud Shell.

#create the project directory
mkdir ~/imagescoring
cd ~/imagescoring
#clone the code in the local directory
git clone https://github.com/haren-bh/multiagenthandson.git

Usaremos uv para crear un entorno de Python (ejecuta en la terminal del editor de Cloud Shell):

#Install uv if you do not have installed yet
pip install uv

#Create the virtual environment
uv venv .adkvenv

source .adkvenv/bin/activate

#go to the project directory
cd ~/imagescoring/multiagenthandson

#install dependencies
uv pip install -r pyproject.toml

Si no tienes un bucket de Cloud Storage, crea uno nuevo en Google Cloud Storage. También puedes crear el bucket con el comando gsutil. Otorga acceso a Agent Engine a Google Cloud Storage (ejecuta en la terminal del editor de Cloud Shell).

# First, make sure your PROJECT_ID variable is set
PROJECT_ID=$(gcloud config get-value project)

# Now, create the bucket with a unique name
# We'll use the project ID to help ensure uniqueness
gsutil mb gs://${PROJECT_ID}-imagescoring-bucket

#Now lets give Agent Engine the permission to access Cloud Storage
# 1. Get the current Project ID (text) and Project Number (numeric)
PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

# 2. Construct the Reasoning Engine Service Account email
SA_EMAIL="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
# 3. Create Agent Engine Service account if not already created
gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_NUMBER}

# 3. Grant GCS Access
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/storage.objectUser" --condition=None

En el editor, ve a View->Toggle hidden files. En la carpeta image_scoring, crea un archivo .env con el siguiente contenido. Agrega los detalles necesarios, como el nombre del proyecto y el bucket de Cloud Storage (ejecuta en la terminal del editor de Cloud Shell).

#go to image_scoring folder
cd ~/imagescoring/multiagenthandson/image_scoring

cat <<EOF>> .env
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_CLOUD_STORAGE_BUCKET=$(gcloud config get-value project)-imagescoring-bucket
GCS_BUCKET_NAME=$(gcloud config get-value project)-imagescoring-bucket
SCORE_THRESHOLD=40
IMAGEN_MODEL="imagen-3.0-generate-002"
GENAI_MODEL="gemini-2.5-flash"
EOF

Observa la estructura del agente en el código fuente, comenzando por agent.py . Este agente contiene el agente raíz que se conectará a los demás agentes.
Vuelve al directorio superior multiagenthandson en la terminal y ejecuta el siguiente comando para ejecutar el agente de forma local (ejecuta en la terminal del Editor de Cloud Shell).

#go to the directory multiagenthandson
cd ~/imagescoring/multiagenthandson
# Run the following command to run agents locally
adk web

Figura 4

Haz Ctrl+clic (Cmd+clic en macOS) en la URL http:// que se muestra en la terminal para abrir el cliente de GUI basado en el navegador del ADK. Debería verse como en la Figura 2.

Selecciona image_scoring en el menú desplegable que se encuentra en la parte superior izquierda (consulta la Figura 5). Ahora, generemos algunas imágenes. También deberías encontrar las imágenes en el bucket de Google Cloud Storage. Prueba las siguientes instrucciones o las tuyas.
Un paisaje montañoso tranquilo al atardecer
Un gato anda en bicicleta

Figura 5: Resultado de muestra

8. Implementa en Agent Engine

Ahora implementaremos el agente en Agent Engine. Agent Engine es un servicio completamente administrado para implementar agentes en GCP. Agent Engine es compatible con el ADK (Kit de desarrollo de agentes), por lo que los agentes creados con el ADK (Kit de desarrollo de agentes) se pueden implementar en Agent Engine.

Crea el archivo requirements.txt con Poetry. Poetry usará pyproject.toml para crear el archivo requirements.txt. Después de ejecutar el comando, verifica si se creó el archivo requirements.txt (ejecuta en la terminal del editor de Cloud Shell).

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

# install poetry-plugin-export
uv pip install poetry-plugin-export

#Create requirements.txt file
python3 -m poetry export -f requirements.txt --output requirements.txt --without-hashes

Crea el paquete. Debemos agrupar nuestra app en un paquete de Python .whl. Usaremos poesía para hacerlo. Una vez que ejecutes el comando, asegúrate de que se cree una carpeta dist y de que contenga el archivo .whl (ejecuta en la terminal del editor de Cloud Shell).

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

#Create python package, to create whl file
python3 -m poetry build

Ahora prepararemos el script de implementación. La secuencia de comandos de implementación implementará nuestro agente de puntuación de imágenes o el servicio del motor de agentes. Confirma el contenido de deploy.py dentro de la carpeta deploy como se muestra a continuación (usa el panel lateral del editor de Cloud Shell para encontrar el archivo).

import vertexai
from image_scoring.agent import root_agent
import os
import glob # To easily find the wheel file
from dotenv import load_dotenv

# Load environment variables from image_scoring/.env
env_path = os.path.join(os.path.dirname(__file__), "..", "image_scoring", ".env")
load_dotenv(env_path)

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.getenv("GOOGLE_CLOUD_LOCATION", "us-central1")
STAGING_BUCKET = f"gs://{os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}"

from vertexai import agent_engines

client=vertexai.Client(
    project=PROJECT_ID,
    location=LOCATION,
)
remote_app = client.agent_engines.create(
    agent=root_agent,
    config={
        "display_name": "image-scoring",
        "staging_bucket": STAGING_BUCKET,
        "requirements": open(os.path.join(os.getcwd(), "requirements.txt")).readlines() + ["./dist/image_scoring-0.1.0-py3-none-any.whl"],
        "extra_packages": [
            "./dist/image_scoring-0.1.0-py3-none-any.whl",
        ],     "env_vars":{"GCS_BUCKET_NAME":os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}
    }
)
print(f"DEBUG: AgentEngine attributes: {dir(remote_app)}")
try:
    print(remote_app.api_resource.name)
except AttributeError:
    print("Could not find resource_name, check DEBUG output above.")

Ahora podemos ejecutar la secuencia de comandos de implementación. Primero, ve a la carpeta superior multiagenthandson (ejecuta en la terminal del editor de Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#run deploy script from the parent folder containing deploy.py
python3 -m deploy.deploy

Después de la implementación, deberías ver algo similar a lo siguiente:

Figura 6: Resultado de muestra

Ahora probemos el agente implementado. Para probar el motor del agente implementado de forma remota, primero copia la ubicación del agente del resultado de la implementación en la terminal. Debería verse algo similar a esto: projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680 .
Ve a la carpeta testclient, abre el archivo remote_test.py en el editor de Cloud Shell y edita las siguientes líneas.

REASONING_ENGINE_ID = "projects/xxx/locations/us-central1/reasoningEngines/xxx"  # TODO: Change this

Desde la carpeta superior multiagenthandson, ejecuta el siguiente comando. Deberías obtener un resultado como el de la figura 4. Una vez que se complete la ejecución, deberías poder ver (Ejecutar en la terminal del editor de Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

Figura 7: Ejemplo de resultado

9. Crea un agente de A2A

En este paso, crearemos un agente A2A simple basado en el agente que creamos en los pasos anteriores. Los agentes existentes del ADK (Kit de desarrollo de agentes) se pueden publicar con el protocolo A2A. Estos son los aspectos clave que aprenderás en este paso.

Aprende los conceptos básicos del protocolo A2A.
Obtén información sobre cómo funcionan los protocolos de ADK y A2A en conjunto.
Aprende a interactuar con el protocolo A2A.

En este ejercicio práctico, usaremos el código de la carpeta image_scoring_adk_a2a_server. Antes de comenzar la tarea, cambia tu directorio a esta carpeta (ejecuta en la terminal del editor de Cloud Shell).

#change directory to image_scoring_adk_a2a_server
cd ~/imagescoring/multiagenthandson/image_scoring_adk_a2a_server

#copy the env file
cp ~/imagescoring/multiagenthandson/image_scoring/.env remote_a2a/image_scoring

1. Crea una tarjeta de agente de A2A

El protocolo A2A requiere una tarjeta de agente que contenga toda la información sobre el agente, como las capacidades del agente, la guía de uso del agente, etcétera. Una vez que se implementa un agente A2A, la tarjeta de agente se puede ver con el vínculo ".well-known/agent-card.json". Los clientes pueden consultar esta información para enviar la solicitud a los agentes.

En la carpeta remote_a2a/image_scoring, confirma que haya un archivo agents.json con el siguiente contenido usando el editor de Cloud Shell.

{
 "name": "image_scoring",
 "description": "Agent that generates images based on user prompts and scores their adherence to the prompt.",
 "url": "http://localhost:8001/a2a/image_scoring",
 "version": "1.0.0",
 "defaultInputModes": ["text/plain"],
 "defaultOutputModes": ["image/png", "text/plain"],
 "capabilities": {
   "streaming": true,
   "functions": true
 },
 "skills": [
   {
     "id": "generate_and_score_image",
     "name": "Generate and Score Image",
     "description": "Generates an image from a given text prompt and then evaluates how well the generated image adheres to the original prompt, providing a score.",
     "tags": ["image generation", "image scoring", "evaluation", "AI art"],
     "examples": [
       "Generate an image of a futuristic city at sunset",
       "Create an image of a cat playing a piano",
       "Show me an image of a serene forest with a hidden waterfall"
     ]
   }
 ]
}

2. Crea un agente de A2A

En la carpeta raíz image_scoring_adk_a2a_server, confirma que haya un archivo a2a_agent.py con el panel lateral del editor de Cloud Shell, que es el punto de entrada para el agente de A2A. Debe tener el siguiente contenido:

from google.adk.agents.remote_a2a_agent import RemoteA2aAgent

root_agent = RemoteA2aAgent(
   name="image_scoring",
   description="Agent to give interesting facts.",
   agent_card="http://localhost:8001/a2a/image_scoring/.well-known/agent.json",
  
   # Optional configurations
   timeout=300.0,          # HTTP timeout (seconds)
   httpx_client=None,      # Custom HTTP client
)

3. Ejecuta el agente de A2A

Ahora sí podemos ejecutar el agente. Para ejecutar el agente, ejecuta el siguiente comando desde la carpeta superior image_scoring_adk_a2a_server (ejecuta en la terminal del editor de Cloud Shell).

#following command runs the ADK agent as a2a agent
adk api_server --a2a --port 8001 remote_a2a

4. Prueba el agente de A2A

Una vez que el agente esté en funcionamiento, podemos probarlo. Primero, revisemos la tarjeta del agente. Abre una terminal nueva con Terminal> New Terminal y ejecuta el siguiente comando (ejecútalo en la terminal del editor de Cloud Shell que se abrió recientemente).

#Execute the following 
curl http://localhost:8001/a2a/image_scoring/.well-known/agent.json

Si ejecutas el comando anterior, se debería mostrar la tarjeta del agente para nuestro agente A2A, que es principalmente el contenido de agent.json que creamos en el paso anterior.

Ahora enviemos una solicitud al agente. Podemos usar curl para enviar solicitudes al agente (ejecutar en la terminal del editor de Cloud Shell recién abierta):

curl -X POST   http://localhost:8001/a2a/image_scoring   -H 'Content-Type: application/json'   -d '{
    "id": "uuid-123",
    "params": {
      "message": {
        "messageId": "msg-456",
        "parts": [{"text": "Create an image of a cat"}],
        "role": "user"
      }
    }
  }'

En la solicitud anterior, puedes cambiar la instrucción modificando la línea "Create an image of a cat". Una vez que ejecutes el comando, podrás buscar la imagen de salida en el almacenamiento de Google Cloud especificado.

10. Limpia

Ahora, limpiemos lo que acabamos de crear.

Borra el servidor de Vertex AI Agent Engine que acabamos de crear. Para ir a Vertex AI, escribe Vertex AI en la barra de búsqueda de la consola de Google Cloud. Haz clic en Agent Engine en el lado izquierdo.Para borrar el agente, haz clic en Borrar.

Figura 8

Borra los archivos en Cloud Shell

#Execute the following to delete the files
cd ~
rm -R ~/imagescoring

Borra el bucket. Puedes ir a GCP Console -> Cloud Storage , seleccionar y borrar tu bucket.

Figura 9: Borra el bucket

11. Conclusión

¡Felicitaciones! Implementaste correctamente una aplicación del ADK (Kit de desarrollo de agentes) multiagente en Vertex AI Agent Engine. Este es un logro significativo que abarca el ciclo de vida principal de una aplicación moderna nativa de la nube y te proporciona una base sólida para implementar tus propios sistemas complejos basados en agentes.

Resumen

En este lab, aprendiste a hacer lo siguiente:

Crea una aplicación multiagente con el ADK (Kit de desarrollo de agentes)
Implementa la aplicación en Vertex AI Agent Engine
Crea un agente que pueda comunicarse con el protocolo A2A.

Recursos útiles