1. Visão geral
Os agentes de IA estão crescendo rapidamente em popularidade, revolucionando a automação de tarefas e a tomada de decisões com a capacidade de operar de forma autônoma, aprender e interagir com o ambiente para alcançar metas.
Mas como criar um agente? Este codelab vai ajudar você a começar mostrando como criar um agente de moeda que pode converter entre as moedas de diferentes países. Em seguida, você vai criar um agente de agência de viagens e conectá-lo ao agente de moeda. O objetivo é mostrar as tecnologias mais recentes para ajudar você a entender as siglas que podem ter aparecido na Internet (MCP, ADK, A2A) e como elas se encaixam.
Protocolo de Contexto de Modelo (MCP)
O Protocolo de Contexto de Modelo (MCP) é um protocolo aberto que padroniza como os aplicativos fornecem contexto para LLMs. O MCP oferece uma maneira padronizada de conectar modelos de IA a recursos, comandos e ferramentas.
Kit de Desenvolvimento de Agente (ADK)
O Kit de Desenvolvimento de Agente (ADK) é um framework de orquestração flexível para desenvolver e implantar agentes de IA. O ADK é independente de modelo, de implantação e foi criado para ser compatível com outros frameworks. O ADK foi projetado para tornar o desenvolvimento de agentes mais parecido com o desenvolvimento de software, para facilitar a criação, a implantação e a orquestração de arquiteturas agênticas que variam de tarefas simples a fluxos de trabalho complexos.
Protocolo Agent2Agent (A2A)
O protocolo Agent2Agent (A2A) é um padrão aberto criado para permitir a comunicação e a colaboração perfeitas entre agentes de IA. Assim como o MCP oferece uma maneira padronizada de dar aos LLMs acesso a dados e ferramentas, o A2A oferece uma maneira padronizada para que os agentes conversem com outros agentes. Em um mundo em que os agentes são criados usando frameworks diversos e por diferentes fornecedores, o A2A oferece uma linguagem comum, quebrando silos e promovendo a interoperabilidade.
O que você vai aprender
- Como criar um servidor MCP local
- Como implantar o servidor MCP no Cloud Run
- Como criar um agente com o Kit de Desenvolvimento de Agente que usa ferramentas do MCP
- Como expor um agente do ADK como um servidor A2A
- Como testar o servidor A2A usando um cliente A2A
- Como criar um agente para conversar com outro agente pelo protocolo A2A
O que é necessário
2. Antes de começar
Criar um projeto
Se você não tiver um projeto na nuvem do Google Cloud, crie um.
No Google Cloud Console, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
Verifique também se o faturamento está ativado para o projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.
Ativar o Cloud Shell
O Google Cloud Shell é um ambiente de desenvolvimento interativo baseado em navegador fornecido diretamente no console do Google Cloud. É a maneira mais fácil de começar a usar o Google Cloud sem precisar instalar ferramentas localmente.
Ative o Cloud Shell clicando neste link. Você pode alternar entre o terminal do Cloud Shell (para executar comandos na nuvem) e o editor (para criar projetos) clicando no botão correspondente no Cloud Shell.
Depois de se conectar ao Cloud Shell, verifique se você já está autenticado e se o projeto está definido como o ID do projeto usando o comando a seguir:
gcloud auth list
Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.
gcloud config list project
Use o comando a seguir para definir seu projeto:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Ativar APIs do Cloud
Ative as APIs necessárias usando o comando a seguir. Isso pode levar alguns 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
Consulte a documentação para comandos e uso do gcloud.
Acessar o código
Clone o repositório:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv é usado para gerenciar dependências e já está instalado no Cloud Shell, mas, se você estiver executando o codelab localmente, poderá instalá-lo da seguinte maneira:
# 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"
Configure as variáveis de ambiente com um arquivo .env executando o seguinte:
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Criar um servidor MCP local
Antes de orquestrar o agente de moeda, você vai criar um servidor MCP para expor as ferramentas de que o agente vai precisar.
Um servidor MCP permite escrever programas leves para expor recursos específicos (como buscar taxas de câmbio) como ferramentas. Um agente ou até mesmo vários agentes podem acessar essas ferramentas usando o Protocolo de Contexto de Modelo (MCP) padronizado.
O pacote do Python FastMCP pode ser usado para criar um servidor MCP que expõe uma única ferramenta chamada get_exchange_rate. A ferramenta get_exchange_rate faz uma chamada pela Internet para a API Frankfurter para receber a taxa de câmbio atual entre duas moedas.
O código do servidor MCP pode ser encontrado no arquivo 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 o servidor MCP localmente, abra um terminal e execute o comando a seguir (o servidor será iniciado em http://localhost:8080):
uv run mcp-server/server.py
Teste se o servidor MCP está funcionando corretamente e se a ferramenta get_exchange_rate está acessível usando o Protocolo de Contexto de Modelo.
Em uma nova janela de terminal (para não interromper o servidor MCP local), execute o seguinte:
uv run mcp-server/test_server.py
Você verá a taxa de câmbio atual de 1 USD (dólar americano) para EUR (euro) gerada:
--- 🛠️ 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
}
} ---
Incrível! Você tem um servidor MCP funcionando com uma ferramenta que seu agente poderá acessar.
Antes de passar para a próxima estação, interrompa o servidor MCP em execução localmente executando Ctrl+C (ou Command+C no Mac) no terminal em que você o iniciou.
4. Implantar o servidor MCP no Cloud Run
Agora você está pronto para implantar o servidor MCP como um servidor MCP remoto no Cloud Run 🚀☁️
Benefícios de executar um servidor MCP remotamente
A execução de um servidor MCP remotamente no Cloud Run pode oferecer vários benefícios:
- 📈Escalabilidade: o Cloud Run foi criado para escalonar horizontalmente rapidamente para lidar com todas as solicitações de entrada. O Cloud Run vai escalonar o servidor MCP automaticamente com base na demanda.
- Servidor centralizado: você pode compartilhar o acesso a um servidor MCP centralizado com membros da equipe por meio de privilégios do IAM, permitindo que eles se conectem a ele nas máquinas locais em vez de executar os próprios servidores localmente. Se uma mudança for feita no servidor MCP, todos os membros da equipe se beneficiarão dela.
- 🔐Segurança: o Cloud Run oferece uma maneira fácil de forçar solicitações autenticadas. Isso permite apenas conexões seguras ao servidor MCP, evitando o acesso não autorizado.
Mude para o diretório mcp-server:
cd mcp-server
Implante o servidor MCP no Cloud Run:
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Se o serviço tiver sido implantado, você verá uma mensagem como esta:
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
Autenticação de clientes MCP
Como você especificou --no-allow-unauthenticated para exigir autenticação, qualquer cliente MCP que se conectar ao servidor MCP remoto precisará ser autenticado.
A documentação oficial para hospedar servidores MCP no Cloud Run fornece mais informações sobre esse tópico, dependendo de onde você está executando o cliente MCP.
Você precisará executar o proxy do Cloud Run para criar um túnel autenticado para o servidor MCP remoto na máquina local.
Por padrão, o URL dos serviços do Cloud Run exige que todas as solicitações sejam autorizadas com o papel do IAM de invocador do Cloud Run (roles/run.invoker). Essa vinculação de política do IAM garante que um mecanismo de segurança forte seja usado para autenticar o cliente MCP local.
Verifique se você ou qualquer membro da equipe que tentar acessar o servidor MCP remoto tem o papel do IAM roles/run.invoker vinculado à principal do IAM (conta do Google Cloud).
gcloud run services proxy mcp-server --region=us-central1
Você verá esta resposta:
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
Todo o tráfego para http://127.0.0.1:8080 será autenticado e encaminhado para o servidor MCP remoto.
Testar o servidor MCP remoto
Em um novo terminal, volte para a pasta raiz e execute novamente o arquivo mcp-server/test_server.py para garantir que o servidor MCP remoto esteja funcionando.
cd ..
uv run mcp-server/test_server.py
Você verá uma saída semelhante à que fez ao executar o servidor localmente:
--- 🛠️ 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
}
} ---
É possível consultar os registros do servidor MCP do Cloud Run implantado se quiser verificar se o servidor remoto foi chamado:
gcloud run services logs read mcp-server --region us-central1 --limit 5
Você verá a seguinte saída nos 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}}
Agora que você tem um servidor MCP remoto, pode criar um agente. 🤖
5. Criar um agente com o ADK
Você tem um servidor MCP implantado. Agora é hora de criar o agente de moeda usando Kit de Desenvolvimento de Agente (ADK).
O ADK torna a criação de agentes extremamente leve e permite que eles se conectem a servidores MCP com suporte integrado para ferramentas MCP. O agente de moeda vai acessar a ferramenta get_exchange_rate usando a classe MCPToolset do ADK.
O código do agente de moeda está localizado em 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 testar rapidamente o agente de moeda, aproveite a interface de desenvolvimento do ADK, acessada executando adk web:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Em um navegador, acesse http://localhost:8000 para conferir e testar o agente.
Verifique se currency_agent está selecionado como o agente no canto superior esquerdo da interface da Web.
Pergunte ao agente na área de conversa algo como "Qual é o valor de 250 CAD em USD?". Você verá o agente chamar nossa ferramenta MCP get_exchange_rate antes de dar uma resposta.
O agente funciona. Ele pode processar consultas que giram em torno de conversões de moeda 💸.
6. Protocolo Agent2Agent (A2A)
O protocolo Agent2Agent (A2A) é um padrão aberto criado para permitir a comunicação e a colaboração perfeitas entre agentes de IA. Isso permite que agentes criados usando frameworks diversos e por diferentes fornecedores se comuniquem em uma linguagem comum, quebrando silos e promovendo a interoperabilidade.
O A2A permite que os agentes:
- Descubram: encontrem outros agentes e aprendam as habilidades (AgentSkill) e os recursos (AgentCapabilities) deles usando cards de agentes padronizados.
- Se comuniquem:troquem mensagens e dados com segurança.
- Colaborem:deleguem tarefas e coordenem ações para alcançar metas complexas.
O protocolo A2A facilita essa comunicação por mecanismos como "cards de agentes", que atuam como cartões de visita digitais que os agentes podem usar para anunciar os recursos e as informações de conexão.
Agora é hora de expor o agente de moeda usando o A2A para que ele possa ser chamado por outros agentes e clientes.
SDK do Python A2A
O SDK do Python A2A fornece modelos Pydantic para cada um dos recursos mencionados acima: AgentSkill, AgentCapabilities e AgentCard. Isso fornece uma interface para acelerar o desenvolvimento e a integração com o protocolo A2A.
Um AgentSkill é como você vai anunciar para outros agentes que o agente de moeda tem uma ferramenta 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?'],
)
Em seguida, como parte do AgentCard, ele vai listar as habilidades e os recursos do agente, além de outros detalhes, como os modos de entrada e saída que o agente pode processar:
# 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],
)
Chegou a hora de juntar tudo com o agente de moeda e mostrar o poder do A2A.
7. Expor o agente de moeda como servidor A2A
O ADK simplifica o processo de criação e conexão de agentes usando o protocolo A2A. Para tornar um agente do ADK acessível (expondo-o) como um servidor A2A, use a função to_a2a(root_agent) do ADK (consulte a documentação do ADK para conferir todos os detalhes).
A função to_a2a converte um agente atual para trabalhar com o A2A e pode expô-lo como um servidor pelo uvicorn. Isso significa que você tem mais controle sobre o que quer expor se planeja produzir seu agente. A função to_a2a() gera automaticamente um card de agente com base no código do agente usando o SDK do Python A2A.
Ao analisar o arquivo currency_agent/agent.py, você pode conferir o uso de to_a2a e como o agente de moeda é exposto como um servidor A2A com apenas duas linhas 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 executar o servidor A2A, em um novo terminal , execute o seguinte:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Se o servidor for iniciado, a saída será semelhante à seguinte, indicando que ele está em execução na porta 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)
O agente de moeda agora está em execução como um servidor A2A, com a capacidade de ser chamado por outros agentes ou clientes usando o protocolo A2A.
Verificar se o agente remoto está em execução
Você pode verificar se o agente está em execução acessando o URL do card do agente de moeda que foi gerado automaticamente pela função to_a2a().
No navegador, acesse http://localhost:10000/.well-known/agent-card.json
Você verá o seguinte card do 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"
}
Testar o servidor A2A
Agora você pode testar o servidor enviando algumas solicitações usando o A2A.
O SDK do Python A2A fornece uma classe a2a.client.Client que simplifica isso para você.
O arquivo currency_agent/test_a2aclient.py contém um código que mostra como buscar o card do agente e enviar uma mensagem para o 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()
Execute os testes usando o comando a seguir:
uv run currency_agent/test_a2aclient.py
Uma execução de teste bem-sucedida resultará no seguinte:
🔄 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)."
}
}
...
Funcionou! Você testou com sucesso que pode se comunicar com o agente de moeda em um protocolo A2A com um cliente A2A. 🎉
Confira o repositório a2a-samples no GitHub para conferir mais exemplos de A2A.
8. Consumir o agente de moeda remoto via A2A
Na etapa anterior, você usou um cliente A2A para se comunicar com o agente de moeda pelo A2A.
Nesta etapa, vamos conferir como consumir o agente de moeda como um agente remoto de outro agente de viagens.
O código do agente de viagens está em 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)],
)
Observe como o agente de moeda é acessado usando RemoteA2aAgent.
Execute adk web para testar o agente de viagens:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Em um navegador, acesse http://localhost:8000 para conferir e testar o agente.
Verifique se travel_agent está selecionado como o agente no canto superior esquerdo da interface da Web.
Pergunte ao agente na área de conversa algo como "Qual é o valor de 250 CAD em USD?".
Você verá o agente de viagens chamar currency_agent remotamente antes de dar uma resposta.
O agente funciona. Ele pode processar consultas que giram em torno de conversões de moeda 💸 chamando um agente remoto usando o A2A.
9. Parabéns
Parabéns! Você criou e implantou um servidor MCP remoto, criou um agente de moeda usando o Kit de Desenvolvimento de Agente (ADK) que se conecta a ferramentas usando o MCP e expôs seu agente usando o protocolo Agent2Agent (A2A). Em seguida, você criou um agente de viagens para conversar com o agente de moeda remotamente usando o A2A.
Aqui está um link para a documentação completa do código.
Quer implantar seu agente? O ambiente de execução do agente da Gemini Enterprise Agent Platform oferece uma experiência gerenciada para implantar agentes de IA na produção.
O que aprendemos
- Como criar um servidor MCP local
- Como implantar o servidor MCP no Cloud Run
- Como criar um agente com o Kit de Desenvolvimento de Agente que usa ferramentas do MCP
- Como expor um agente do ADK como um servidor A2A
- Como testar o servidor A2A usando um cliente A2A
- Como criar um agente para conversar com outro agente pelo protocolo A2A
Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste laboratório, siga estas etapas:
- No console do Google Cloud, acesse a página Gerenciar recursos.
- Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
- Na caixa de diálogo, digite o ID do projeto e clique em Desligar para excluir o projeto.