Créer un système multi-agent avec ADK, le déployer dans Agent Engine et commencer à utiliser le protocole A2A

1. Objectif de cet atelier

Dans cet atelier pratique, vous allez créer une application multi-agents à l'aide de l'ADK (Agent Development Kit) qui génère une image en fonction de votre requête et l'évalue par rapport à celle-ci. Si l'image ne répond pas de manière satisfaisante aux exigences décrites dans la requête, l'agent continuera à générer des images jusqu'à ce qu'il trouve celle qui répond à vos exigences. Chacun des agents de cet atelier pratique a un objectif unique. Les agents coopèrent entre eux pour atteindre l'objectif global. Vous apprendrez à tester l'application en local et à la déployer dans Vertex AI Agent Engine.

Points abordés

• Comprendre les bases d'ADK (Agent Development Kit) et apprendre à créer un système multi-agents
• Découvrez comment déployer et utiliser facilement les agents dans Vertex AI Agent Engine.
• Comprendre les bases du protocole A2A
• Découvrez comment utiliser le protocole A2A et l'ADK (Agent Development Kit) ensemble pour créer des agents ouverts.

2. Configuration du projet

Vous pouvez obtenir des crédits Google Cloud pour exécuter cet atelier. Cliquez ici pour obtenir les crédits. Consultez cette page pour savoir comment demander des crédits Google Cloud.

• Si vous ne disposez pas déjà d'un projet que vous pouvez utiliser, vous devrez en créer un dans la console GCP.
• Dans cet atelier, nous allons utiliser GCP Cloud Shell pour effectuer nos tâches. Ouvrez Cloud Shell et définissez le projet à l'aide de Cloud Shell.
• Ouvrez GCP Cloud Shell en cliquant sur Cloud Shell . Si la fenêtre pop-up "Autoriser Shell" s'affiche, cliquez dessus pour autoriser l'éditeur Cloud Shell.
• Vous pouvez vérifier si le projet est déjà authentifié à l'aide de la commande suivante dans le terminal Cloud Shell.

gcloud auth list

• Exécutez la commande suivante dans Cloud Shell pour confirmer votre projet

gcloud config list project

• Copiez l'ID du projet et utilisez la commande suivante pour le définir.

gcloud config set project <YOUR_PROJECT_ID>

• Nous devons activer certains services pour exécuter cet atelier. Exécutez la commande suivante dans Cloud Shell.

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

3. Présentation d'Agent Development Kit

Agent Development Kit présente plusieurs avantages majeurs pour les développeurs qui créent des applications agentives :

1. Systèmes multi-agents : créez des applications modulaires et évolutives en combinant plusieurs agents spécialisés de manière hiérarchique, qui permettent une coordination et une délégation complexes.
2. Riche écosystème d'outils : dotez les agents de capacités diversifiées en utilisant des outils prédéfinis (outils de recherche, d'exécution de code, etc.), en créant des fonctions personnalisées, en intégrant des outils issus de frameworks d'agents tiers (LangChain, CrewAI) ou même en vous servant d'autres agents comme outils.
3. Orchestration flexible : définissez des workflows à l'aide d'agents de workflow (SequentialAgent, ParallelAgent et LoopAgent) pour des pipelines prévisibles, ou utilisez le routage dynamique piloté par LLM (transfert LlmAgent) pour un comportement adaptatif.
4. Expérience de développement intégrée : développez, testez et déboguez en local avec une CLI puissante et une UI de développement interactive. Inspectez les événements, l'état et l'exécution de l'agent à chaque étape.
5. Évaluation intégrée : évaluez de façon systématique les performances de l'agent en comparant la qualité de la réponse finale et la trajectoire d'exécution étape par étape à des cas de test prédéfinis.
6. Prêt pour le déploiement : conteneurisez et déployez vos agents où vous le souhaitez. Exécutez-les en local, faites-les évoluer avec Vertex AI Agent Engine ou intégrez-les à une infrastructure personnalisée à l'aide de Cloud Run ou Docker.

Bien que d'autres SDK d'IA générative ou frameworks d'agents vous permettent également d'interroger des modèles et même d'améliorer leur efficacité grâce à des outils, la coordination dynamique entre plusieurs modèles vous demande beaucoup de travail.

Agent Development Kit offre un framework de niveau supérieur. Ainsi, vous pouvez connecter facilement plusieurs agents les uns aux autres pour des workflows complexes, mais simples à gérer.

Figure 1 : Positionnement de l'ADK (Agent Development Kit)

4. Présentation de Vertex AI Agent Engine

Vertex AI Agent Engine est un service entièrement géré permettant de déployer des agents dans Google Cloud. Avec Vertex AI Agent Engine, les développeurs peuvent développer, personnaliser, déployer, diffuser et gérer des agents d'IA OSS( ADK (Agent Development Kit) , LangChain, LangGraph, CrewAI, AutoGen, etc.) sur Vertex AI.

Agent Engine fournit également des services pour gérer les données utilisateur, également appelées mémoire de l'agent. Deux types de services de mémoire sont actuellement disponibles.

• Mémoire à court terme : avec les sessions Agent Engine, vous pouvez stocker, gérer et récupérer l'historique des conversations en cours (état) au cours d'une même session en tant que mémoire à court terme.
• Mémoire à long terme : avec la banque de mémoire Agent Engine, stockez, transformez et récupérez des souvenirs (état), en particulier sur plusieurs sessions en tant que souvenirs à long terme.

Vous pouvez également déployer des agents dans d'autres services Google Cloud tels que Cloud Run ou GKE. Toutefois, vous devriez envisager d'utiliser Vertex AI Agent Engine pour les cas d'utilisation suivants.

• Environnement d'exécution géré avec état : si vous avez besoin d'un environnement d'exécution avec état et entièrement géré pour le déploiement de votre agent, Vertex AI Agent Engine est un bon choix, car il abstrait les tâches courantes telles que la gestion des sessions et la persistance pour les agents d'IA.
• Exécution de code : si votre agent doit exécuter du code généré de manière dynamique pendant la session utilisateur, Agent Engine fournit un bac à sable sécurisé dans lequel vous pouvez exécuter le code.
• Mémoire à long terme flexible : si vous avez besoin d'une mémoire à long terme flexible pour vos agents, la banque de mémoire Vertex AI, qui peut être utilisée avec Vertex AI Agent Engine, peut vous aider à mémoriser les informations sur vos utilisateurs de manière flexible et à les utiliser dans toutes les sessions.

Vous pouvez également combiner Vertex AI Agent Engine avec d'autres environnements d'exécution tels que Cloud Run pour créer une architecture d'application flexible. Vous trouverez ci-dessous un exemple d'architecture de référence utilisant différents services pour créer un agent.

Figure 2 : Exemple d'architecture de référence pour la création d'agents à l'aide de plusieurs services.

5. Présentation d'A2A

Le protocole Agent2Agent (A2A) est une norme ouverte conçue pour permettre une communication et une collaboration fluides et sécurisées entre des agents d'IA autonomes provenant de différents frameworks, fournisseurs et domaines.

1. Interopérabilité universelle : A2A permet aux agents de travailler ensemble, quelles que soient leurs technologies sous-jacentes, favorisant ainsi un véritable écosystème multi-agents. Cela signifie que les agents conçus par différentes entreprises sur différentes plates-formes peuvent communiquer et se coordonner.
2. Découverte des capacités : les agents peuvent annoncer leurs capacités à l'aide de "cartes d'agent" (documents JSON) qui décrivent leur identité, les fonctionnalités A2A compatibles, les compétences et les exigences d'authentification. Cela permet aux autres agents de découvrir et de sélectionner l'agent le plus adapté à une tâche donnée.
3. Sécurité par défaut : la sécurité est un principe fondamental. L'A2A intègre des mécanismes d'authentification et d'autorisation de niveau entreprise, en utilisant des normes telles que HTTPS/TLS, JWT, OIDC et les clés API pour garantir des interactions sécurisées et protéger les données sensibles.
4. Agnostique de la modalité : le protocole est compatible avec différentes modalités de communication, y compris le streaming de texte, audio et vidéo, ainsi que les formulaires interactifs et les iFrames intégrés. Cette flexibilité permet aux agents d'échanger des informations dans le format le plus approprié à la tâche et à l'utilisateur.
5. Gestion structurée des tâches : A2A définit des protocoles clairs pour la délégation, la surveillance et l'exécution des tâches. Il permet de regrouper les tâches associées et de les gérer sur différents agents à l'aide d'ID de tâches uniques. Les tâches peuvent passer par des cycles de vie définis (par exemple, "envoyée", "en cours", "terminée").
6. Exécution opaque : une fonctionnalité importante est que les agents n'ont pas besoin de révéler leurs processus de raisonnement internes, leur mémoire ou leurs outils spécifiques à d'autres agents. Ils n'exposent que leurs services appelables, ce qui favorise la modularité et la confidentialité.
7. Basé sur des normes existantes : A2A s'appuie sur des technologies Web établies telles que HTTP, les événements envoyés par le serveur (SSE) pour le streaming en temps réel et JSON-RPC pour l'échange de données structurées, ce qui facilite l'intégration à l'infrastructure informatique existante.
8. Communication asynchrone : le protocole est conçu en tenant compte de la communication asynchrone comme élément principal. Il facilite la progression flexible des tâches et permet les notifications push pour les mises à jour, même lorsqu'une connexion n'est pas maintenue en permanence.

6. Architecture d'un agent

Dans cet atelier, vous allez créer une application multi-agent qui génère une image selon vos spécifications et l'évalue avant de vous la présenter.

Le système est structuré avec un agent principal appelé image_scoring qui orchestre l'ensemble du processus. Cet agent principal possède un sous-agent appelé image_generation_scoring_agent, qui possède lui-même ses propres sous-agents pour des tâches plus spécifiques. Cela crée une relation hiérarchique dans laquelle l'agent principal délègue des tâches à ses sous-agents.

Figure 3 : Flux global de l'agent.

Liste de tous les agents

Agent	Purpose	Sous-agents
image_scoring (agent principal)	Il s'agit de l'agent racine qui gère le workflow global. Il exécute de manière répétée les image_generation_scoring_agent et checker_agent dans une boucle jusqu'à ce qu'une condition d'arrêt soit remplie.	image_generation_scoring_agent checker_agent_instance
image_generation_scoring_agent (sous-agent d'image_scoring)	Cet agent est responsable de la logique de base de la génération et de la notation des images. Pour ce faire, il exécute une séquence de trois sous-agents.	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (sous-agent de image_scoring)	Cet agent vérifie si le processus de notation des images doit se poursuivre ou s'arrêter. Il utilise l'outil check_tool_condition pour évaluer la condition de fin.	-
checker_agent_instance (sous-agent de image_scoring)	Cet agent est un expert en création de requêtes pour la génération d'images. Il prend un texte en entrée et génère une requête détaillée adaptée au modèle de génération d'images.	-
image_generation_prompt_agent (sous-agent de image_generation_scoring_agent)	Cet agent est un expert en création de requêtes pour la génération d'images. Il prend un texte en entrée et génère une requête détaillée adaptée au modèle de génération d'images.	-
scoring_images_prompt (sous-agent de image_generation_scoring_agent) :	Cet agent est un expert en évaluation et en notation d'images selon différents critères. Il prend l'image générée et lui attribue un score.	-

Liste de tous les outils utilisés

Outil	Description	User-agent
check_tool_condition	Cet outil vérifie si la condition de fin de boucle est remplie ou si le nombre maximal d'itérations a été atteint. Si l'une de ces conditions est remplie, la boucle s'arrête.	checker_agent_instance
generate_images	Cet outil génère des images à l'aide du modèle Imagen 3. Il peut également enregistrer les images générées dans un bucket Google Cloud Storage.	image_generation_agent
get_policy	Cet outil récupère une règle à partir d'un fichier JSON. Cette règle est utilisée par image_generation_prompt_agent pour créer le prompt de génération d'images et par scoring_images_prompt pour évaluer les images.	image_generation_agent
get_image	Cet outil charge l'artefact d'image généré afin qu'il puisse être évalué.	scoring_images_prompt
set_score	Cet outil définit le score total de l'image générée dans l'état de la session.	scoring_images_prompt

7. Installer l'ADK et configurer votre environnement

Dans cet atelier pratique, nous allons utiliser Cloud Shell pour effectuer les tâches.

Préparer un onglet dans l'éditeur Cloud Shell

1. Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
2. Cliquez sur Continuer.
3. Si vous êtes invité à autoriser Cloud Shell, cliquez sur Autoriser.
4. Pour le reste de cet atelier, vous pouvez utiliser cette fenêtre comme IDE avec l'éditeur Cloud Shell et le terminal Cloud Shell.
5. Ouvrez un nouveau terminal en cliquant sur Terminal > Nouveau terminal dans l'éditeur Cloud Shell. Toutes les commandes ci-dessous seront exécutées dans ce terminal.

Télécharger et installer ADK et les exemples de code pour cet atelier

1. Exécutez les commandes suivantes pour cloner la source nécessaire à partir de GitHub et installer les bibliothèques requises. Exécutez les commandes dans le terminal ouvert dans l'éditeur 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. Nous allons utiliser uv pour créer un environnement Python (exécutez la commande dans le terminal de l'éditeur 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. Si vous n'avez pas de bucket Cloud Storage, créez-en un dans Google Cloud Storage. Vous pouvez également créer le bucket à l'aide de la commande gsutil. Accordez à Agent Engine l'accès à Google Cloud Storage (exécutez la commande dans le terminal de l'éditeur 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. Dans l'éditeur, accédez à Affichage > Activer/Désactiver les fichiers cachés. Dans le dossier image_scoring, créez un fichier .env avec le contenu suivant. Ajoutez les informations requises, telles que le nom de votre projet et votre bucket Cloud Storage (exécutez-le dans le terminal de l'éditeur 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. Examinez la structure de l'agent dans le code source, en commençant par agent.py . Cet agent contient l'agent racine qui se connectera aux autres agents.
6. Revenez au répertoire racine multiagenthandson dans le terminal et exécutez la commande suivante pour exécuter l'agent en local (exécuter dans le terminal de l'éditeur Cloud Shell).

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

Figure 4

Appuyez sur Ctrl+clic (CMD+clic pour macOS) sur l'URL http:// affichée dans le terminal pour ouvrir le client GUI basé sur le navigateur de l'ADK. Elle devrait ressembler à la figure 2.

7. Sélectionnez image_scoring dans le menu déroulant en haut à gauche (voir la figure 5). Générons maintenant des images ! Vous devriez également trouver les images dans le bucket Google Cloud Storage. Essayez les prompts suivants ou les vôtres.
8. Paysage de montagne paisible au coucher du soleil
9. Un chat à vélo

Figure 5 : Exemple de résultat

8. Déployer sur Agent Engine

Nous allons maintenant déployer l'agent sur Agent Engine. Agent Engine est un service entièrement géré permettant de déployer des agents dans GCP. Agent Engine est compatible avec ADK (Agent Development Kit). Les agents créés avec ADK (Agent Development Kit) peuvent donc être déployés dans Agent Engine.

1. Créez le fichier requirements.txt à l'aide de Poetry. Poetry utilisera pyproject.toml pour créer le fichier requirements.txt. Après avoir exécuté la commande, vérifiez si le fichier requirements.txt a été créé (exécutez-la dans le terminal de l'éditeur 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. Créez le package. Nous devons regrouper notre application dans un package Python .whl. Nous utiliserons poetry pour cela. Une fois la commande exécutée, assurez-vous qu'un dossier "dist" a été créé et qu'il contient le fichier .whl (exécutez-le dans le terminal de l'éditeur 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. Nous allons maintenant préparer le script de déploiement. Le script de déploiement déploiera notre agent de notation d'images ou notre service de moteur d'agent. Veuillez vérifier le contenu de deploy.py dans le dossier deploy comme indiqué ci-dessous (utilisez le volet latéral de l'éditeur Cloud Shell pour trouver le fichier).

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. Nous pouvons maintenant exécuter le script de déploiement. Commencez par accéder au dossier racine multiagenthandson (exécuter dans le terminal de l'éditeur Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

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

Une fois le déploiement effectué, un résultat semblable à celui ci-dessous devrait s'afficher :

Figure 6 : Exemple de résultat

5. Testons maintenant l'agent déployé. Pour tester le moteur de l'agent déployé à distance, commencez par copier l'emplacement de l'agent à partir de la sortie du déploiement dans le terminal. Elle devrait ressembler à ceci : projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680 .
    Accédez au dossier testclient,ouvrez le fichier remote_test.py dans l'éditeur Cloud Shell et modifiez les lignes suivantes.

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

6. Depuis le dossier racine multiagenthandson, exécutez la commande suivante. Vous devriez obtenir un résultat semblable à celui de la figure 4. Une fois l'exécution terminée, vous devriez voir "Run in Cloud Shell Editor Terminal" (Exécuter dans le terminal de l'éditeur Cloud Shell).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

Figure 7 : Exemple de résultat

9. Créer un agent A2A

Dans cette étape, nous allons créer un agent A2A simple basé sur l'agent que nous avons créé lors des étapes précédentes. Les agents ADK (Agent Development Kit) existants peuvent être publiés sous le protocole A2A. Voici les principaux points que vous allez apprendre dans cette étape.

• Découvrez les principes de base du protocole A2A.
• Découvrez comment les protocoles ADK et A2A fonctionnent ensemble.
• Découvrez comment interagir avec le protocole A2A.

Dans cet exercice pratique, nous allons utiliser le code du dossier image_scoring_adk_a2a_server. Avant de commencer la tâche, veuillez accéder à ce dossier (exécutez-le dans le terminal de l'éditeur 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. Créer une fiche d'agent A2A

Le protocole A2A nécessite une carte d'agent contenant toutes les informations sur l'agent, telles que ses capacités, son guide d'utilisation, etc. Une fois qu'un agent A2A est déployé, la carte d'agent est visible à l'aide du lien .well-known/agent-card.json. Les clients peuvent se référer à ces informations pour envoyer la demande aux agents.

Dans le dossier remote_a2a/image_scoring, vérifiez qu'il existe un fichier agents.json dans l'éditeur Cloud Shell avec le contenu suivant.

{
 "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. Créer un agent A2A

Dans le dossier racine image_scoring_adk_a2a_server, vérifiez qu'il existe un fichier a2a_agent.py à l'aide du panneau latéral de l'éditeur Cloud Shell, qui est le point d'entrée de l'agent A2A. Il doit contenir les éléments suivants :

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. Exécuter l'agent A2A

Nous sommes maintenant prêts à exécuter l'agent. Pour exécuter l'agent, exécutez la commande suivante à partir du dossier racine image_scoring_adk_a2a_server (exécutez-la dans le terminal de l'éditeur Cloud Shell).

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

4. Tester l'agent A2A

Une fois l'agent en cours d'exécution, nous pouvons le tester. Tout d'abord, vérifions la fiche de l'agent. Ouvrez un nouveau terminal en sélectionnant Terminal>Nouveau terminal, puis exécutez la commande suivante (exécutez-la dans le terminal de l'éditeur Cloud Shell qui vient de s'ouvrir).

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

L'exécution de la commande ci-dessus devrait afficher la carte de l'agent A2A, qui correspond principalement au contenu du fichier agent.json que nous avons créé à l'étape précédente.

Envoyons maintenant une requête à l'agent. Nous pouvons utiliser curl pour envoyer une requête à l'agent (exécuter dans le terminal de l'éditeur Cloud Shell qui vient de s'ouvrir) :

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

Dans la requête ci-dessus, vous pouvez modifier le prompt en changeant la ligne "Create an image of a cat" (Crée une image de chat). Une fois la commande exécutée, vous pouvez rechercher l'image de sortie dans le Google Cloud Storage spécifié.

10. Effectuer un nettoyage

Nettoyons maintenant ce que nous venons de créer.

1. Supprimez le serveur Vertex AI Agent Engine que nous venons de créer. Accédez à Vertex AI en saisissant "Vertex AI" dans la barre de recherche de la console Google Cloud. Cliquez sur Agent Engine sur la gauche.Vous pouvez supprimer l'agent en cliquant sur "Supprimer".

Figure 8

2. Supprimez les fichiers dans Cloud Shell.

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

3. Supprimez le bucket. Vous pouvez accéder à la console GCP > Cloud Storage , sélectionner votre bucket et le supprimer.

Figure 9 : Supprimer le bucket

11. Conclusion

Félicitations ! Vous avez déployé une application multi-agents ADK (Agent Development Kit) sur Vertex AI Agent Engine. Il s'agit d'une réussite importante qui couvre le cycle de vie principal d'une application cloud native moderne. Vous disposez ainsi d'une base solide pour déployer vos propres systèmes agentiques complexes.

Résumé

Dans cet atelier, vous avez appris à :

• Créer une application multi-agents à l'aide d'ADK (Agent Development Kit)
• Déployer l'application sur Vertex AI Agent Engine
• Créez un agent capable de communiquer à l'aide du protocole A2A.

Ressources utiles

• Documentation officielle de l'ADK
• Vertex AI Agent Engine
• Protocole A2A
• Cloud Run