1. Introduction
Cet atelier porte sur l'implémentation et le déploiement d'un service d'agent client. Vous allez utiliser l'Agent Development Kit (ADK) pour créer un agent d'IA qui utilise des outils à distance tels que le serveur MCP créé dans l'atelier 1. Le principe architectural clé démontré est la séparation des préoccupations, avec une couche de raisonnement distincte (l'agent) communiquant avec une couche d'outils distincte (le serveur MCP) via une API sécurisée.
Dans l'atelier 1, vous avez créé un serveur MCP qui fournit des données sur les animaux d'un zoo fictif aux LLM, par exemple lorsque vous utilisez la CLI Gemini. Dans cet atelier, nous allons créer un agent de guide touristique pour le zoo fictif. L'agent utilisera le même serveur MCP que dans l'atelier 1 pour accéder aux informations sur les animaux du zoo. Il utilisera également Wikipédia pour créer la meilleure expérience de visite guidée.
Enfin, nous déploierons l'agent de guide touristique sur Google Cloud Run, afin qu'il soit accessible à tous les visiteurs du zoo et pas seulement en local.
Prérequis
- Un serveur MCP en cours d'exécution sur Cloud Run ou son URL de service associée.
- Un projet Google Cloud avec facturation activée.
Points abordés
- Comment structurer un projet Python pour le déploiement de l'ADK.
- Implémenter un agent utilisant des outils avec google-adk
- Découvrez comment connecter un agent à un serveur MCP distant pour son ensemble d'outils.
- Découvrez comment déployer une application Python en tant que conteneur sans serveur sur Cloud Run.
- Découvrez comment configurer une authentification sécurisée de service à service à l'aide de rôles IAM.
- Comment supprimer des ressources Cloud pour éviter d'encourir des frais à l'avenir.
Prérequis
- Un compte Google Cloud et un projet Google Cloud
- Un navigateur Web tel que Chrome
2. Pourquoi déployer sur Cloud Run ?
Cloud Run est un excellent choix pour héberger des agents ADK, car il s'agit d'une plate-forme sans serveur. Vous pouvez donc vous concentrer sur votre code et non sur la gestion de l'infrastructure sous-jacente. Nous nous occupons des tâches opérationnelles pour vous.
Considérez-le comme un magasin éphémère : il n'ouvre et n'utilise des ressources que lorsque des clients (demandes) arrivent. Lorsqu'il n'y a pas de clients, il ferme complètement et vous ne payez pas pour un magasin vide.
Principales fonctionnalités
Exécutez des conteneurs n'importe où :
- Vous fournissez un conteneur (image Docker) contenant votre application.
- Cloud Run l'exécute sur l'infrastructure de Google.
- Vous n'avez plus à vous soucier des correctifs de l'OS, de la configuration des VM ni du scaling.
Scaling automatique :
- Si aucune personne n'utilise votre application, aucune instance n'est exécutée (vous ne payez rien en cas d'inactivité).
- Si 1 000 requêtes sont envoyées, il génère autant de copies que nécessaire.
Sans état par défaut :
- Chaque requête peut être envoyée à une instance différente.
- Si vous avez besoin de stocker un état, utilisez un service externe tel que Cloud SQL, Firestore ou Redis.
Compatible avec n'importe quel langage ou framework :
- Tant qu'il s'exécute dans un conteneur Linux, Cloud Run n'a pas d'importance qu'il s'agisse de Python, Go, Node.js, Java ou .NET.
Payez seulement ce que vous utilisez :
- Facturation par requête + temps de calcul (jusqu'à 100 ms).
- Vous ne payez pas les ressources inactives comme avec une VM traditionnelle.
3. Préparation
Configuration de l'environnement au rythme de chacun
- Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.
- Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
- L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par
PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet. - Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
- Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.
Démarrer Cloud Shell
Accédez à l'éditeur Cloud Shell.
Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
- Cliquez sur Terminal
- Cliquez sur Nouveau terminal.
Dans le terminal, définissez votre projet à l'aide de la commande suivante. Si vous avez terminé l'atelier 1, assurez-vous d'utiliser le même ID de projet :
gcloud config set project [YOUR-PROJECT-ID]
Si vous ne vous souvenez pas de l'ID de votre projet, vous pouvez l'obtenir en exécutant la commande suivante :
gcloud projects list | awk '/PROJECT_ID/{print $2}'
4. Si vous êtes invité à autoriser l'accès, cliquez sur Autoriser pour continuer.
5. Le message suivant doit s'afficher :
Updated property [core/project].
If you see a `WARNING` and are asked `Do you want to continue (Y/n)?`,
then you have likely entered the project ID incorrectly. Press `n`,
press `Enter`, and try to run the `gcloud config set project` command again.
4. Avant de commencer
Activer les API et définir les variables d'environnement
Activez tous les services nécessaires :
gcloud services enable \
run.googleapis.com \
artifactregistry.googleapis.com \
cloudbuild.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Résultat attendu
Operation "operations/acat.p2-[GUID]" finished successfully.
Configurez votre région par défaut pour utiliser les modèles d'embedding Vertex AI. En savoir plus sur les emplacements disponibles pour Vertex AI Dans l'exemple, nous utilisons la région europe-west1.
gcloud config set compute/region europe-west1
5. Télécharger et installer l'ADK, puis créer un dossier de projet
Créez les répertoires du projet.
Cette commande crée un dossier principal pour le code source de l'atelier et de l'agent.
cd && mkdir zoo_guide_agent && cd zoo_guide_agent
Créez un environnement virtuel.
python3 -m venv .venv
Activez l'environnement virtuel :
source .venv/bin/activate
Créez le fichier requirements.txt. Ce fichier répertorie les bibliothèques Python dont votre agent a besoin. La commande suivante crée le fichier et le remplit.
cloudshell edit requirements.txt
google-adk==1.12.0
langchain-community
wikipedia
Vous devez exécuter la commande à partir du répertoire principal de votre projet, zoo_guide_agent.
pip install -r requirements.txt
Définissez des variables pour votre projet, votre région et votre utilisateur actuels. Il s'agit d'une méthode plus robuste pour exécuter ces commandes.
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_REGION=$(gcloud config get-value compute/region)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export SERVICE_ACCOUNT="${PROJECT_NUMBER}-compute@developer.gserviceaccount.com"
Créez et ouvrez un fichier .env pour authentifier l'agent dans le répertoire zoo_guide_agent.
cloudshell edit .env
La commande cloudshell edit ouvre le fichier .env dans l'éditeur au-dessus du terminal. Saisissez les éléments suivants dans le fichier .env, puis revenez au terminal.
MODEL="gemini-2.5-flash"
SERVICE_ACCOUNT="${PROJECT_NUMBER}-compute@developer.gserviceaccount.com"
Ajoutez l'URL du serveur MCP. Si vous avez terminé l'atelier 1, suivez ces étapes pour utiliser le serveur MCP que vous avez créé dans l'atelier 1 :
- Autorisez l'identité du service Cloud Run à appeler le serveur MCP distant.
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT" \
--role="roles/run.invoker"
- Enregistrez l'URL du serveur MCP de l'atelier 1 dans une variable d'environnement.
echo -e "\nMCP_SERVER_URL=https://zoo-mcp-server-${PROJECT_NUMBER}.europe-west1.run.app/mcp/" >> .env
Si vous utilisez un lien de serveur MCP public, exécutez la commande suivante et remplacez PROJECT_NUMBER par la valeur fournie.
echo -e "\nMCP_SERVER_URL=https://zoo-mcp-server-${PROJECT_NUMBER}.europe-west1.run.app/mcp/" >> .env
6. Créer un workflow d'agent
Créer le fichier init.py
Créez le fichier init.py. Ce fichier indique à Python que le répertoire zoo_guide_agent est un package.
cloudshell edit __init__.py
La commande ci-dessus ouvre l'éditeur de code. Ajoutez le code suivant à __init__.py :
from . import agent
Créer le fichier main agent.py
Créez le fichier principal agent.py. Cette commande crée le fichier Python et y colle le code complet de votre système multi-agents.
cloudshell edit agent.py
Étape 1 : Importations et configuration initiale
Ce premier bloc importe toutes les bibliothèques nécessaires à partir de l'ADK et de Google Cloud. Il configure également la journalisation et charge les variables d'environnement à partir de votre fichier .env, ce qui est essentiel pour accéder à votre modèle et à l'URL du serveur.
Ajoutez le code suivant à votre fichier agent.py :
import os
import logging
import google.cloud.logging
from dotenv import load_dotenv
from google.adk import Agent
from google.adk.agents import SequentialAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StreamableHTTPConnectionParams
from google.adk.tools.tool_context import ToolContext
from google.adk.tools.langchain_tool import LangchainTool
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
import google.auth
import google.auth.transport.requests
import google.oauth2.id_token
# --- Setup Logging and Environment ---
cloud_logging_client = google.cloud.logging.Client()
cloud_logging_client.setup_logging()
load_dotenv()
model_name = os.getenv("MODEL")
Étape 2 : Définir les outils (les capacités de l'agent)
L'efficacité d'un agent dépend des outils qu'il peut utiliser. Dans cette section, nous définissons toutes les capacités de notre agent, y compris une fonction personnalisée pour enregistrer des données, un outil MCP qui se connecte à notre serveur MCP sécurisé ainsi qu'un outil Wikipédia.
Ajoutez le code suivant en bas de agent.py :
# Greet user and save their prompt
def add_prompt_to_state(
tool_context: ToolContext, prompt: str
) -> dict[str, str]:
"""Saves the user's initial prompt to the state."""
tool_context.state["PROMPT"] = prompt
logging.info(f"[State updated] Added to PROMPT: {prompt}")
return {"status": "success"}
# Configuring the MCP Tool to connect to the Zoo MCP server
mcp_server_url = os.getenv("MCP_SERVER_URL")
if not mcp_server_url:
raise ValueError("The environment variable MCP_SERVER_URL is not set.")
def get_id_token():
"""Get an ID token to authenticate with the MCP server."""
target_url = os.getenv("MCP_SERVER_URL")
audience = target_url.split('/mcp/')[0]
request = google.auth.transport.requests.Request()
id_token = google.oauth2.id_token.fetch_id_token(request, audience)
return id_token
"""
# Use this code if you are using the public MCP Server and comment out the code below defining mcp_tools
mcp_tools = MCPToolset(
connection_params=StreamableHTTPConnectionParams(
url=mcp_server_url
)
)
"""
mcp_tools = MCPToolset(
connection_params=StreamableHTTPConnectionParams(
url=mcp_server_url,
headers={
"Authorization": f"Bearer {get_id_token()}",
},
),
)
# Configuring the Wikipedia Tool
wikipedia_tool = LangchainTool(
tool=WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
)
Présentation des trois outils
add_prompt_to_state📝
Cet outil se souvient de ce que demande un visiteur du zoo. Lorsqu'un visiteur demande "Où sont les lions ?", cet outil enregistre cette question spécifique dans la mémoire de l'agent afin que les autres agents du workflow sachent ce qu'ils doivent rechercher.
Comment : il s'agit d'une fonction Python qui écrit la requête du visiteur dans le dictionnaire tool_context.state partagé. Ce contexte d'outil représente la mémoire à court terme de l'agent pour une seule conversation. Les données enregistrées dans l'état par un agent peuvent être lues par l'agent suivant du workflow.
MCPToolset🦁
Il permet de connecter l'agent de guide touristique au serveur MCP Zoo créé dans l'atelier 1. Ce serveur dispose d'outils spéciaux pour rechercher des informations spécifiques sur nos animaux, comme leur nom, leur âge et leur enclos.
Comment : il se connecte de manière sécurisée à l'URL du serveur privé du zoo. Il utilise get_id_token pour obtenir automatiquement une "carte d'accès" sécurisée (un jeton d'identification de compte de service) afin de prouver son identité et d'obtenir l'accès.
LangchainTool🌍
Cela permet à l'agent de guide touristique d'acquérir des connaissances générales sur le monde. Lorsqu'un visiteur pose une question qui ne figure pas dans la base de données du zoo, comme "Que mangent les lions à l'état sauvage ?", cet outil permet à l'agent de trouver la réponse sur Wikipédia.
Comment : il sert d'adaptateur, permettant à notre agent d'utiliser l'outil WikipediaQueryRun prédéfini de la bibliothèque LangChain.
Ressources :
Étape 3 : Définir les agents spécialisés
Nous allons ensuite définir l'agent de recherche et l'agent de mise en forme des réponses. L'agent de recherche est le "cerveau" de notre opération. Cet agent prend la requête de l'utilisateur à partir de State, examine ses puissants outils (l'outil de serveur MCP de Zoo et l'outil Wikipédia), et décide lesquels utiliser pour trouver la réponse.
Le rôle de l'agent de mise en forme des réponses est la présentation. Elle n'utilise aucun outil pour trouver de nouvelles informations. Au lieu de cela, il prend les données brutes collectées par l'agent Researcher (transmises via l'état) et utilise les compétences linguistiques du LLM pour les transformer en une réponse conviviale et conversationnelle.
Ajoutez le code suivant en bas de agent.py :
# 1. Researcher Agent
comprehensive_researcher = Agent(
name="comprehensive_researcher",
model=model_name,
description="The primary researcher that can access both internal zoo data and external knowledge from Wikipedia.",
instruction="""
You are a helpful research assistant. Your goal is to fully answer the user's PROMPT.
You have access to two tools:
1. A tool for getting specific data about animals AT OUR ZOO (names, ages, locations).
2. A tool for searching Wikipedia for general knowledge (facts, lifespan, diet, habitat).
First, analyze the user's PROMPT.
- If the prompt can be answered by only one tool, use that tool.
- If the prompt is complex and requires information from both the zoo's database AND Wikipedia,
you MUST use both tools to gather all necessary information.
- Synthesize the results from the tool(s) you use into preliminary data outputs.
PROMPT:
{{ PROMPT }}
""",
tools=[
mcp_tools,
wikipedia_tool
],
output_key="research_data" # A key to store the combined findings
)
# 2. Response Formatter Agent
response_formatter = Agent(
name="response_formatter",
model=model_name,
description="Synthesizes all information into a friendly, readable response.",
instruction="""
You are the friendly voice of the Zoo Tour Guide. Your task is to take the
RESEARCH_DATA and present it to the user in a complete and helpful answer.
- First, present the specific information from the zoo (like names, ages, and where to find them).
- Then, add the interesting general facts from the research.
- If some information is missing, just present the information you have.
- Be conversational and engaging.
RESEARCH_DATA:
{{ research_data }}
"""
)
Étape 4 : L'agent de workflow
L'agent de workflow agit comme le responsable du "back-office" pour la visite du zoo. Elle prend en compte la demande de recherche et s'assure que les deux agents que nous avons définis ci-dessus effectuent leur travail dans le bon ordre : d'abord la recherche, puis la mise en forme. Cela crée un processus prévisible et fiable pour répondre à la question d'un visiteur.
Comment : il s'agit d'un SequentialAgent, un type spécial d'agent qui ne réfléchit pas par lui-même. Son seul rôle est d'exécuter une liste de sub_agents (le chercheur et le formateur) dans une séquence fixe, en transmettant automatiquement la mémoire partagée de l'un à l'autre.
Ajoutez ce bloc de code en bas de agent.py :
tour_guide_workflow = SequentialAgent(
name="tour_guide_workflow",
description="The main workflow for handling a user's request about an animal.",
sub_agents=[
comprehensive_researcher, # Step 1: Gather all data
response_formatter, # Step 2: Format the final response
]
)
Étape finale : assembler le workflow principal 
Cet agent est désigné comme root_agent, que le framework ADK utilise comme point de départ pour toutes les nouvelles conversations. Son rôle principal est d'orchestrer l'ensemble du processus. Il sert de contrôleur initial et gère le premier tour de la conversation.
Ajoutez ce dernier bloc de code en bas de agent.py :
root_agent = Agent(
name="greeter",
model=model_name,
description="The main entry point for the Zoo Tour Guide.",
instruction="""
- Let the user know you will help them learn about the animals we have in the zoo.
- When the user responds, use the 'add_prompt_to_state' tool to save their response.
After using the tool, transfer control to the 'tour_guide_workflow' agent.
""",
tools=[add_prompt_to_state],
sub_agents=[tour_guide_workflow]
)
Votre fichier agent.py est maintenant terminé. En le construisant de cette manière, vous pouvez voir comment chaque composant (outils, agents de nœud de calcul et agents de gestion) joue un rôle spécifique dans la création du système intelligent final. Passons au déploiement !
7. Préparer l'application pour le déploiement
Une fois votre environnement local prêt, l'étape suivante consiste à préparer votre projet Google Cloud pour le déploiement. Cela implique une vérification finale de la structure de fichier de votre agent pour s'assurer qu'elle est compatible avec la commande de déploiement. Plus important encore, vous configurez une autorisation IAM essentielle qui permet à votre service Cloud Run déployé d'agir en votre nom et d'appeler les modèles Vertex AI. Cette étape permet de s'assurer que l'environnement cloud est prêt à exécuter votre agent correctement.
Chargez les variables dans votre session shell en exécutant la commande source.
source .env
Attribuez le rôle Utilisateur Vertex AI au compte de service, ce qui lui permet de générer des prédictions et d'appeler les modèles de Google.
# Grant the "Vertex AI User" role to your service account
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT" \
--role="roles/aiplatform.user"
8. Déployer l'agent à l'aide de l'ADK CLI
Maintenant que votre code local est prêt et que votre projet Google Cloud est préparé, il est temps de déployer l'agent. Vous utiliserez la commande adk deploy cloud_run, un outil pratique qui automatise l'ensemble du workflow de déploiement. Cette commande unique empaquette votre code, crée une image de conteneur, la transfère vers Artifact Registry et lance le service sur Cloud Run, le rendant accessible sur le Web.
Créer un fichier .gcloudignore
Pour réduire notre temps de déploiement, nous souhaitons créer un fichier .gcloudignore. Pour ce faire, exécutez les commandes suivantes pour déployer votre agent.
cloudshell edit .gcloudignore
La commande cloudshell edit ouvre le fichier .gcloudignore dans l'éditeur au-dessus du terminal. Écrivez ce qui suit dans le fichier et enregistrez-le. Revenez ensuite au terminal pour exécuter les commandes de déploiement de la section suivante.
.venv/
Déployer
Exécutez les commandes suivantes pour déployer votre agent.
# Run the deployment command
adk deploy cloud_run \
--project=$PROJECT_ID \
--region=europe-west1 \
--service_name=zoo-tour-guide \
--with_ui \
.
gcloud run services update zoo-tour-guide \
--region=europe-west1 \
--update-labels=dev-tutorial=codelab-adk
Accepter les invites
Le message suivant peut s'afficher :
Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region [europe-west1] will be created. Do you want to continue (Y/n)?
Saisissez Y et appuyez sur ENTRÉE.
Le message suivant peut s'afficher :
Allow unauthenticated invocations to [your-service-name] (y/N)?.
Pour cet atelier, nous voulons autoriser les appels non authentifiés afin de faciliter les tests. Saisissez y et appuyez sur Entrée.
Obtenir le lien de déploiement
Une fois l'exécution réussie, la commande fournit l'URL du service Cloud Run déployé. (Elle ressemblera à quelque chose comme https://zoo-tour-guide-123456789.europe-west1.run.app.) Copiez cette URL pour la tâche suivante.
9. Tester l'agent déployé
Maintenant que votre agent est en ligne sur Cloud Run, vous allez effectuer un test pour vérifier que le déploiement a réussi et que l'agent fonctionne comme prévu. Vous utiliserez l'URL du service public (par exemple, https://zoo-tour-guide-123456789.europe-west1.run.app/) pour accéder à l'interface Web de l'ADK et interagir avec l'agent.
Ouvrez l'URL publique du service Cloud Run dans votre navigateur Web. Comme vous avez utilisé --with_ui flag, l'interface utilisateur du développeur ADK devrait s'afficher.
Activez Token Streaming en haut à droite.
Vous pouvez maintenant interagir avec l'agent Zoo.
Saisissez hello et appuyez sur Entrée pour démarrer une nouvelle conversation.
Observez le résultat. L'agent doit répondre rapidement par un message d'accueil :
"Hello! I'm your Zoo Tour Guide. I can help you learn about the amazing animals we have here. What would you like to know or explore today?"
Explication du flux d'agent
Votre système fonctionne comme une équipe multi-agents intelligente. Le processus est géré par une séquence claire pour assurer un flux fluide et efficace, de la question de l'utilisateur à la réponse finale détaillée.
1. L'agent d'accueil du zoo (le bureau d'accueil)
L'ensemble du processus commence avec l'agent d'accueil.
Son rôle : lancer la conversation. Son instruction est de saluer l'utilisateur et de lui demander quel animal il souhaite découvrir.
Son outil : lorsque l'utilisateur répond, le salueur utilise son outil add_prompt_to_state pour capturer ses mots exacts (par exemple, "parle-moi des lions") et les enregistrer dans la mémoire du système.
Le transfert : après avoir enregistré la requête, le contrôle est immédiatement transmis à son sous-agent, tour_guide_workflow.
2. Le chercheur complet (le super-chercheur)
Il s'agit de la première étape du workflow principal et du "cerveau" de l'opération. Au lieu d'une grande équipe, vous disposez désormais d'un seul agent hautement qualifié qui peut accéder à toutes les informations disponibles.
Son rôle : analyser la question de l'utilisateur et élaborer un plan intelligent. Il utilise la puissante capacité d'utilisation d'outils du modèle linguistique pour déterminer s'il a besoin :
- Données internes issues des registres du zoo (via le serveur MCP).
- Connaissances générales issues du Web (via l'API Wikipédia).
- ou les deux pour les questions complexes.
Son action : il exécute le ou les outils nécessaires pour collecter toutes les données brutes requises. Par exemple, si vous lui demandez "Quel âge ont nos lions et que mangent-ils à l'état sauvage ?", il appellera le serveur MCP pour obtenir l'âge et l'outil Wikipédia pour obtenir des informations sur leur régime alimentaire.
3. Formateur de réponse (présentateur)
Une fois que le chercheur complet a rassemblé tous les faits, il s'agit du dernier agent à exécuter.
Son rôle : servir de voix amicale pour le guide de visite du zoo. Il prend les données brutes (qui peuvent provenir d'une ou des deux sources) et les affine.
Son action : il synthétise toutes les informations en une seule réponse cohérente et attrayante. En suivant ses instructions, il présente d'abord les informations spécifiques sur le zoo, puis ajoute les faits généraux intéressants.
Résultat final : texte généré par l'agent. Il s'agit de la réponse complète et détaillée que l'utilisateur voit dans la fenêtre de chat.
Si vous souhaitez en savoir plus sur la création d'agents, consultez les ressources suivantes :
10. Nettoyer l'environnement
gcloud run services delete zoo-tour-guide --region=europe-west1 --quiet
gcloud artifacts repositories delete cloud-run-source-deploy --location=europe-west1 --quiet
11. Félicitations
Bravo ! Vous avez terminé cet atelier de programmation.
Points abordés
- Découvrez comment structurer un projet Python pour le déploiement avec l'interface de ligne de commande ADK.
- Comment implémenter un workflow multi-agent à l'aide de SequentialAgent et ParallelAgent.
- Comment se connecter à un serveur MCP distant à l'aide de MCPToolset pour utiliser ses outils.
- Découvrez comment enrichir vos données internes en intégrant des outils externes comme l'API Wikipédia.
- Découvrez comment déployer un agent en tant que conteneur sans serveur sur Cloud Run à l'aide de la commande adk deploy.
12. Enquête
Résultat :