1. Panoramica
Gli agenti AI stanno diventando sempre più popolari, rivoluzionando l'automazione delle attività e il processo decisionale grazie alla loro capacità di operare in modo autonomo, imparare e interagire con il loro ambiente per raggiungere gli obiettivi.
Ma come si fa esattamente a creare un agente? Questo codelab ti aiuterà a iniziare mostrandoti come creare un agente di valuta in grado di convertire le valute di diversi paesi. Dopodiché, creerai un agente di agenzia viaggi e lo collegherai all'agente di valuta. L'obiettivo è guidarti attraverso le ultime tecnologie per aiutarti a comprendere gli acronimi che potresti aver visto circolare su internet (MCP, ADK, A2A) e vedere come si integrano tra loro.
Model Context Protocol (MCP)
Model Context Protocol (MCP) è un protocollo aperto che standardizza il modo in cui le applicazioni forniscono il contesto agli LLM. MCP fornisce un modo standardizzato per connettere i modelli AI a risorse, prompt e strumenti.
Agent Development Kit (ADK)
Agent Development Kit (ADK) è un framework di orchestrazione flessibile per lo sviluppo e il deployment di agenti AI. ADK è indipendente dal modello, dal deployment ed è progettato per la compatibilità con altri framework. ADK è stato progettato per rendere lo sviluppo di agenti più simile allo sviluppo di software, in modo che gli sviluppatori possano creare, eseguire il deployment e orchestrare più facilmente architetture agentiche che vanno da semplici attività a workflow complessi.
Protocollo Agent2Agent (A2A)
Il protocollo Agent2Agent (A2A) è uno standard aperto progettato per consentire una comunicazione e una collaborazione fluide tra gli agenti AI. Proprio come MCP fornisce un modo standardizzato per consentire agli LLM di accedere a dati e strumenti, A2A fornisce un modo standardizzato per gli agenti di comunicare con altri agenti. In un mondo in cui gli agenti vengono creati utilizzando diversi framework e da diversi fornitori, A2A fornisce un linguaggio comune, abbattendo i silos e promuovendo l'interoperabilità.
Obiettivi didattici
- Come creare un server MCP locale
- Eseguire il deployment del server MCP su Cloud Run
- Come creare un agente con Agent Development Kit che utilizza gli strumenti MCP
- Come esporre un agente ADK come server A2A
- Testare il server A2A utilizzando un client A2A
- Come creare un agente per comunicare con un altro agente tramite il protocollo A2A
Che cosa ti serve
2. Prima di iniziare
Crea un progetto
Se non hai un progetto Google Cloud, creane uno.
Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
Assicurati inoltre che la fatturazione sia abilitata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.
Attiva Cloud Shell
Google Cloud Shell è un ambiente di sviluppo interattivo basato su browser fornito direttamente nella console Google Cloud. È il modo più semplice per iniziare a utilizzare Google Cloud senza dover installare strumenti in locale.
Attiva Cloud Shell facendo clic su questo link. Puoi passare dal terminale Cloud Shell (per eseguire i comandi cloud) all'editor (per creare progetti) facendo clic sul pulsante corrispondente in Cloud Shell.
Una volta eseguita la connessione a Cloud Shell, puoi verificare che il tuo account sia già autenticato e che il progetto sia impostato sul tuo ID progetto utilizzando il seguente comando:
gcloud auth list
Esegui il seguente comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto.
gcloud config list project
Utilizza il seguente comando per impostare il progetto:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Abilita le API Cloud
Abilita le API richieste utilizzando il seguente comando. L'operazione potrebbe richiedere alcuni minuti.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Per informazioni sui comandi e sull'utilizzo di gcloud, consulta la documentazione.
Ottieni il codice
Clona il repository:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv viene utilizzato per gestire le dipendenze ed è già installato in Cloud Shell, ma se esegui il codelab in locale, puoi installarlo come segue:
# 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 le variabili di ambiente con un file .env eseguendo quanto segue:
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Crea un server MCP locale
Prima di orchestrare l'agente di valuta, devi creare un server MCP per esporre gli strumenti di cui l'agente avrà bisogno.
Un server MCP ti consente di scrivere programmi leggeri per esporre funzionalità specifiche (come il recupero dei tassi di cambio) come strumenti. Un agente o anche più agenti possono quindi accedere a questi strumenti utilizzando il Model Context Protocol (MCP) standardizzato.
Il pacchetto Python FastMCP può essere utilizzato per creare un server MCP che espone un singolo strumento denominato get_exchange_rate. Lo strumento get_exchange_rate effettua una chiamata su internet all'API Frankfurter per ottenere il tasso di cambio corrente tra due valute.
Il codice per il server MCP è disponibile nel file 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),
)
)
Per avviare il server MCP in locale, apri un terminale ed esegui il seguente comando (il server verrà avviato su http://localhost:8080):
uv run mcp-server/server.py
Verifica che il server MCP funzioni correttamente e che lo strumento get_exchange_rate sia accessibile utilizzando il Model Context Protocol.
In una nuova finestra del terminale (in modo da non arrestare il server MCP locale), esegui quanto segue:
uv run mcp-server/test_server.py
Dovresti vedere l'output del tasso di cambio corrente di 1 USD (dollaro statunitense) in 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
}
} ---
Fantastico! Hai creato correttamente un server MCP funzionante con uno strumento a cui il tuo agente potrà accedere.
Prima di passare alla stazione successiva, arresta il server MCP in esecuzione in locale eseguendo Ctrl+C (o Command+C su Mac) nel terminale in cui l'hai avviato.
4. Esegui il deployment del server MCP su Cloud Run
Ora puoi eseguire il deployment del server MCP come server MCP remoto su Cloud Run 🚀☁️
Vantaggi dell'esecuzione di un server MCP in remoto
L'esecuzione di un server MCP in remoto su Cloud Run può offrire diversi vantaggi:
- 📈Scalabilità: Cloud Run è progettato per fare lo scale out rapidamente per gestire tutte le richieste in entrata. Cloud Run scala automaticamente il server MCP in base alla domanda.
- 👥Server centralizzato: puoi condividere l'accesso a un server MCP centralizzato con i membri del team tramite i privilegi IAM, consentendo loro di connettersi dai computer locali anziché eseguire tutti i propri server in locale. Se viene apportata una modifica al server MCP, tutti i membri del team ne trarranno vantaggio.
- 🔐Sicurezza: Cloud Run offre un modo semplice per forzare le richieste autenticate. In questo modo, solo le connessioni sicure possono accedere al server MCP, impedendo l'accesso non autorizzato.
Passa alla directory mcp-server:
cd mcp-server
Esegui il deployment del server MCP su Cloud Run:
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Se il deployment del servizio è stato eseguito correttamente, verrà visualizzato un messaggio simile al seguente:
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
Autenticare i client MCP
Poiché hai specificato --no-allow-unauthenticated per richiedere l'autenticazione, qualsiasi client MCP che si connette al server MCP remoto dovrà autenticarsi.
La documentazione ufficiale per ospitare i server MCP su Cloud Run fornisce ulteriori informazioni su questo argomento a seconda di dove esegui il client MCP.
Dovrai eseguire il proxy Cloud Run per creare un tunnel autenticato al server MCP remoto sul computer locale.
Per impostazione predefinita, l'URL dei servizi Cloud Run richiede che tutte le richieste siano autorizzate con il ruolo IAM Cloud Run Invoker (roles/run.invoker). Questo binding dei criteri IAM garantisce l'utilizzo di un meccanismo di sicurezza efficace per autenticare il client MCP locale.
Assicurati che tu o qualsiasi membro del team che tenti di accedere al server MCP remoto abbia il ruolo IAM roles/run.invoker associato alla sua entità IAM (account Google Cloud).
gcloud run services proxy mcp-server --region=us-central1
Dovresti vedere l'output seguente:
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
Tutto il traffico verso http://127.0.0.1:8080 verrà ora autenticato e inoltrato al server MCP remoto.
Testa il server MCP remoto
In un nuovo terminale, torna alla cartella principale ed esegui di nuovo il file mcp-server/test_server.py per assicurarti che il server MCP remoto funzioni.
cd ..
uv run mcp-server/test_server.py
Dovresti vedere un output simile a quello visualizzato quando hai eseguito il server in locale:
--- 🛠️ 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
}
} ---
Puoi eseguire query sui log del server MCP Cloud Run di cui hai eseguito il deployment se vuoi verificare che il server remoto sia stato effettivamente chiamato:
gcloud run services logs read mcp-server --region us-central1 --limit 5
Dovresti vedere il seguente output nei log:
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}}
Ora che hai un server MCP remoto, puoi passare alla creazione di un agente. 🤖
5. Crea un agente con ADK
Hai eseguito il deployment di un server MCP, ora è il momento di creare l'agente di valuta utilizzando Agent Development Kit (ADK).
ADK rende la creazione di agenti estremamente leggera e consente loro di connettersi ai server MCP con il supporto integrato per gli strumenti MCP. L'agente di valuta accederà allo strumento get_exchange_rate utilizzando la classe MCPToolset di ADK.
Il codice per l'agente di valuta si trova in 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")
)
)
],
)
Per testare rapidamente l'agente di valuta, puoi sfruttare l'interfaccia utente di sviluppo di ADK, a cui puoi accedere eseguendo adk web:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
In un browser, vai a http://localhost:8000 per visualizzare e testare l'agente.
Assicurati che currency_agent sia selezionato come agente nell'angolo in alto a sinistra dell'interfaccia utente web.
Chiedi all'agente nell'area chat qualcosa del tipo "What is 250 CAD to USD?". Dovresti vedere l'agente chiamare il nostro strumento MCP get_exchange_rate prima di fornire una risposta.
L'agente funziona. Può gestire le query relative alle conversioni di valuta 💸.
6. Protocollo Agent2Agent (A2A)
Il protocollo Agent2Agent (A2A) è uno standard aperto progettato per consentire una comunicazione e una collaborazione fluide tra gli agenti AI. Ciò consente agli agenti creati utilizzando diversi framework e da diversi fornitori di comunicare tra loro in un linguaggio comune, abbattendo i silos e promuovendo l'interoperabilità.
A2A consente agli agenti di:
- Scoprire: trova altri agenti e scopri le loro competenze (AgentSkill) e funzionalità (AgentCapabilities) utilizzando le schede agente standardizzate.
- Comunicare: scambia messaggi e dati in modo sicuro.
- Collaborare: delega le attività e coordina le azioni per raggiungere obiettivi complessi.
Il protocollo A2A facilita questa comunicazione tramite meccanismi come le "schede agente" che fungono da biglietti da visita digitali che gli agenti possono utilizzare per pubblicizzare le proprie funzionalità e informazioni di connessione.
Ora è il momento di esporre l'agente di valuta utilizzando A2A in modo che possa essere chiamato da altri agenti e client.
SDK Python A2A
L'SDK Python A2A fornisce modelli Pydantic per ciascuna delle risorse menzionate in precedenza: AgentSkill, AgentCapabilities e AgentCard. Fornisce un'interfaccia per accelerare lo sviluppo e l'integrazione con il protocollo A2A.
Un AgentSkill è il modo in cui pubblicizzerai ad altri agenti che l'agente di valuta ha uno strumento per 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?'],
)
Quindi, come parte di AgentCard, verranno elencate le competenze e le funzionalità dell'agente insieme a dettagli aggiuntivi come le modalità di input e output che l'agente può gestire:
# 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],
)
È arrivato il momento di mettere tutto insieme con l'agente di valuta e mostrare la potenza di A2A.
7. Esporre l'agente di valuta come server A2A
ADK semplifica la creazione e la connessione degli agenti utilizzando il protocollo A2A. Per rendere accessibile (esporre) un agente ADK esistente come server A2A, utilizza la funzione to_a2a(root_agent) di ADK (per tutti i dettagli, consulta la documentazione di ADK).
La funzione to_a2a converte un agente esistente in modo che funzioni con A2A e possa esporlo come server tramite uvicorn. Ciò significa che hai un maggiore controllo su ciò che vuoi esporre se prevedi di mettere in produzione il tuo agente. La funzione to_a2a() genera automaticamente una scheda agente basata sul codice dell'agente utilizzando l'SDK Python A2A.
Se esamini il file currency_agent/agent.py, puoi vedere l'utilizzo di to_a2a e come l'agente di valuta viene esposto come server A2A con solo due righe di codice.
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)
Per eseguire il server A2A, in un nuovo terminale esegui quanto segue:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Se il server viene avviato correttamente, l'output sarà simile al seguente, che indica che è in esecuzione sulla 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)
L'agente di valuta è ora in esecuzione correttamente come server A2A, con la possibilità di essere chiamato da altri agenti o client utilizzando il protocollo A2A.
Verifica che l'agente remoto sia in esecuzione
Puoi verificare che l'agente sia attivo e in esecuzione visitando l'URL della scheda agente per l'agente di valuta generato automaticamente dalla funzione to_a2a().
Nel browser, vai a http://localhost:10000/.well-known/agent-card.json
Dovresti vedere la seguente scheda 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"
}
Testa il server A2A
Ora puoi testare il server inviando alcune richieste utilizzando A2A.
L'SDK Python A2A fornisce una classe a2a.client.Client che semplifica questa operazione.
Il file currency_agent/test_a2aclient.py contiene il codice che mostra come recuperare la scheda agente e inviare un messaggio al server 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()
Esegui i test utilizzando il seguente comando:
uv run currency_agent/test_a2aclient.py
Un'esecuzione di test riuscita produrrà quanto segue:
🔄 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)."
}
}
...
Funziona. Hai verificato correttamente di poter comunicare con l'agente di valuta tramite un protocollo A2A con un client A2A. 🎉
Per altri esempi di A2A, consulta il repository a2a-samples su GitHub.
8. Utilizza l'agente di valuta remoto tramite A2A
Nel passaggio precedente, hai utilizzato un client A2A per comunicare con l'agente di valuta tramite A2A.
In questo passaggio, vediamo come puoi utilizzare l'agente di valuta come agente remoto da un altro agente di viaggi.
Il codice dell'agente di viaggi è in 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)],
)
Nota come si accede all'agente di valuta utilizzando RemoteA2aAgent.
Esegui adk web per testare l'agente di viaggi:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
In un browser, vai a http://localhost:8000 per visualizzare e testare l'agente.
Assicurati che travel_agent sia selezionato come agente nell'angolo in alto a sinistra dell'interfaccia utente web.
Chiedi all'agente nell'area chat qualcosa del tipo "What is 250 CAD to USD?".
Dovresti vedere l'agente di viaggi chiamare currency_agent in remoto prima di fornire una risposta.
L'agente funziona. Può gestire le query relative alle conversioni di valuta 💸 chiamando un agente remoto utilizzando A2A.
9. Complimenti
Complimenti! Hai creato ed eseguito correttamente il deployment di un server MCP remoto, creato un agente di valuta utilizzando Agent Development Kit (ADK) che si connette agli strumenti utilizzando MCP ed esposto l'agente utilizzando il protocollo Agent2Agent (A2A). Dopodiché, hai creato un agente di viaggi per comunicare con l'agente di valuta in remoto utilizzando A2A.
Ecco un link alla documentazione completa del codice.
Vuoi eseguire il deployment dell'agente? Agent Runtime di Gemini Enterprise Agent Platform offre un'esperienza gestita per il deployment di agenti AI in produzione.
Argomenti trattati
- Come creare un server MCP locale
- Eseguire il deployment del server MCP su Cloud Run
- Come creare un agente con Agent Development Kit che utilizza gli strumenti MCP
- Come esporre un agente ADK come server A2A
- Testare il server A2A utilizzando un client A2A
- Come creare un agente per comunicare con un altro agente tramite il protocollo A2A
Libera spazio
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo lab, segui questi passaggi:
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.