Crea un sistema multi-agente con ADK, esegui il deployment in Agent Engine e inizia a utilizzare il protocollo A2A

1. Obiettivo di questo lab

In questo lab pratico creerai un'applicazione multi-agente utilizzando ADK (Agent Development Kit) che genera un'immagine in base al prompt e la valuta in base al prompt. Se l'immagine non soddisfa in modo soddisfacente i requisiti descritti nel prompt, l'agente genererà continuamente immagini finché non verrà generata l'immagine che soddisfa i tuoi requisiti. Ciascuno degli agenti di questo esercizio pratico ha un unico scopo e collaborano tra loro per raggiungere l'obiettivo generale. Imparerai a testare l'applicazione localmente e a eseguirne il deployment in Vertex AI Agent Engine.

Obiettivi didattici

• Comprendi le nozioni di base di ADK (Agent Development Kit) e scopri come creare un sistema multi-agente.
• Scopri come eseguire il deployment e utilizzare facilmente gli agenti in Vertex AI Agent Engine.
• Comprendere le nozioni di base del protocollo A2A
• Scopri come utilizzare insieme il protocollo A2A e l'ADK (Agent Development Kit) per creare agenti aperti.

2. Configurazione del progetto

Puoi ottenere crediti Google Cloud per eseguire questo lab. Fai clic qui per ottenere i crediti. Consulta questo articolo per scoprire come richiedere i crediti Google Cloud.

• Se non hai già un progetto che puoi utilizzare, dovrai crearne uno nuovo nella console GCP.
• In questo lab utilizzeremo GCP Cloud Shell per svolgere le nostre attività. Apri Cloud Shell e imposta il progetto utilizzando Cloud Shell.
• Apri GCP Cloud Shell facendo clic qui, Cloud Shell . Se viene visualizzato il popup "Autorizza shell", fai clic per autorizzare l'editor di Cloud Shell.
• Puoi verificare se il progetto è già autenticato utilizzando il seguente comando nel terminale Cloud Shell.

gcloud auth list

• Esegui questo comando in Cloud Shell per confermare il tuo progetto

gcloud config list project

• Copia l'ID progetto e utilizza il seguente comando per impostarlo

gcloud config set project <YOUR_PROJECT_ID>

• Per eseguire questo lab, dobbiamo abilitare alcuni servizi. Esegui questo comando in Cloud Shell.

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

3. Introduzione ad Agent Development Kit

Agent Development Kit offre diversi vantaggi chiave per gli sviluppatori che creano applicazioni agentiche:

1. Sistemi multi-agente: crea applicazioni modulari e scalabili componendo più agenti specializzati in una gerarchia. Consente una coordinazione e una delega complesse.
2. Ecosistema di strumenti avanzati: dota gli agenti di diverse funzionalità: utilizza strumenti predefiniti (Ricerca, Esecuzione di codice e così via), crea funzioni personalizzate, integra strumenti di framework di agenti di terze parti (LangChain, CrewAI) o utilizza altri agenti come strumenti.
3. Orchestrazione flessibile: definisci i workflow utilizzando gli agenti di workflow (SequentialAgent, ParallelAgent e LoopAgent) per pipeline prevedibili oppure sfrutta il routing dinamico basato su LLM (trasferimento LlmAgent) per un comportamento adattivo.
4. Esperienza di sviluppo integrata: sviluppa, testa ed esegui il debug in locale con una potente CLI e una UI di sviluppo interattiva. Esamina gli eventi, lo stato e l'esecuzione passo passo dell'agente.
5. Valutazione integrata: valuta sistematicamente le prestazioni dell'agente valutando sia la qualità della risposta finale sia la traiettoria di esecuzione passo passo rispetto a scenari di test predefiniti.
6. Pronto per il deployment: inserisci i tuoi agenti in un container ed esegui il deployment ovunque: esegui localmente, esegui lo scale con Vertex AI Agent Engine o esegui l'integrazione nell'infrastruttura personalizzata utilizzando Cloud Run o Docker.

Sebbene altri SDK di AI generativa o framework di agenti ti consentano anche di eseguire query sui modelli e persino di potenziarli con strumenti, il coordinamento dinamico tra più modelli richiede un notevole impegno da parte tua.

L'Agent Development Kit offre un framework di livello superiore rispetto a questi strumenti, consentendoti di collegare facilmente più agenti tra loro per workflow complessi ma facili da gestire.

Figura 1: posizionamento dell'ADK (Agent Development Kit)

4. Introduzione a Vertex AI Agent Engine

Vertex AI Agent Engine è un servizio completamente gestito per il deployment di agenti in Google Cloud. Con Vertex AI Agent Engine, gli sviluppatori possono sviluppare, personalizzare, eseguire il deployment, gestire e pubblicare agenti AI OSS( ADK (Agent Development Kit) , LangChain, LangGraph, CrewAI, AutoGen e altri) su Vertex AI.

Agent Engine fornisce anche servizi per la gestione dei dati utente, noti anche come memoria dell'agente. Attualmente sono disponibili due tipi di servizi di memoria.

• Memoria a breve termine: con le sessioni di Agent Engine puoi archiviare, gestire e recuperare la cronologia della conversazione in corso (stato) all'interno di una singola sessione come memoria a breve termine.
• Memoria a lungo termine: con Agent Engine Memory Bank, memorizza, trasforma e recupera i ricordi (stato), in particolare in più sessioni come ricordi a lungo termine.

Puoi eseguire il deployment degli agenti anche in altri servizi Google Cloud come Cloud Run o GKE. Ti consigliamo di utilizzare Vertex AI Agent Engine per i seguenti casi d'uso.

• Runtime gestito stateful: se hai bisogno di un runtime stateful e completamente gestito per il deployment dell'agente, Vertex AI Agent Engine è una buona scelta, in quanto astrae attività comuni come la gestione delle sessioni e la persistenza per gli agenti AI.
• Esecuzione del codice: se l'agente deve eseguire codice generato dinamicamente durante la sessione utente, Agent Engine fornisce un ambiente sandbox sicuro in cui puoi eseguire il codice.
• Memoria a lungo termine flessibile: se hai bisogno di una memoria a lungo termine flessibile per i tuoi agenti, Vertex AI Memory Bank, che può essere utilizzato con Vertex AI Agent Engine, può fornire un modo flessibile per ricordare le informazioni sull'utente che possono essere utilizzate in tutte le sessioni.

Puoi anche combinare Vertex AI Agent Engine con altri runtime come Cloud Run per creare un'architettura dell'applicazione flessibile. Di seguito è riportato un esempio di architettura di riferimento che utilizza vari servizi per creare un agente.

Figura 2: un'architettura di riferimento di esempio per la creazione di agenti utilizzando più servizi.

5. Introduzione ad A2A

Il protocollo Agent2Agent (A2A) è uno standard aperto progettato per consentire una comunicazione e una collaborazione fluide e sicure tra agenti di AI autonomi di diversi framework, fornitori e domini.

1. Interoperabilità universale: A2A consente agli agenti di lavorare insieme indipendentemente dalle tecnologie sottostanti, promuovendo un ecosistema veramente multi-agente. Ciò significa che gli agenti creati da aziende diverse su piattaforme diverse possono comunicare e coordinarsi.
2. Rilevamento delle funzionalità:gli agenti possono pubblicizzare le proprie funzionalità utilizzando le "schede agente" (documenti JSON), che descrivono la loro identità, le funzionalità A2A supportate, le competenze e i requisiti di autenticazione. In questo modo, gli altri agenti possono scoprire e selezionare l'agente più adatto a una determinata attività.
3. Sicurezza per impostazione predefinita: la sicurezza è un principio fondamentale. A2A incorpora meccanismi di autenticazione e autorizzazione di livello aziendale, utilizzando standard come HTTPS/TLS, JWT, OIDC e chiavi API per garantire interazioni sicure e proteggere i dati sensibili.
4. Indipendente dalla modalità: il protocollo supporta varie modalità di comunicazione, tra cui streaming di testo, audio e video, nonché moduli interattivi e iframe incorporati. Questa flessibilità consente agli agenti di scambiare informazioni nel formato più appropriato per l'attività e l'utente.
5. Gestione strutturata delle attività: A2A definisce protocolli chiari per la delega, il monitoraggio e il completamento delle attività. Supporta il raggruppamento delle attività correlate e la loro gestione in diversi agenti utilizzando ID attività unici. Le attività possono passare attraverso cicli di vita definiti (ad es. inviate, in corso, completate).
6. Esecuzione opaca:una funzionalità importante è che gli agenti non devono rivelare ad altri agenti i loro processi di ragionamento interni, la memoria o strumenti specifici. Espongono solo i propri servizi chiamabili, promuovendo la modularità e la privacy.
7. Basato su standard esistenti: A2A sfrutta tecnologie web consolidate come HTTP, Server-Sent Events (SSE) per lo streaming in tempo reale e JSON-RPC per lo scambio di dati strutturati, semplificando l'integrazione con l'infrastruttura IT esistente.
8. Comunicazione asincrona:il protocollo è progettato con la comunicazione asincrona come considerazione principale, facilitando la progressione flessibile delle attività e consentendo le notifiche push per gli aggiornamenti anche quando una connessione non viene mantenuta in modo persistente.

6. Architettura dell'agente

In questo lab creerai un'applicazione multi-agente che genera un'immagine in base alle tue specifiche e la valuta prima di presentartela.

Il sistema è strutturato con un agente principale chiamato image_scoring che coordina l'intero processo. Questo agente principale ha un agente secondario chiamato image_generation_scoring_agent, che a sua volta ha i propri agenti secondari per attività più specifiche. In questo modo si crea una relazione gerarchica in cui l'agente principale delega le attività ai suoi agenti secondari.

Figura 3: flusso complessivo dell'agente.

Elenco di tutti gli agenti

Agent	Purpose	Subagenti
image_scoring (Main Agent)	Questo è l'agente principale che gestisce il flusso di lavoro complessivo. Esegue ripetutamente image_generation_scoring_agent e checker_agent in un ciclo finché non viene soddisfatta una condizione di terminazione.	image_generation_scoring_agent checker_agent_instance
image_generation_scoring_agent (sub-agente di image_scoring)	Questo agente è responsabile della logica di base per la generazione e l'assegnazione di punteggi alle immagini. Per farlo, esegue una sequenza di tre sub-agenti.	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (agente secondario di image_scoring)	Questo agente controlla se il processo di assegnazione del punteggio all'immagine deve continuare o terminare. Utilizza lo strumento check_tool_condition per valutare la condizione di interruzione.	-
checker_agent_instance (agente secondario di image_scoring)	Questo agente è un esperto nella creazione di prompt per la generazione di immagini. Prende un testo di input e genera un prompt dettagliato adatto al modello di generazione di immagini.	-
image_generation_prompt_agent (agente secondario di image_generation_scoring_agent)	Questo agente è un esperto nella creazione di prompt per la generazione di immagini. Prende un testo di input e genera un prompt dettagliato adatto al modello di generazione di immagini.	-
scoring_images_prompt (sub-agente di image_generation_scoring_agent):	Questo agente è un esperto nella valutazione e nell'assegnazione di punteggi alle immagini in base a vari criteri. Prende l'immagine generata e le assegna un punteggio.	-

Elenco di tutti gli strumenti utilizzati

Strumento	Descrizione	User agent
check_tool_condition	Questo strumento controlla se la condizione di terminazione del ciclo è soddisfatta o se è stato raggiunto il numero massimo di iterazioni. Se una di queste condizioni è vera, il ciclo si interrompe.	checker_agent_instance
generate_images	Questo strumento genera immagini utilizzando il modello Imagen 3. Può anche salvare le immagini generate in un bucket Google Cloud Storage.	image_generation_agent
get_policy	Questo strumento recupera una policy da un file JSON. La norma viene utilizzata da image_generation_prompt_agent per creare il prompt di generazione di immagini e da scoring_images_prompt per assegnare un punteggio alle immagini.	image_generation_agent
get_image	Questo strumento carica l'artefatto dell'immagine generata in modo che possa essere valutato.	scoring_images_prompt
set_score	Questo strumento imposta il punteggio totale dell'immagine generata nello stato della sessione.	scoring_images_prompt

7. Installare ADK e configurare l'ambiente

In questo esercizio pratico utilizzeremo Cloud Shell per eseguire le attività.

Prepara una scheda dell'editor di Cloud Shell

1. Fai clic su questo link per andare direttamente all'editor di Cloud Shell.
2. Fai clic su Continua.
3. Quando ti viene chiesto di autorizzare Cloud Shell, fai clic su Autorizza.
4. Per il resto del lab, puoi lavorare in questa finestra come IDE con l'editor di Cloud Shell e il terminale Cloud Shell.
5. Apri un nuovo terminale utilizzando Terminale > Nuovo terminale nell'editor di Cloud Shell. Tutti i comandi riportati di seguito verranno eseguiti su questo terminale.

Scarica e installa l'ADK e gli esempi di codice per questo lab

1. Esegui questi comandi per clonare l'origine necessaria da GitHub e installare le librerie necessarie. Esegui i comandi nel terminale aperto nell'editor di 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

2. Utilizzeremo uv per creare l'ambiente Python (esegui nel terminale dell'editor di 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

3. Se non hai un bucket di spazio di archiviazione cloud, creane uno nuovo in Google Cloud Storage. Puoi anche creare il bucket utilizzando il comando gsutil. Concedi ad Agent Engine l'accesso a Google Cloud Storage (esegui nel terminale dell'editor di 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

4. Nell'editor, vai a Visualizza > Attiva/disattiva file nascosti. Nella cartella image_scoring crea un file .env con il seguente contenuto. Aggiungi i dettagli richiesti, come il nome del progetto e il bucket Cloud Storage (Esegui nel terminale dell'editor 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

5. Esamina la struttura dell'agente nel codice sorgente, a partire da agent.py . Questo agente contiene l'agente principale che si connetterà agli altri agenti.
6. Torna alla directory principale multiagenthandson nel terminale ed esegui questo comando per eseguire l'agente in locale (Run in Cloud Shell Editor Terminal).

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

Figura 4

Premi Ctrl+clic (CMD+clic per macOS) sull'URL http:// visualizzato sul terminale per aprire il client GUI basato su browser dell'ADK. Dovrebbe avere l'aspetto della Figura 2

7. Seleziona image_scoring dal menu a discesa in alto a sinistra (vedi Figura 5). Ora generiamo alcune immagini. Dovresti trovare le immagini anche nel bucket Google Cloud Storage. Prova i seguenti prompt o i tuoi prompt.
8. Un tranquillo paesaggio montano al tramonto
9. Un gatto in bicicletta

Figura 5: esempio di output

8. Esegui il deployment in Agent Engine

Ora eseguiamo il deployment dell'agente in Agent Engine. Agent Engine è un servizio completamente gestito per il deployment di agenti in GCP. Agent Engine è compatibile con ADK (Agent Development Kit), pertanto gli agenti creati con ADK (Agent Development Kit) possono essere implementati in Agent Engine.

1. Crea il file requirements.txt utilizzando Poetry. Poetry utilizzerà pyproject.toml per creare il file requirements.txt. Dopo aver eseguito il comando, controlla se è stato creato il file requirements.txt (esegui nel terminale dell'editor di 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

2. Crea il pacchetto. Dobbiamo raggruppare la nostra app in un pacchetto Python .whl. Useremo la poesia per farlo. Dopo aver eseguito il comando, assicurati che venga creata una cartella dist contenente il file .whl (esegui nel terminale dell'editor di 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

3. Ora prepareremo lo script di deployment. Lo script di deployment eseguirà il deployment del nostro servizio di valutazione delle immagini o di Agent Engine. Conferma il contenuto di deploy.py all'interno della cartella deploy come indicato di seguito (utilizza il riquadro laterale dell'editor di Cloud Shell per trovare il file).

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

4. Ora possiamo eseguire lo script di deployment. Innanzitutto, vai alla cartella principale multiagenthandson (esegui nel terminale dell'editor di Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

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

Dopo il deployment, dovresti vedere qualcosa di simile a questo:

Figura 6: esempio di output

5. Ora testiamo l'agente di cui è stato eseguito il deployment. Per testare il motore dell'agente di cui è stato eseguito il deployment da remoto, copia prima la posizione dell'agente dall'output del deployment nel terminale. Dovrebbe avere un aspetto simile a questo: projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680 .
   Vai alla cartella testclient,apri il file remote_test.py nell'editor di Cloud Shell e modifica le seguenti righe.

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

6. Dalla cartella principale multiagenthandson, esegui il comando seguente. Dovresti ottenere un output simile a quello della Figura 4. Al termine dell'esecuzione, dovresti visualizzare (Esegui nel terminale dell'editor Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

Figura 7: esempio di output

9. Crea un agente A2A

In questo passaggio creeremo un semplice agente A2A basato sull'agente creato nei passaggi precedenti. Gli agenti ADK (Agent Development Kit) esistenti possono essere pubblicati con il protocollo A2A. Questi sono gli aspetti chiave che imparerai in questo passaggio.

• Scopri le nozioni di base del protocollo A2A.
• Scopri come funzionano insieme i protocolli ADK e A2A.
• Scopri come interagire con il protocollo A2A.

In questo esercizio pratico utilizzeremo il codice nella cartella image_scoring_adk_a2a_server. Prima di iniziare l'attività, cambia la directory in questa cartella (esegui nel terminale dell'editor di 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 la scheda dell'agente A2A

Il protocollo A2A richiede una scheda dell'agente che contenga tutte le informazioni sull'agente, come le funzionalità, la guida all'utilizzo e così via. Una volta implementato un agente A2A, la scheda dell'agente è visibile utilizzando il link ".well-known/agent-card.json". I clienti possono fare riferimento a queste informazioni per inviare la richiesta agli agenti.

Nella cartella remote_a2a/image_scoring verifica che sia presente agents.json utilizzando l'editor di Cloud Shell con i seguenti contenuti.

{
 "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 A2A

All'interno della cartella radice image_scoring_adk_a2a_server, verifica che sia presente un file a2a_agent.py utilizzando il riquadro laterale dell'editor di Cloud Shell, che è il punto di ingresso per l'agente A2A. Deve contenere i seguenti contenuti:

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. Esegui l'agente A2A

Ora siamo pronti per eseguire l'agente. Per eseguire l'agente, esegui il seguente comando dall'interno della cartella principale image_scoring_adk_a2a_server (esegui nel terminale dell'editor di Cloud Shell).

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

4. Testare l'agente A2A

Una volta che l'agente è in esecuzione, possiamo testarlo. Innanzitutto, controlliamo la scheda dell'agente. Apri un nuovo terminale utilizzando Terminale > Nuovo terminale ed esegui il seguente comando (esegui nel terminale dell'editor di Cloud Shell appena aperto).

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

L'esecuzione del comando precedente dovrebbe mostrare la scheda dell'agente per il nostro agente A2A, che corrisponde principalmente al contenuto di agent.json che abbiamo creato nel passaggio precedente.

Ora inviamo una richiesta all'agente. Possiamo utilizzare curl per inviare la richiesta all'agente (esegui nel terminale dell'editor di Cloud Shell appena aperto).

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"
      }
    }
  }'

Nella richiesta precedente, puoi modificare il prompt cambiando la riga "Crea un'immagine di un gatto". Dopo aver eseguito il comando, puoi controllare l'immagine di output nell'Google Cloud Storage specificato.

10. Esegui la pulizia

Ora puliamo ciò che abbiamo appena creato.

1. Elimina il server Vertex AI Agent Engine che abbiamo appena creato. Vai a Vertex AI digitando Vertex AI nella barra di ricerca della console Google Cloud. Fai clic su Agent Engine a sinistra.Puoi eliminare l'agente facendo clic su Elimina.

Figura 8

2. Elimina i file in Cloud Shell

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

3. Elimina il bucket. Puoi andare alla console GCP -> Cloud Storage , selezionare ed eliminare il bucket.

Figura 9: eliminazione del bucket

11. Conclusione

Complimenti! Hai eseguito il deployment di un'applicazione multi-agente ADK (Agent Development Kit) in Vertex AI Agent Engine. Si tratta di un risultato significativo che copre il ciclo di vita principale di un'applicazione cloud-native moderna, fornendoti una base solida per il deployment dei tuoi sistemi agentici complessi.

Riepilogo

In questo lab hai imparato a:

• Crea un'applicazione multiagente utilizzando ADK (Agent Development Kit)
• Esegui il deployment dell'applicazione in Vertex AI Agent Engine
• Crea un agente in grado di comunicare utilizzando il protocollo A2A.

Risorse utili

• Documentazione ufficiale dell'ADK
• Vertex AI Agent Engine
• Protocollo A2A
• Cloud Run