1. Descripción general
Los agentes de IA están creciendo rápidamente en popularidad y revolucionan la automatización de tareas y la toma de decisiones con su capacidad de operar de forma autónoma, aprender e interactuar con su entorno para lograr objetivos.
Pero, ¿cómo se crea un agente? Este codelab te ayudará a comenzar, ya que te mostrará cómo crear un agente de divisas que pueda realizar conversiones entre las monedas de diferentes países. Luego, crearás un agente de agencia de viajes y lo conectarás al agente de divisas. El objetivo es guiarte a través de las tecnologías más recientes para ayudarte a comprender esas siglas que quizás hayas visto en Internet (MCP, ADK, A2A) y ver cómo encajan.
Protocolo de contexto del modelo (MCP)
El Protocolo de contexto del modelo (MCP) es un protocolo abierto que estandariza la forma en que las aplicaciones proporcionan contexto a los LLM. El MCP proporciona una forma estandarizada de conectar modelos de IA a recursos, instrucciones y herramientas.
Kit de desarrollo de agentes (ADK)
El Kit de desarrollo de agentes (ADK) es un framework de organización flexible para desarrollar y, luego, implementar agentes de IA. El ADK es independiente del modelo y de la implementación, y está diseñado para la compatibilidad con otros frameworks. El ADK se diseñó para que el desarrollo de agentes se parezca más al desarrollo de software, para que los desarrolladores puedan crear, implementar y organizar arquitecturas de agentes que van desde tareas simples hasta flujos de trabajo complejos.
Protocolo Agent2Agent (A2A)
El protocolo Agent2Agent (A2A) es un estándar abierto diseñado para permitir la comunicación y la colaboración sin problemas entre agentes de IA. Al igual que el MCP proporciona una forma estandarizada de darles a los LLM acceso a datos y herramientas, el A2A proporciona una forma estandarizada para que los agentes hablen con otros agentes. En un mundo en el que los agentes se crean con diversos frameworks y por diferentes proveedores, el A2A proporciona un lenguaje común, rompe los silos y fomenta la interoperabilidad.
Qué aprenderás
- Cómo crear un servidor de MCP local
- Cómo implementar el servidor de MCP en Cloud Run
- Cómo crear un agente con el Kit de desarrollo de agentes que usa herramientas de MCP
- Cómo exponer un agente del ADK como un servidor A2A
- Cómo probar el servidor A2A con un cliente A2A
- Cómo crear un agente para hablar con otro agente a través del protocolo A2A
Requisitos
2. Antes de comenzar
Crea un proyecto
Si no tienes un proyecto de Google Cloud, crea uno.
En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
Además, asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto.
Activar Cloud Shell
Google Cloud Shell es un entorno de desarrollo interactivo basado en navegador que se proporciona directamente en la consola de Google Cloud. Es la forma más sencilla de comenzar a usar Google Cloud sin necesidad de instalar herramientas de forma local.
Activa Cloud Shell haciendo clic en este vínculo. Puedes alternar entre la terminal de Cloud Shell (para ejecutar comandos en la nube) y el editor (para crear proyectos) haciendo clic en el botón correspondiente en Cloud Shell.
Una vez que te conectes a Cloud Shell, verifica que ya te autenticaste y que el proyecto esté configurado con el ID de tu proyecto con el siguiente comando:
gcloud auth list
En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto.
gcloud config list project
Usa el siguiente comando para configurar tu proyecto:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Habilita las API de Cloud
Habilita las APIs requeridas con el siguiente comando. Esto puede tardar algunos minutos.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Consulta la documentación para ver los comandos y el uso de gcloud.
Obtén el código
Clona el repositorio:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv se usa para administrar dependencias y ya está instalado en Cloud Shell, pero si ejecutas el codelab de forma local, puedes instalarlo de la siguiente manera:
# 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"
Configura las variables de entorno con un archivo .env ejecutando lo siguiente:
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Crea un servidor de MCP local
Antes de organizar tu agente de divisas, primero crearás un servidor de MCP para exponer las herramientas que necesitará tu agente.
Un servidor de MCP te permite escribir programas livianos para exponer capacidades específicas (como obtener tipos de cambio de divisas) como herramientas. Luego, un agente o incluso varios agentes pueden acceder a estas herramientas con el Protocolo de contexto del modelo (MCP) estandarizado.
Se puede aprovechar el paquete FastMCP de Python para crear un servidor de MCP que exponga una sola herramienta llamada get_exchange_rate. La herramienta get_exchange_rate realiza una llamada a través de Internet a la API de Frankfurter para obtener el tipo de cambio actual entre dos monedas.
El código del servidor de MCP se puede encontrar en el archivo 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),
)
)
Para iniciar el servidor de MCP de forma local, abre una terminal y ejecuta el siguiente comando (el servidor se iniciará en http://localhost:8080):
uv run mcp-server/server.py
Prueba que el servidor de MCP funcione correctamente y que se pueda acceder a la herramienta get_exchange_rate con el Protocolo de contexto del modelo.
En una ventana de terminal nueva (para no detener el servidor de MCP local), ejecuta lo siguiente:
uv run mcp-server/test_server.py
Deberías ver el tipo de cambio actual de 1 USD (dólar estadounidense) a EUR (euro):
--- 🛠️ 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
}
} ---
Excelente. Creaste correctamente un servidor de MCP en funcionamiento con una herramienta a la que podrá acceder tu agente.
Antes de pasar a la siguiente estación, detén el servidor de MCP que se ejecuta de forma local ejecutando Ctrl+C (o Command+C en Mac) en la terminal en la que lo iniciaste.
4. Implementa tu servidor de MCP en Cloud Run
Ahora estás listo para implementar el servidor de MCP como un servidor de MCP remoto en Cloud Run 🚀☁️.
Beneficios de ejecutar un servidor de MCP de forma remota
Ejecutar un servidor de MCP de forma remota en Cloud Run puede proporcionar varios beneficios:
- 📈Escalabilidad: Cloud Run está diseñado para escalar horizontalmente con rapidez con el fin de controlar todas las solicitudes entrantes. Cloud Run escalará tu servidor de MCP automáticamente según la demanda.
- 👥Servidor centralizado: Puedes compartir el acceso a un servidor de MCP centralizado con los miembros del equipo a través de privilegios de IAM, lo que les permite conectarse a él desde sus máquinas locales en lugar de ejecutar todos sus propios servidores de forma local. Si se realiza un cambio en el servidor de MCP, todos los miembros del equipo se beneficiarán de él.
- 🔐Seguridad: Cloud Run proporciona una forma sencilla de forzar solicitudes autenticadas. Esto permite solo conexiones seguras a tu servidor de MCP, lo que impide el acceso no autorizado.
Cambia al directorio mcp-server:
cd mcp-server
Implementa el servidor de MCP en Cloud Run:
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Si tu servicio se implementó correctamente, verás un mensaje como el siguiente:
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
Cómo autenticar clientes de MCP
Como especificaste --no-allow-unauthenticated para requerir autenticación, cualquier cliente de MCP que se conecte al servidor de MCP remoto deberá autenticarse.
En la documentación oficial para alojar servidores de MCP en Cloud Run, se proporciona más información sobre este tema, según dónde ejecutes tu cliente de MCP.
Deberás ejecutar el proxy de Cloud Run para crear un túnel autenticado al servidor de MCP remoto en tu máquina local.
De forma predeterminada, la URL de los servicios de Cloud Run requiere que todas las solicitudes se autoricen con el rol de IAM de invocador de Cloud Run (roles/run.invoker). Esta vinculación de política de IAM garantiza que se use un mecanismo de seguridad sólido para autenticar tu cliente de MCP local.
Debes asegurarte de que tú o cualquier miembro del equipo que intente acceder al servidor de MCP remoto tenga el rol de IAM roles/run.invoker vinculado a su principal de IAM (cuenta de Google Cloud).
gcloud run services proxy mcp-server --region=us-central1
Deberías ver el siguiente resultado:
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
Ahora, todo el tráfico a http://127.0.0.1:8080 se autenticará y se reenviará al servidor de MCP remoto.
Prueba el servidor de MCP remoto
En una terminal nueva, vuelve a la carpeta raíz y vuelve a ejecutar el archivo mcp-server/test_server.py para asegurarte de que el servidor de MCP remoto funcione.
cd ..
uv run mcp-server/test_server.py
Deberías ver un resultado similar al que viste cuando ejecutaste el servidor de forma 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
}
} ---
Puedes consultar los registros del servidor de MCP de Cloud Run implementado si deseas verificar que se llamó al servidor remoto:
gcloud run services logs read mcp-server --region us-central1 --limit 5
Deberías ver lo siguiente en los registros:
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}}
Ahora que tienes un servidor de MCP remoto, puedes crear un agente. 🤖
5. Crea un agente con el ADK
Tienes un servidor de MCP implementado, ahora es el momento de crear el agente de divisas con el Kit de desarrollo de agentes (ADK).
El ADK hace que la creación de agentes sea extremadamente liviana y les permite conectarse a servidores de MCP con compatibilidad integrada para las herramientas de MCP. El agente de divisas accederá a la herramienta get_exchange_rate con la clase MCPToolset del ADK.
El código del agente de divisas se encuentra en 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")
)
)
],
)
Para probar rápidamente el agente de divisas, puedes aprovechar la IU de desarrollo del ADK, a la que se accede ejecutando adk web:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
En un navegador, ve a http://localhost:8000 para ver y probar el agente.
Asegúrate de que currency_agent esté seleccionado como el agente en la esquina superior izquierda de la IU web.
Pregúntale a tu agente en el área de chat algo como "¿Cuánto son 250 CAD en USD?". Deberías ver que el agente llama a nuestra herramienta de MCP get_exchange_rate antes de dar una respuesta.
El agente funciona. Puede controlar las consultas que giran en torno a las conversiones de divisas 💸.
6. Protocolo Agent2Agent (A2A)
El protocolo Agent2Agent (A2A) es un estándar abierto diseñado para permitir la comunicación y la colaboración sin problemas entre agentes de IA. Esto permite que los agentes que se crean con diversos frameworks y por diferentes proveedores se comuniquen entre sí en un lenguaje común, rompan los silos y fomenten la interoperabilidad.
El A2A permite que los agentes hagan lo siguiente:
- Descubrir: Encuentra otros agentes y aprende sus habilidades (AgentSkill) y capacidades (AgentCapabilities) con tarjetas de agentes estandarizadas.
- Comunicarse: Intercambia mensajes y datos de forma segura.
- Colaborar: Delega tareas y coordina acciones para lograr objetivos complejos.
El protocolo A2A facilita esta comunicación a través de mecanismos como las "tarjetas de agentes" que actúan como tarjetas de presentación digitales que los agentes pueden usar para anunciar sus capacidades y la información de conexión.
Ahora es el momento de exponer el agente de divisas con A2A para que otros agentes y clientes puedan llamarlo.
SDK de Python de A2A
El SDK de Python de A2A proporciona modelos de Pydantic para cada uno de los recursos mencionados anteriormente: AgentSkill, AgentCapabilities y AgentCard. Esto proporciona una interfaz para acelerar el desarrollo y la integración con el protocolo A2A.
Un AgentSkill es la forma en que anunciarás a otros agentes que el agente de divisas tiene una herramienta para 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?'],
)
Luego, como parte de AgentCard, se enumerarán las habilidades y capacidades del agente junto con detalles adicionales, como los modos de entrada y salida que puede controlar el agente:
# 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],
)
Llegó el momento de combinar todo con el agente de divisas y mostrar el poder de A2A.
7. Expón el agente de divisas como servidor A2A
El ADK simplifica el proceso de creación y conexión de agentes con el protocolo A2A. Para que un agente del ADK existente sea accesible (exponerlo) como un servidor A2A, se usa la función to_a2a(root_agent) del ADK (consulta la documentación del ADK para obtener todos los detalles).
La función to_a2a convierte un agente existente para que funcione con A2A y pueda exponerlo como un servidor a través de uvicorn. Esto significa que tienes un control más estricto sobre lo que deseas exponer si planeas producir tu agente. La función to_a2a() genera automáticamente una tarjeta de agente basada en el código de tu agente con el SDK de Python de A2A en segundo plano.
Si observas el archivo currency_agent/agent.py, puedes ver el uso de to_a2a y cómo se expone el agente de divisas como un servidor A2A con solo dos líneas de código.
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)
Para ejecutar el servidor A2A, ejecuta lo siguiente en una terminal nueva:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Si el servidor se inicia correctamente, el resultado se verá de la siguiente manera, lo que indica que se ejecuta en el puerto 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)
Ahora, el agente de divisas se ejecuta correctamente como un servidor A2A, con la capacidad de que otros agentes o clientes lo llamen con el protocolo A2A.
Verifica que el agente remoto esté en ejecución
Puedes volver a verificar que tu agente esté en funcionamiento visitando la URL de la tarjeta de agente para el agente de divisas que generó automáticamente la función to_a2a().
En tu navegador, ve a http://localhost:10000/.well-known/agent-card.json.
Deberías ver la siguiente tarjeta de agente:
{
"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"
}
Prueba el servidor A2A
Ahora puedes probar el servidor enviándole algunas solicitudes con A2A.
El SDK de Python de A2A proporciona una clase a2a.client.Client que simplifica esto.
El archivo currency_agent/test_a2aclient.py contiene código que muestra cómo obtener la tarjeta de agente y enviar un mensaje al servidor 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()
Ejecuta las pruebas con el siguiente comando:
uv run currency_agent/test_a2aclient.py
Una ejecución de prueba exitosa dará como resultado lo siguiente:
🔄 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)."
}
}
...
¡Funciona! Probaste correctamente que puedes comunicarte con el agente de divisas a través de un protocolo A2A con un cliente A2A. 🎉
Consulta el repositorio a2a-samples en GitHub para obtener más muestras de A2A.
8. Consume el agente de divisas remoto a través de A2A
En el paso anterior, usaste un cliente A2A para comunicarte con el agente de divisas a través de A2A.
En este paso, veamos cómo puedes consumir el agente de divisas como un agente remoto de otro agente de viajes.
El código del agente de viajes está en 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)],
)
Observa cómo se accede al agente de divisas con RemoteA2aAgent.
Ejecuta adk web para probar el agente de viajes:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
En un navegador, ve a http://localhost:8000 para ver y probar el agente.
Asegúrate de que travel_agent esté seleccionado como el agente en la esquina superior izquierda de la IU web.
Pregúntale a tu agente en el área de chat algo como "¿Cuánto son 250 CAD en USD?".
Deberías ver que el agente de viajes llama a currency_agent de forma remota antes de dar una respuesta.
El agente funciona. Puede controlar las consultas que giran en torno a las conversiones de divisas 💸 llamando a un agente remoto con A2A.
9. Felicitaciones
¡Felicitaciones! Creaste e implementaste correctamente un servidor de MCP remoto, creaste un agente de divisas con el Kit de desarrollo de agentes (ADK) que se conecta a herramientas con MCP y expusiste tu agente con el protocolo Agent2Agent (A2A). Luego, creaste un agente de viajes para hablar con el agente de divisas de forma remota con A2A.
Aquí tienes un vínculo a la documentación completa del código.
¿Quieres implementar tu agente? Agent Runtime de Gemini Enterprise Agent Platform proporciona una experiencia administrada para implementar agentes de IA en producción.
Temas abordados
- Cómo crear un servidor de MCP local
- Cómo implementar el servidor de MCP en Cloud Run
- Cómo crear un agente con el Kit de desarrollo de agentes que usa herramientas de MCP
- Cómo exponer un agente del ADK como un servidor A2A
- Cómo probar el servidor A2A con un cliente A2A
- Cómo crear un agente para hablar con otro agente a través del protocolo A2A
Limpia
Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este lab:
- En la consola de Google Cloud, ve a la página Administrar recursos.
- En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
- En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.