1. Présentation
Les agents IA gagnent rapidement en popularité. Ils révolutionnent l'automatisation des tâches et la prise de décision grâce à leur capacité à fonctionner de manière autonome, à apprendre et à interagir avec leur environnement pour atteindre des objectifs.
Mais comment créer un agent ? Cet atelier de programmation vous aidera à vous lancer en vous montrant comment créer un agent de change capable de convertir les devises de différents pays. Vous créerez ensuite un agent d'agence de voyage et le connecterez à l'agent de change. L'objectif est de vous présenter les dernières technologies pour vous aider à comprendre les acronymes que vous avez peut-être vus sur Internet (MCP, ADK, A2A) et à voir comment ils fonctionnent ensemble.
Protocole MCP (Model Context Protocol)
Le protocole MCP (Model Context Protocol) est un protocole ouvert qui standardise la façon dont les applications fournissent un contexte aux LLM. Il offre un moyen standardisé de connecter des modèles d'IA à des ressources, des requêtes et des outils.
Agent Development Kit (ADK)
Agent Development Kit (ADK) est un framework d'orchestration flexible permettant de développer et de déployer des agents IA. ADK est indépendant du modèle et du déploiement, et conçu pour être compatible avec d'autres frameworks. Il a été conçu pour rendre le développement d'agents semblable à celui de logiciels, afin de permettre aux développeurs de créer, de déployer et d'orchestrer plus facilement des architectures agentiques allant de tâches simples à des workflows complexes.
Protocole Agent2Agent (A2A)
Le protocole Agent2Agent (A2A) est une norme ouverte conçue pour permettre une communication et une collaboration fluides entre les agents IA. Tout comme le protocole MCP fournit un moyen standardisé d'accorder aux LLM l'accès aux données et aux outils, le protocole A2A permet aux agents de communiquer entre eux de manière standardisée. Dans un monde où les agents sont créés à l'aide de frameworks divers et par différents fournisseurs, le protocole A2A fournit un langage commun, éliminant les silos et favorisant l'interopérabilité.
Points abordés
- Créer un serveur MCP local
- Déployer le serveur MCP sur Cloud Run
- Créer un agent avec Agent Development Kit qui utilise des outils MCP
- Exposer un agent ADK en tant que serveur A2A
- Tester le serveur A2A à l'aide d'un client A2A
- Créer un agent pour communiquer avec un autre agent via le protocole A2A
Ce dont vous avez besoin
2. Avant de commencer
Créer un projet
Si vous n'avez pas de projet Google Cloud, créez-en un.
Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
Assurez-vous également que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée pour un projet.
Activer Cloud Shell
Google Cloud Shell est un environnement de développement interactif basé sur un navigateur, fourni directement dans la console Google Cloud. C'est le moyen le plus simple de commencer à utiliser Google Cloud sans avoir à installer d'outils en local.
Cliquez sur ce lien pour activer Cloud Shell. Vous pouvez basculer entre le terminal Cloud Shell (pour exécuter des commandes cloud) et l'éditeur (pour créer des projets) en cliquant sur le bouton correspondant dans Cloud Shell.
Une fois connecté à Cloud Shell, vérifiez que vous êtes déjà authentifié et que le projet est défini sur votre ID de projet à l'aide de la commande suivante :
gcloud auth list
Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud reconnaît votre projet.
gcloud config list project
Utilisez la commande suivante pour définir votre projet :
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Activer API Cloud
Activez les API requises à l'aide de la commande suivante. L'opération peut prendre quelques minutes.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Consultez la documentation pour connaître les commandes gcloud ainsi que leur utilisation.
Obtenir le code
Clonez le dépôt :
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv est utilisé pour gérer les dépendances. Il est déjà installé dans Cloud Shell, mais si vous exécutez l'atelier de programmation en local, vous pouvez l'installer comme suit :
# macOS and Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows (uncomment below line)
# powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
Configurez les variables d'environnement avec un fichier .env en exécutant la commande suivante :
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Créer un serveur MCP local
Avant d'orchestrer votre agent de change, vous devez d'abord créer un serveur MCP pour exposer les outils dont votre agent aura besoin.
Un serveur MCP vous permet d'écrire des programmes légers pour exposer des fonctionnalités spécifiques (comme la récupération des taux de change) en tant qu'outils. Un agent, voire plusieurs agents, peuvent ensuite accéder à ces outils à l'aide du protocole Model Context Protocol (MCP) standardisé.
Le package Python FastMCP peut être utilisé pour créer un serveur MCP qui expose un seul outil appelé get_exchange_rate. L'outil get_exchange_rate effectue un appel sur Internet à l'API Frankfurter pour obtenir le taux de change actuel entre deux devises.
Le code du serveur MCP se trouve dans le fichier mcp-server/server.py :
import logging
import os
import httpx
from fastmcp import FastMCP
# Set up logging
logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
mcp = FastMCP("Currency MCP Server 💵")
@mcp.tool()
def get_exchange_rate(
currency_from: str = 'USD',
currency_to: str = 'EUR',
currency_date: str = 'latest',
):
"""Use this to get current exchange rate.
Args:
currency_from: The currency to convert from (e.g., "USD").
currency_to: The currency to convert to (e.g., "EUR").
currency_date: The date for the exchange rate or "latest". Defaults to "latest".
Returns:
A dictionary containing the exchange rate data, or an error message if the request fails.
"""
logger.info(f"--- 🛠️ Tool: get_exchange_rate called for converting {currency_from} to {currency_to} ---")
try:
response = httpx.get(
f'https://api.frankfurter.app/{currency_date}',
params={'from': currency_from, 'to': currency_to},
)
response.raise_for_status()
data = response.json()
if 'rates' not in data:
return {'error': 'Invalid API response format.'}
logger.info(f'✅ API response: {data}')
return data
except httpx.HTTPError as e:
return {'error': f'API request failed: {e}'}
except ValueError:
return {'error': 'Invalid JSON response from API.'}
if __name__ == "__main__":
logger.info(f"🚀 MCP server started on port {os.getenv('PORT', 8080)}")
# Could also use 'sse' transport, host="0.0.0.0" required for Cloud Run.
asyncio.run(
mcp.run_async(
transport="http",
host="0.0.0.0",
port=os.getenv("PORT", 8080),
)
)
Pour démarrer le serveur MCP en local, ouvrez un terminal et exécutez la commande suivante (le serveur démarrera sur http://localhost:8080) :
uv run mcp-server/server.py
Vérifiez que le serveur MCP fonctionne correctement et que l'outil get_exchange_rate est accessible à l'aide du protocole MCP (Model Context Protocol).
Dans une nouvelle fenêtre de terminal (afin de ne pas arrêter le serveur MCP local), exécutez la commande suivante :
uv run mcp-server/test_server.py
Le taux de change actuel de 1 USD (dollar américain) en EUR (euro) doit s'afficher :
--- 🛠️ Tool found: get_exchange_rate ---
--- 🪛 Calling get_exchange_rate tool for USD to EUR ---
--- ✅ Success: {
"amount": 1.0,
"base": "USD",
"date": "2025-05-26",
"rates": {
"EUR": 0.87866
}
} ---
Formidable ! Vous disposez d'un serveur MCP fonctionnel avec un outil auquel votre agent pourra accéder.
Avant de passer à l'étape suivante, arrêtez le serveur MCP en cours d'exécution en local en exécutant Ctrl+C (ou Command+C sur Mac) dans le terminal où vous l'avez démarré.
4. Déployer votre serveur MCP sur Cloud Run
Vous êtes maintenant prêt à déployer le serveur MCP en tant que serveur MCP distant sur Cloud Run 🚀☁️.
Avantages de l'exécution d'un serveur MCP à distance
L'exécution d'un serveur MCP à distance sur Cloud Run peut offrir plusieurs avantages :
- 📈Scalabilité : Cloud Run est conçu pour effectuer rapidement un scaling horizontal afin de gérer toutes les requêtes entrantes. Cloud Run mettra automatiquement à l'échelle votre serveur MCP en fonction de la demande.
- Serveur centralisé : vous pouvez partager l'accès à un serveur MCP centralisé avec les membres de l'équipe via des droits IAM, ce qui leur permet de s'y connecter depuis leurs machines locales au lieu d'exécuter leurs propres serveurs en local. Si une modification est apportée au serveur MCP, tous les membres de l'équipe en bénéficieront.
- 🔐Sécurité : Cloud Run permet d'appliquer facilement des requêtes authentifiées. Cela permet uniquement des connexions sécurisées à votre serveur MCP, empêchant ainsi tout accès non autorisé.
Accédez au répertoire mcp-server :
cd mcp-server
Déployez le serveur MCP sur Cloud Run :
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Si votre service a été déployé, un message semblable à celui-ci s'affiche :
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
Authentifier les clients MCP
Étant donné que vous avez spécifié --no-allow-unauthenticated pour exiger une authentification, tout client MCP se connectant au serveur MCP distant devra s'authentifier.
La documentation officielle sur l'hébergement de serveurs MCP sur Cloud Run fournit plus d'informations à ce sujet, en fonction de l'endroit où vous exécutez votre client MCP.
Vous devrez exécuter le proxy Cloud Run pour créer un tunnel authentifié vers le serveur MCP distant sur votre machine locale.
Par défaut, l'URL des services Cloud Run exige que toutes les requêtes soient autorisées avec le rôle IAM Demandeur Cloud Run (roles/run.invoker). Cette liaison de stratégie IAM garantit qu'un mécanisme de sécurité renforcé est utilisé pour authentifier votre client MCP local.
Vous devez vous assurer que vous ou tout membre de l'équipe qui tente d'accéder au serveur MCP distant disposez du rôle IAM roles/run.invoker lié à votre principal IAM (compte Google Cloud).
gcloud run services proxy mcp-server --region=us-central1
Vous devriez obtenir le résultat suivant :
Proxying to Cloud Run service [mcp-server] in project [<YOUR_PROJECT_ID>] region [us-central1]
http://127.0.0.1:8080 proxies to https://mcp-server-abcdefgh-uc.a.run.app
Tout le trafic vers http://127.0.0.1:8080 sera désormais authentifié et transféré vers le serveur MCP distant.
Tester le serveur MCP distant
Dans un nouveau terminal, revenez au dossier racine et réexécutez le fichier mcp-server/test_server.py pour vous assurer que le serveur MCP distant fonctionne.
cd ..
uv run mcp-server/test_server.py
Vous devriez obtenir un résultat semblable à celui obtenu lors de l'exécution du serveur en local :
--- 🛠️ Tool found: get_exchange_rate ---
--- 🪛 Calling get_exchange_rate tool for USD to EUR ---
--- ✅ Success: {
"amount": 1.0,
"base": "USD",
"date": "2025-05-26",
"rates": {
"EUR": 0.87866
}
} ---
Vous pouvez interroger les journaux du serveur MCP Cloud Run déployé si vous souhaitez vérifier que le serveur distant a bien été appelé :
gcloud run services logs read mcp-server --region us-central1 --limit 5
Vous devriez obtenir le résultat suivant dans les journaux :
2025-06-04 14:28:29,871 [INFO]: --- 🛠️ Tool: get_exchange_rate called for converting USD to EUR ---
2025-06-04 14:28:30,610 [INFO]: HTTP Request: GET https://api.frankfurter.app/latest?from=USD&to=EUR "HTTP/1.1 200 OK"
2025-06-04 14:28:30,611 [INFO]: ✅ API response: {'amount': 1.0, 'base': 'USD', 'date': '2025-06-03', 'rates': {'EUR': 0.87827}}
Maintenant que vous disposez d'un serveur MCP distant, vous pouvez passer à la création d'un agent. 🤖
5. Créer un agent avec ADK
Vous disposez d'un serveur MCP déployé. Il est maintenant temps de créer l'agent de change à l'aide d'Agent Development Kit (ADK).
ADK permet de créer des agents extrêmement légers et de les connecter à des serveurs MCP grâce à la prise en charge intégrée des outils MCP. L'agent de change accédera à l'outil get_exchange_rate à l'aide de la classe MCPToolset d'ADK.
Le code de l'agent de change se trouve dans currency_agent/agent.py :
import logging
import os
from dotenv import load_dotenv
from google.adk.agents import LlmAgent
from google.adk.a2a.utils.agent_to_a2a import to_a2a
from google.adk.tools.mcp_tool import MCPToolset, StreamableHTTPConnectionParams
logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
load_dotenv()
SYSTEM_INSTRUCTION = (
"You are a specialized assistant for currency conversions. "
"Your sole purpose is to use the 'get_exchange_rate' tool to answer questions about currency exchange rates. "
"If the user asks about anything other than currency conversion or exchange rates, "
"politely state that you cannot help with that topic and can only assist with currency-related queries. "
"Do not attempt to answer unrelated questions or use tools for other purposes."
)
logger.info("--- 🔧 Loading MCP tools from MCP Server... ---")
logger.info("--- 🤖 Creating ADK Currency Agent... ---")
root_agent = LlmAgent(
model="gemini-3.7-flash",
name="currency_agent",
description="An agent that can help with currency conversions",
instruction=SYSTEM_INSTRUCTION,
tools=[
MCPToolset(
connection_params=StreamableHTTPConnectionParams(
url=os.getenv("MCP_SERVER_URL", "http://localhost:8080/mcp")
)
)
],
)
Pour tester rapidement l'agent de change, vous pouvez profiter de l'interface utilisateur de développement d'ADK, accessible en exécutant adk web :
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Dans un navigateur, accédez à http://localhost:8000 pour voir et tester l'agent.
Assurez-vous que currency_agent est sélectionné comme agent en haut à gauche de l'interface utilisateur Web.
Posez une question à votre agent dans la zone de chat, par exemple "Quel est le taux de change de 250 CAD en USD ?". Vous devriez voir l'agent appeler notre outil MCP get_exchange_rate avant de donner une réponse.
L'agent fonctionne. Il peut gérer les requêtes liées aux conversions de devises 💸.
6. Protocole Agent2Agent (A2A)
Le protocole Agent2Agent (A2A) est une norme ouverte conçue pour permettre une communication et une collaboration fluides entre les agents IA. Cela permet aux agents créés à l'aide de frameworks divers et par différents fournisseurs de communiquer entre eux dans un langage commun, éliminant ainsi les silos et favorisant l'interopérabilité.
Le protocole A2A permet aux agents de :
- Découvrir d'autres agents et connaître leurs compétences (AgentSkill) et leurs capacités (AgentCapabilities) à l'aide de cartes d'agent standardisées (Agent Cards).
- Communiquer : échanger des messages et des données de manière sécurisée.
- Collaborer : déléguer des tâches et coordonner des actions pour atteindre des objectifs complexes.
Le protocole A2A facilite cette communication grâce à des mécanismes tels que les "cartes d'agent", qui servent de cartes de visite numériques que les agents peuvent utiliser pour promouvoir leurs capacités et leurs informations de connexion.
Il est maintenant temps d'exposer l'agent de change à l'aide du protocole A2A afin qu'il puisse être appelé par d'autres agents et clients.
SDK Python A2A
Le SDK Python A2A fournit des modèles Pydantic pour chacune des ressources mentionnées ci-dessus : AgentSkill, AgentCapabilities et AgentCard. Cela fournit une interface permettant d'accélérer le développement et l'intégration avec le protocole A2A.
Un AgentSkill vous permet d'indiquer aux autres agents que l'agent de change dispose d'un outil pour get_exchange_rate :
# A2A Agent Skill definition
skill = AgentSkill(
id='get_exchange_rate',
name='Currency Exchange Rates Tool',
description='Helps with exchange values between various currencies',
tags=['currency conversion', 'currency exchange'],
examples=['What is exchange rate between USD and GBP?'],
)
Ensuite, dans le cadre de l'AgentCard, il répertorie les compétences et les capacités de l'agent, ainsi que des informations supplémentaires telles que les modes d'entrée et de sortie que l'agent peut gérer :
# A2A Agent Card definition
agent_card = AgentCard(
name='Currency Agent',
description='Helps with exchange rates for currencies',
url=f'http://{host}:{port}/',
version='1.0.0',
defaultInputModes=["text"],
defaultOutputModes=["text"],
capabilities=AgentCapabilities(streaming=True),
skills=[skill],
)
Il est temps de tout mettre en œuvre avec l'agent de change et de montrer la puissance du protocole A2A.
7. Exposer l'agent de change en tant que serveur A2A
ADK simplifie le processus de création et de connexion d'agents à l'aide du protocole A2A. Pour rendre un agent ADK existant accessible (l'exposer) en tant que serveur A2A, utilisez la fonction to_a2a(root_agent) d'ADK (pour en savoir plus, consultez la documentation ADK).
La fonction to_a2a convertit un agent existant pour qu'il fonctionne avec le protocole A2A et puisse être exposé en tant que serveur via uvicorn. Cela signifie que vous contrôlez plus précisément ce que vous souhaitez exposer si vous prévoyez de mettre votre agent en production. La fonction to_a2a() génère automatiquement une carte d'agent basée sur le code de votre agent à l'aide du SDK Python A2A en arrière-plan.
En examinant le fichier currency_agent/agent.py, vous pouvez voir l'utilisation de to_a2a et comment l'agent de change est exposé en tant que serveur A2A avec seulement deux lignes de code.
from google.adk.a2a.utils.agent_to_a2a import to_a2a
# ... see file for full code
# Make the agent A2A-compatible
a2a_app = to_a2a(root_agent, port=10000)
Pour exécuter le serveur A2A, exécutez la commande suivante dans un nouveau terminal :
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Si le serveur démarre correctement, le résultat suivant s'affiche, indiquant qu'il s'exécute sur le port 10000 :
[INFO]: --- 🔧 Loading MCP tools from MCP Server... ---
[INFO]: --- 🤖 Creating ADK Currency Agent... ---
INFO: Started server process [45824]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://localhost:10000 (Press CTRL+C to quit)
L'agent de change s'exécute désormais en tant que serveur A2A et peut être appelé par d'autres agents ou clients à l'aide du protocole A2A.
Vérifier que l'agent distant est en cours d'exécution
Vous pouvez vérifier que votre agent est en cours d'exécution en accédant à l'URL de la carte d'agent pour l'agent de change qui a été générée automatiquement par la fonction to_a2a().
Dans votre navigateur, accédez à http://localhost:10000/.well-known/agent-card.json.
La carte d'agent suivante doit s'afficher :
{
"capabilities": {
},
"defaultInputModes": [
"text/plain"
],
"defaultOutputModes": [
"text/plain"
],
"description": "An agent that can help with currency conversions",
"name": "currency_agent",
"preferredTransport": "JSONRPC",
"protocolVersion": "0.3.0",
"skills": [
{
"description": "An agent that can help with currency conversions I am a specialized assistant for currency conversions. my sole purpose is to use the 'get_exchange_rate' tool to answer questions about currency exchange rates. If the user asks about anything other than currency conversion or exchange rates, politely state that I cannot help with that topic and can only assist with currency-related queries. Do not attempt to answer unrelated questions or use tools for other purposes.",
"id": "currency_agent",
"name": "model",
"tags": [
"llm"
]
},
{
"description": "Use this to get current exchange rate.\n\nArgs:\n currency_from: The currency to convert from (e.g., \"USD\").\n currency_to: The currency to convert to (e.g., \"EUR\").\n currency_date: The date for the exchange rate or \"latest\". Defaults to \"latest\".\n\nReturns:\n A dictionary containing the exchange rate data, or an error message if the request fails.",
"id": "currency_agent-get_exchange_rate",
"name": "get_exchange_rate",
"tags": [
"llm",
"tools"
]
}
],
"supportsAuthenticatedExtendedCard": false,
"url": "http://localhost:10000",
"version": "0.0.1"
}
Tester le serveur A2A
Vous pouvez maintenant tester le serveur en lui envoyant des requêtes à l'aide du protocole A2A.
Le SDK Python A2A fournit une classe a2a.client.Client qui simplifie cette opération.
Le fichier currency_agent/test_a2aclient.py contient du code qui montre comment récupérer la carte d'agent et envoyer un message au serveur A2A.
# ... see file for full code
async def get_agent_card():
"""Get the agent card."""
print(f"🔄 Fetching the agent card at {AGENT_URL}")
async with httpx.AsyncClient() as httpx_client:
resolver = A2ACardResolver(
httpx_client=httpx_client,
base_url=AGENT_URL,
)
public_agent_card = await resolver.get_agent_card()
print("✅ Successfully fetched the agent card")
return public_agent_card
async def send_message(text_query: str) -> None:
"""
Send a text query to the agent and print the response.
"""
public_agent_card = await get_agent_card()
print("🔄 Initializing a non-streaming client")
config = ClientConfig(streaming=False)
client = await create_client(agent=public_agent_card, client_config=config)
message = new_text_message(text_query, role=Role.ROLE_USER)
print("Sending request:")
request = SendMessageRequest(message=message)
print(request)
print("Response:")
async for chunk in client.send_message(request):
print(chunk)
await client.close()
Exécutez les tests à l'aide de la commande suivante :
uv run currency_agent/test_a2aclient.py
Si le test réussit, le résultat suivant s'affiche :
🔄 Fetching the agent card at http://localhost:10000
✅ Successfully fetched the agent card
====================================================
AgentCard
====================================================
--- General ---
Name : currency_agent
Description : An agent that can help with currency conversions
Version : 0.0.1
--- Interfaces ---
[0] http://localhost:10000 (JSONRPC 1.0)
--- Capabilities ---
Streaming : False
Push notifications : False
Extended agent card : False
--- I/O Modes ---
Input : text/plain
Output : text/plain
--- Skills ---
----------------------------------------------------
ID : currency_agent
Name : model
Description : An agent that can help with currency conversions
Tags : llm
----------------------------------------------------
ID : currency_agent-get_exchange_rate
Name : get_exchange_rate
Description : Use this to get current exchange rate.
Tags : llm, tools
====================================================
🔄 Fetching the agent card at http://localhost:10000
✅ Successfully fetched the agent card
🔄 Initializing a non-streaming client
Sending request:
message {
message_id: "5d190c88-336e-4a22-925d-e2af49cf4bad"
role: ROLE_USER
parts {
text: "how much is 100 USD in GBP?"
}
}
Response:
task {
id: "e6f311bb-654a-477f-82a9-81c7a48f7b81"
context_id: "672e351b-0ff3-4aed-a059-868b383c41a0"
status {
state: TASK_STATE_COMPLETED
timestamp {
seconds: 1787836031
nanos: 994786000
}
}
artifacts {
artifact_id: "e0a05ac8-25c7-471c-a33c-1073fe48cbb8"
parts {
text: "100 USD is currently equal to approximately **73.37 GBP** (at an exchange rate of 1 USD = 0.73368 GBP)."
}
}
...
Ça fonctionne ! Vous avez testé avec succès que vous pouvez communiquer avec l'agent de change via un protocole A2A avec un client A2A. 🎉
Consultez le dépôt a2a-samples sur GitHub pour obtenir d'autres exemples A2A.
8. Utiliser l'agent de change distant via le protocole A2A
À l'étape précédente, vous avez utilisé un client A2A pour communiquer avec l'agent de change via le protocole A2A.
Dans cette étape, voyons comment vous pouvez utiliser l'agent de change en tant qu'agent distant à partir d'un autre agent de voyage.
Le code de l'agent de voyage se trouve dans travel_agent/agent.py :
import logging
import os
from dotenv import load_dotenv
from google.adk.agents import LlmAgent
from google.adk.tools.agent_tool import AgentTool
from google.adk.agents.remote_a2a_agent import RemoteA2aAgent, AGENT_CARD_WELL_KNOWN_PATH
logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
load_dotenv()
SYSTEM_INSTRUCTION = (
"You are a helpful travel assistant. You help users plan trips, recommend places, "
"and answer travel-related questions. "
"Whenever a user asks about currency exchange rates or money conversions, "
"delegate the request to the 'currency_agent' sub-agent."
)
CURRENCY_AGENT_URL = os.getenv("CURRENCY_AGENT_URL", "http://localhost:10000")
logger.info(
"--- 🔗 Connecting to Remote A2A Currency Agent at %s... ---",
CURRENCY_AGENT_URL,
)
currency_remote_agent = RemoteA2aAgent(
name="currency_agent",
agent_card=f"{CURRENCY_AGENT_URL}{AGENT_CARD_WELL_KNOWN_PATH}",
description="An agent that can help with currency conversions and exchange rates.",
)
logger.info("--- 🤖 Creating ADK Travel Agent... ---")
root_agent = LlmAgent(
model="gemini-3.7-flash",
name="travel_agent",
description="A travel assistant that can help plan trips and convert currencies via the remote currency agent.",
instruction=SYSTEM_INSTRUCTION,
tools=[AgentTool(agent=currency_remote_agent)],
)
Notez comment l'agent de change est accessible à l'aide de RemoteA2aAgent.
Exécutez adk web pour tester l'agent de voyage :
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Dans un navigateur, accédez à http://localhost:8000 pour voir et tester l'agent.
Assurez-vous que travel_agent est sélectionné comme agent en haut à gauche de l'interface utilisateur Web.
Posez une question à votre agent dans la zone de chat, par exemple "Quel est le taux de change de 250 CAD en USD ?".
Vous devriez voir l'agent de voyage appeler currency_agent à distance avant de donner une réponse.
L'agent fonctionne. Il peut gérer les requêtes liées aux conversions de devises 💸 en appelant un agent distant à l'aide du protocole A2A.
9. Félicitations
Félicitations ! Vous avez créé et déployé un serveur MCP distant, créé un agent de change à l'aide d'Agent Development Kit (ADK) qui se connecte à des outils à l'aide du protocole MCP, et exposé votre agent à l'aide du protocole Agent2Agent (A2A). Vous avez ensuite créé un agent de voyage pour communiquer à distance avec l'agent de change à l'aide du protocole A2A.
Cliquez ici pour accéder à la documentation complète du code.
Vous souhaitez déployer votre agent ? Agent Runtime de Gemini Enterprise Agent Platform offre une expérience gérée pour le déploiement d'agents IA en production.
Points abordés
- Créer un serveur MCP local
- Déployer le serveur MCP sur Cloud Run
- Créer un agent avec Agent Development Kit qui utilise des outils MCP
- Exposer un agent ADK en tant que serveur A2A
- Tester le serveur A2A à l'aide d'un client A2A
- Créer un agent pour communiquer avec un autre agent via le protocole A2A
Libérer de l'espace
Pour éviter que les ressources utilisées dans cet atelier ne soient facturées sur votre compte Google Cloud, procédez comme suit :
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.