1. Übersicht
KI-Agenten werden immer beliebter und revolutionieren die Aufgabenautomatisierung und Entscheidungsfindung. Sie können autonom agieren, lernen und mit ihrer Umgebung interagieren, um Ziele zu erreichen.
Aber wie erstellt man einen Agenten? In diesem Codelab erfahren Sie, wie Sie einen Währungsagenten erstellen, der zwischen den Währungen verschiedener Länder umrechnen kann. Anschließend erstellen Sie einen Reisebüroagenten und verbinden ihn mit dem Währungsagenten. Ziel ist es, Ihnen die neuesten Technologien vorzustellen, damit Sie die Abkürzungen verstehen, die Sie möglicherweise im Internet gesehen haben (MCP, ADK, A2A), und erfahren, wie sie zusammenpassen.
Model Context Protocol (MCP)
Das Model Context Protocol (MCP) ist ein offenes Protokoll, das die Bereitstellung von Kontext durch Anwendungen an LLMs standardisiert. MCP bietet eine standardisierte Möglichkeit, KI-Modelle mit Ressourcen, Prompts und Tools zu verbinden.
Agent Development Kit (ADK)
Das Agent Development Kit (ADK) ist ein flexibles Orchestrierungs-Framework zum Entwickeln und Bereitstellen von KI-Agenten. Das ADK ist modellunabhängig, bereitstellungsunabhängig und für die Kompatibilität mit anderen Frameworks konzipiert. Das ADK wurde entwickelt, um die Entwicklung von Agenten eher wie die Softwareentwicklung zu gestalten und Entwicklern das Erstellen, Bereitstellen und Orchestrieren von agentischen Architekturen zu erleichtern, die von einfachen Aufgaben bis hin zu komplexen Workflows reichen.
Agent2Agent-Protokoll (A2A)
Das Agent2Agent-Protokoll (A2A) ist ein offener Standard, der eine nahtlose Kommunikation und Zusammenarbeit zwischen KI-Agenten ermöglichen soll. So wie MCP eine standardisierte Möglichkeit bietet, LLMs Zugriff auf Daten und Tools zu gewähren, bietet A2A eine standardisierte Möglichkeit für Agenten, mit anderen Agenten zu kommunizieren. In einer Welt, in der Agenten mit verschiedenen Frameworks und von verschiedenen Anbietern erstellt werden, bietet A2A eine gemeinsame Sprache, die Silos aufbricht und die Interoperabilität fördert.
Lerninhalte
- Lokalen MCP-Server erstellen
- MCP-Server in Cloud Run bereitstellen
- Agenten mit dem Agent Development Kit erstellen, der MCP-Tools verwendet
- ADK-Agenten als A2A-Server bereitstellen
- A2A-Server mit einem A2A-Client testen
- Agenten erstellen, der über das A2A-Protokoll mit einem anderen Agenten kommuniziert
Voraussetzungen
2. Hinweis
Projekt erstellen
Wenn Sie kein Google Cloud-Projekt haben, erstellen Sie eines.
Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
Achten Sie außerdem darauf, dass die Abrechnung für das Cloud-Projekt aktiviert ist. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
Cloud Shell aktivieren
Google Cloud Shell ist eine interaktive, browserbasierte Entwicklungsumgebung, die direkt in der Google Cloud Console bereitgestellt wird. Sie ist die einfachste Möglichkeit, mit Google Cloud zu beginnen, ohne Tools lokal installieren zu müssen.
Aktivieren Sie die Cloud Shell, indem Sie auf diesen Link klicken. Sie können zwischen dem Cloud Shell-Terminal (zum Ausführen von Cloud-Befehlen) und dem Editor (zum Erstellen von Projekten) wechseln, indem Sie in der Cloud Shell auf den entsprechenden Button klicken.
Sobald die Verbindung mit der Cloud Shell hergestellt ist, prüfen Sie mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und für das Projekt schon Ihre Projekt-ID eingestellt ist:
gcloud auth list
Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt:
gcloud config list project
Legen Sie das Projekt mit dem folgenden Befehl fest:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Cloud APIs aktivieren
Aktivieren Sie die erforderlichen APIs mit dem folgenden Befehl. Dies kann einige Minuten dauern.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Informationen zu gcloud-Befehlen und ihrer Verwendung finden Sie in der Dokumentation.
Code abrufen
Klonen Sie das Repository:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv wird zum Verwalten von Abhängigkeiten verwendet und ist bereits in Cloud Shell installiert. Wenn Sie das Codelab jedoch lokal ausführen, können Sie es so installieren:
# 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"
Konfigurieren Sie Umgebungsvariablen mit einer .env-Datei, indem Sie Folgendes ausführen:
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Lokalen MCP-Server erstellen
Bevor Sie Ihren Währungsagenten orchestrieren, erstellen Sie zuerst einen MCP-Server, um die Tools bereitzustellen, die Ihr Agent benötigt.
Mit einem MCP-Server können Sie einfache Programme schreiben, um bestimmte Funktionen (z. B. das Abrufen von Wechselkursen) als Tools bereitzustellen. Ein oder mehrere Agenten können dann mit dem standardisierten Model Context Protocol (MCP) auf diese Tools zugreifen.
Mit dem FastMCP-Python-Paket kann ein MCP-Server erstellt werden, der ein einzelnes Tool namens get_exchange_rate bereitstellt. Das get_exchange_rate Tool ruft über das Internet die Frankfurter API auf, um den aktuellen Wechselkurs zwischen zwei Währungen abzurufen.
Der Code für den MCP-Server befindet sich in der Datei 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),
)
)
Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus, um den MCP-Server lokal zu starten (der Server wird unter http://localhost:8080 gestartet):
uv run mcp-server/server.py
Testen Sie, ob der MCP-Server ordnungsgemäß funktioniert und ob das Tool get_exchange_rate über das Model Context Protocol zugänglich ist.
Führen Sie in einem neuen Terminalfenster (damit Sie den lokalen MCP-Server nicht beenden) Folgendes aus:
uv run mcp-server/test_server.py
Sie sollten den aktuellen Wechselkurs von 1 USD (US-Dollar) zu EUR (Euro) sehen:
--- 🛠️ 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
}
} ---
Sehr gut! Sie haben jetzt einen funktionierenden MCP-Server mit einem Tool, auf das Ihr Agent zugreifen kann.
Bevor Sie mit dem nächsten Schritt fortfahren, beenden Sie den lokal ausgeführten MCP-Server, indem Sie im Terminal, in dem Sie ihn gestartet haben, Ctrl+C (oder Command+C auf dem Mac) ausführen.
4. MCP-Server in Cloud Run bereitstellen
Jetzt können Sie den MCP-Server als Remote-MCP-Server in Cloud Run bereitstellen. 🚀☁️
Vorteile der Remote-Ausführung eines MCP-Servers
Die Remote-Ausführung eines MCP-Servers in Cloud Run bietet mehrere Vorteile:
- 📈 Skalierbarkeit: Cloud Run wurde entwickelt, um alle Anfragen schnell horizontal skalieren zu können. Cloud Run skaliert Ihren MCP-Server automatisch je nach Bedarf.
- 👥 Zentraler Server: Sie können den Zugriff auf einen zentralen MCP-Server über IAM-Berechtigungen für Teammitglieder freigeben, sodass sie von ihren lokalen Computern aus eine Verbindung herstellen können, anstatt alle ihre eigenen Server lokal auszuführen. Wenn eine Änderung am MCP-Server vorgenommen wird, profitieren alle Teammitglieder davon.
- 🔐 Sicherheit: Cloud Run bietet eine einfache Möglichkeit, authentifizierte Anfragen zu erzwingen. So sind nur sichere Verbindungen zu Ihrem MCP-Server möglich und unbefugter Zugriff wird verhindert.
Wechseln Sie in das Verzeichnis mcp-server:
cd mcp-server
Stellen Sie den MCP-Server in Cloud Run bereit:
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Wenn Ihr Dienst erfolgreich bereitgestellt wurde, wird eine Meldung wie die folgende angezeigt:
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
MCP-Clients authentifizieren
Da Sie --no-allow-unauthenticated angegeben haben, um eine Authentifizierung zu erzwingen, muss sich jeder MCP-Client, der eine Verbindung zum Remote-MCP-Server herstellt, authentifizieren.
In der offiziellen Dokumentation zu MCP-Server in Cloud Run hosten finden Sie weitere Informationen zu diesem Thema, je nachdem, wo Sie Ihren MCP-Client ausführen.
Sie müssen den Cloud Run-Proxy ausführen, um einen authentifizierten Tunnel zum Remote-MCP-Server auf Ihrem lokalen Computer zu erstellen.
Standardmäßig erfordert die URL von Cloud Run-Diensten, dass alle Anfragen mit der Cloud Run Invoker (roles/run.invoker) IAM-Rolle autorisiert werden. Diese IAM-Richtlinienbindung sorgt dafür, dass ein starker Sicherheitsmechanismus verwendet wird, um Ihren lokalen MCP-Client zu authentifizieren.
Achten Sie darauf, dass Sie oder alle Teammitglieder, die auf den Remote-MCP-Server zugreifen möchten, die IAM-Rolle roles/run.invoker an ihr IAM-Hauptkonto (Google Cloud-Konto) gebunden haben.
gcloud run services proxy mcp-server --region=us-central1
Es sollte folgende Ausgabe angezeigt werden:
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
Der gesamte Traffic zu http://127.0.0.1:8080 wird jetzt authentifiziert und an den Remote-MCP-Server weitergeleitet.
Remote-MCP-Server testen
Wechseln Sie in einem neuen Terminal zurück zum Stammordner und führen Sie die Datei mcp-server/test_server.py noch einmal aus, um zu prüfen, ob der Remote-MCP-Server funktioniert.
cd ..
uv run mcp-server/test_server.py
Die Ausgabe sollte ähnlich aussehen wie bei der lokalen Ausführung des Servers:
--- 🛠️ 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
}
} ---
Sie können die Logs des bereitgestellten Cloud Run-MCP-Servers abfragen, um zu prüfen, ob der Remote-Server tatsächlich aufgerufen wurde:
gcloud run services logs read mcp-server --region us-central1 --limit 5
In den Logs sollte Folgendes ausgegeben werden:
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}}
Jetzt haben Sie einen Remote-MCP-Server und können einen Agenten erstellen. 🤖
5. Agenten mit ADK erstellen
Sie haben einen bereitgestellten MCP-Server. Jetzt ist es an der Zeit, den Währungsagenten mit dem Agent Development Kit (ADK) zu erstellen.
Mit dem ADK lassen sich Agenten sehr einfach erstellen und mit integrierter Unterstützung für MCP-Tools mit MCP-Servern verbinden. Der Währungsagent greift mit der MCPToolset-Klasse des ADK auf das get_exchange_rate Tool zu.
Der Code für den Währungsagenten befindet sich 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")
)
)
],
)
Um den Währungsagenten schnell zu testen, können Sie die ADK-Entwicklungsoberfläche nutzen, auf die Sie mit adk web zugreifen können:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Rufen Sie in einem Browser http://localhost:8000 auf, um den Agenten zu sehen und zu testen.
Achten Sie darauf, dass currency_agent links oben in der Weboberfläche als Agent ausgewählt ist.
Fragen Sie Ihren Agenten im Chatbereich beispielsweise „Wie viel sind 250 CAD in USD?“. Sie sollten sehen, dass der Agent unser MCP-Tool get_exchange_rate aufruft, bevor er eine Antwort gibt.
Der Agent funktioniert. Er kann Anfragen zur Währungsumrechnung verarbeiten. 💸
6. Agent2Agent-Protokoll (A2A)
Das Agent2Agent-Protokoll (A2A) ist ein offener Standard, der eine nahtlose Kommunikation und Zusammenarbeit zwischen KI-Agenten ermöglichen soll. So können Agenten, die mit verschiedenen Frameworks und von verschiedenen Anbietern erstellt wurden, in einer gemeinsamen Sprache miteinander kommunizieren, Silos aufbrechen und die Interoperabilität fördern.
Mit A2A können Agenten:
- Erkennen: Mit standardisierten Agentenkarten andere Agenten finden und ihre Fähigkeiten (AgentSkill) und Funktionen (AgentCapabilities) kennenlernen.
- Kommunizieren:Nachrichten und Daten sicher austauschen.
- Zusammenarbeiten:Aufgaben delegieren und Aktionen koordinieren, um komplexe Ziele zu erreichen.
Das A2A-Protokoll erleichtert diese Kommunikation durch Mechanismen wie „Agentenkarten“, die als digitale Visitenkarten dienen, mit denen Agenten ihre Fähigkeiten und Verbindungsinformationen bewerben können.
Jetzt ist es an der Zeit, den Währungsagenten mit A2A bereitzustellen, damit er von anderen Agenten und Clients aufgerufen werden kann.
A2A Python SDK
Das A2A Python SDK bietet Pydantic-Modelle für jede der oben genannten Ressourcen: AgentSkill, AgentCapabilities und AgentCard. So können Sie die Entwicklung und Integration mit dem A2A-Protokoll beschleunigen.
Mit AgentSkill können Sie anderen Agenten mitteilen, dass der Währungsagent ein Tool für get_exchange_rate hat:
# 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?'],
)
Als Teil der AgentCard werden dann die Fähigkeiten und Funktionen des Agenten zusammen mit zusätzlichen Details wie den Eingabe- und Ausgabemodi aufgeführt, die der Agent verarbeiten kann:
# 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],
)
Jetzt ist es an der Zeit, alles mit dem Währungsagenten zusammenzuführen und die Leistungsfähigkeit von A2A zu demonstrieren.
7. Währungsagenten als A2A-Server bereitstellen
Das ADK vereinfacht das Erstellen und Verbinden von Agenten mit dem A2A-Protokoll. Ein vorhandener ADK-Agent wird mit der Funktion to_a2a(root_agent) des ADK als A2A-Server bereitgestellt (vollständige Details finden Sie in der ADK-Dokumentation).
Die Funktion to_a2a konvertiert einen vorhandenen Agenten für die Verwendung mit A2A und kann ihn mit uvicorn als Server bereitstellen. So haben Sie mehr Kontrolle darüber, was Sie bereitstellen möchten, wenn Sie Ihren Agenten in der Produktion einsetzen möchten. Die Funktion to_a2a() generiert automatisch eine Agentenkarte basierend auf Ihrem Agentencode und verwendet dazu im Hintergrund das A2A Python SDK.
Wenn Sie sich die Datei currency_agent/agent.py ansehen, sehen Sie die Verwendung von to_a2a und wie der Währungsagent mit nur zwei Codezeilen als A2A-Server bereitgestellt wird.
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)
Führen Sie in einem neuen Terminal Folgendes aus, um den A2A-Server auszuführen:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Wenn der Server erfolgreich gestartet wurde, sieht die Ausgabe so aus und gibt an, dass er auf Port 10000 ausgeführt wird:
[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)
Der Währungsagent wird jetzt erfolgreich als A2A-Server ausgeführt und kann von anderen Agenten oder Clients mit dem A2A-Protokoll aufgerufen werden.
Prüfen, ob der Remote-Agent ausgeführt wird
Sie können noch einmal prüfen, ob Ihr Agent ausgeführt wird, indem Sie die URL der Agentenkarte für den Währungsagenten aufrufen, die automatisch von der Funktion to_a2a() generiert wurde.
Rufen Sie in Ihrem Browser http://localhost:10000/.well-known/agent-card.json auf.
Sie sollten die folgende Agentenkarte sehen:
{
"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"
}
A2A-Server testen
Sie können den Server jetzt testen, indem Sie ihm mit A2A einige Anfragen senden.
Das A2A Python SDK bietet eine a2a.client.Client-Klasse, die dies für Sie vereinfacht.
Die Datei currency_agent/test_a2aclient.py enthält Code, der zeigt, wie Sie die Agentenkarte abrufen und eine Nachricht an den A2A-Server senden.
# ... 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()
Führen Sie die Tests mit dem folgenden Befehl aus:
uv run currency_agent/test_a2aclient.py
Ein erfolgreicher Testlauf führt zu Folgendem:
🔄 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)."
}
}
...
Sie funktioniert. Sie haben erfolgreich getestet, dass Sie mit einem A2A-Client über ein A2A-Protokoll mit dem Währungsagenten kommunizieren können. 🎉
Weitere A2A-Beispiele finden Sie im Repository a2a-samples auf GitHub.
8. Remote-Währungsagenten über A2A verwenden
Im vorherigen Schritt haben Sie einen A2A-Client verwendet, um über A2A mit dem Währungsagenten zu kommunizieren.
In diesem Schritt sehen wir uns an, wie Sie den Währungsagenten als Remote-Agenten von einem anderen Reisebüroagenten aus verwenden können.
Der Code des Reisebüroagenten befindet sich 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)],
)
Beachten Sie, wie auf den Währungsagenten mit RemoteA2aAgent zugegriffen wird.
Führen Sie adk web aus, um den Reisebüroagenten zu testen:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
Rufen Sie in einem Browser http://localhost:8000 auf, um den Agenten zu sehen und zu testen.
Achten Sie darauf, dass travel_agent links oben in der Weboberfläche als Agent ausgewählt ist.
Fragen Sie Ihren Agenten im Chatbereich beispielsweise „Wie viel sind 250 CAD in USD?“.
Sie sollten sehen, dass der Reisebüroagent currency_agent remote aufruft, bevor er eine Antwort gibt.
Der Agent funktioniert. Er kann Anfragen zur Währungsumrechnung verarbeiten, indem er mit A2A einen Remote-Agenten aufruft. 💸
9. Glückwunsch
Glückwunsch! Sie haben erfolgreich einen Remote-MCP-Server erstellt und bereitgestellt, mit dem Agent Development Kit (ADK) einen Währungsagenten erstellt, der mit MCP-Tools verbunden ist, und Ihren Agenten mit dem Agent2Agent-Protokoll (A2A) bereitgestellt. Anschließend haben Sie einen Reisebüroagenten erstellt, der mit A2A remote mit dem Währungsagenten kommuniziert.
Hier finden Sie einen Link zur vollständigen Codedokumentation.
Möchten Sie Ihren Agenten bereitstellen? Die Agent Runtime der Gemini Enterprise Agent Platform bietet eine verwaltete Umgebung für die Bereitstellung von KI-Agenten in der Produktion.
Behandelte Themen
- Lokalen MCP-Server erstellen
- MCP-Server in Cloud Run bereitstellen
- Agenten mit dem Agent Development Kit erstellen, der MCP-Tools verwendet
- ADK-Agenten als A2A-Server bereitstellen
- A2A-Server mit einem A2A-Client testen
- Agenten erstellen, der über das A2A-Protokoll mit einem anderen Agenten kommuniziert
Bereinigen
Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in diesem Lab verwendeten Ressourcen in Rechnung gestellt werden:
- Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
- Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen.
- Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Herunterfahren , um das Projekt zu löschen.