1. Übersicht
KI-Agenten werden immer beliebter. Sie revolutionieren die Aufgabenautomatisierung und Entscheidungsfindung, da sie autonom agieren, lernen und mit ihrer Umgebung interagieren können, um Ziele zu erreichen.
Aber wie genau geht man vor, um einen Agent zu erstellen? In diesem Codelab erfahren Sie, wie Sie einen Währungsagenten erstellen, der Währungen verschiedener Länder umrechnen kann. Wir möchten Ihnen die neuesten Technologien vorstellen, damit Sie die Abkürzungen, die Sie vielleicht schon im Internet gesehen haben (MCP, ADK, A2A), besser verstehen.
Model Context Protocol (MCP)
Das Model Context Protocol (MCP) ist ein offenes Protokoll, das standardisiert, wie Anwendungen LLMs Kontext bereitstellen. 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 modell- und bereitstellungsunabhängig und für die Kompatibilität mit anderen Frameworks konzipiert. Das ADK wurde entwickelt, um die Entwicklung von KI-Agenten an die Softwareentwicklung anzunähern und Entwicklern die Erstellung, Bereitstellung und Orchestrierung von KI-Agentenarchitekturen 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öglicht. Genau 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 entwickelt 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, die MCP-Tools verwenden
- ADK-Agent als A2A-Server bereitstellen
- A2A-Server mit dem A2A-Client testen
Voraussetzungen
2. Hinweis
Projekt erstellen
- Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
- Aktivieren Sie 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 Cloud Shell auf die entsprechende Schaltfläche klicken.
- Wenn Sie mit Cloud Shell verbunden sind, können Sie mit dem folgenden Befehl prüfen, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list
- Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt.
gcloud config list project
- Verwenden Sie den folgenden Befehl, um Ihr Projekt festzulegen:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
- 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
- Python 3.10 oder höher muss installiert sein.
Informationen zu gcloud-Befehlen und deren Verwendung finden Sie in der Dokumentation.
3. Installation
- Klonen Sie das Repository:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
- Installieren Sie uv (wird zum Verwalten von Abhängigkeiten verwendet):
# 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"
- Umgebungsvariablen konfigurieren (über die Datei
.env):
Erstellen Sie mit folgendem Befehl eine .env-Datei:
echo "GOOGLE_GENAI_USE_VERTEXAI=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=us-central1" >> .env
4. Lokalen MCP-Server erstellen
Bevor Sie Ihren Währungs-Agent orchestrieren, erstellen Sie zuerst einen MCP-Server, um die Tools verfügbar zu machen, die Ihr Agent benötigt.
Mit einem MCP-Server können Sie einfache Programme schreiben, um bestimmte Funktionen (z. B. das Abrufen von Währungskursen) als Tools verfügbar zu machen. Ein oder mehrere Agents können dann über das standardisierte Model Context Protocol (MCP) auf diese Tools zugreifen.
Mit dem Python-Paket FastMCP kann ein MCP-Server erstellt werden, der ein einzelnes Tool namens get_exchange_rate bereitstellt. Das Tool get_exchange_rate 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),
)
)
Wenn Sie den MCP-Server lokal starten möchten, öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus (der Server wird auf http://localhost:8080 gestartet):
uv run mcp-server/server.py
Prüfen 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 Terminal-Fenster (damit der lokale MCP-Server nicht beendet wird) Folgendes aus:
uv run mcp-server/test_server.py
Es sollte der aktuelle Wechselkurs von 1 $ (US-Dollar) zu EUR (Euro) ausgegeben werden:
--- 🛠️ 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 einen funktionierenden MCP-Server mit einem Tool, auf das Ihr Agent zugreifen kann.
Bevor Sie mit der nächsten Station 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.
5. MCP-Server in Cloud Run bereitstellen
Jetzt können Sie den MCP-Server als Remote-MCP-Server in Cloud Run bereitstellen. 🚀☁️
Vorteile des Remote-Betriebs eines MCP-Servers
Das Remote-Ausführen eines MCP-Servers in Cloud Run kann mehrere Vorteile bieten:
- 📈 Skalierbarkeit: Cloud Run wurde entwickelt, um schnell horizontal skaliert zu werden, um alle eingehenden Anfragen zu bearbeiten. Cloud Run skaliert Ihren MCP-Server automatisch je nach Bedarf.
- 👥 Zentralisierter Server: Sie können den Zugriff auf einen zentralisierten MCP-Server über IAM-Berechtigungen mit Teammitgliedern teilen. So können sie von ihren lokalen Computern aus eine Verbindung herstellen, 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. Dadurch sind nur sichere Verbindungen zu Ihrem MCP-Server möglich, was unbefugten Zugriff verhindert.
Wechseln Sie in das Verzeichnis mcp-server:
cd mcp-server
MCP-Server in Cloud Run bereitstellen:
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 unter 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 IAM-Rolle Cloud Run Invoker (roles/run.invoker) autorisiert werden. Diese IAM-Richtlinienbindung sorgt dafür, dass ein starker Sicherheitsmechanismus zur Authentifizierung Ihres lokalen MCP-Clients verwendet wird.
Sie und alle Teammitglieder, die auf den Remote-MCP-Server zugreifen möchten, müssen die roles/run.invoker-IAM-Rolle haben, die an ihr IAM-Hauptkonto (Google Cloud-Konto) gebunden ist.
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
Kehren Sie in einem neuen Terminal zum Stammordner zurück und führen Sie die Datei mcp-server/test_server.py noch einmal aus, um sicherzugehen, dass der Remote-MCP-Server funktioniert.
cd ..
uv run mcp-server/test_server.py
Die Ausgabe sollte in etwa so aussehen wie beim lokalen Ausführen 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}}
Nachdem Sie einen Remote-MCP-Server haben, können Sie mit dem Erstellen eines KI‑Agenten fortfahren. 🤖
6. Agent mit dem Agent Development Kit (ADK) erstellen
Sie haben einen MCP-Server bereitgestellt. Jetzt ist es an der Zeit, den Währungs-Agenten mit dem Agent Development Kit (ADK) zu erstellen.
Das Agent Development Kit wurde vor Kurzem in der stabilen Version 1.0.0 veröffentlicht. Dieser Meilenstein bedeutet, dass das Python ADK jetzt produktionsreif ist und Entwicklern eine zuverlässige und robuste Plattform bietet, auf der sie ihre Agents in Live-Umgebungen erstellen und bereitstellen können.
Mit dem ADK lassen sich sehr schlanke KI-Agenten erstellen, die sich dank integrierter Unterstützung für MCP-Tools problemlos mit MCP-Servern verbinden lassen. Der Währungs-Agent greift mit der MCPToolset-Klasse des ADK auf das get_exchange_rate-Tool zu.
Der Code für den Währungs-Agent 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-2.5-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ährungs-Agenten schnell zu testen, können Sie die Entwickler-UI des ADK verwenden. Rufen Sie sie mit dem folgenden Befehl auf: adk web
uv run adk web
Rufen Sie in einem Browser http://localhost:8000 auf, um den Agent zu sehen und zu testen.
Achten Sie darauf, dass currency_agent oben links in der Web-UI als Agent ausgewählt ist.
Fragen Sie Ihren Kundenservicemitarbeiter im Chatbereich beispielsweise: „Wie viel sind 250 CAD in USD?“. Der Kundenservicemitarbeiter sollte das MCP-Tool get_exchange_rate aufrufen, bevor er eine Antwort gibt.
Der Agent funktioniert. Es kann Anfragen zur Währungsumrechnung beantworten. 💸
7. Agent2Agent-Protokoll (A2A)
Das Agent2Agent-Protokoll (A2A) ist ein offener Standard, der eine nahtlose Kommunikation und Zusammenarbeit zwischen KI-Agenten ermöglicht. So können Agents, die mit verschiedenen Frameworks und von verschiedenen Anbietern entwickelt wurden, in einer gemeinsamen Sprache miteinander kommunizieren. Das trägt dazu bei, Silos aufzubrechen und die Interoperabilität zu fördern.
Mit A2A können Agents:
- Entdecken:Mit standardisierten Agent-Karten können Sie andere Agents und ihre Fähigkeiten (AgentSkill) und Funktionen (AgentCapabilities) finden.
- Kommunizieren:Nachrichten und Daten sicher austauschen.
- Zusammenarbeiten:Aufgaben delegieren und Aktionen koordinieren, um komplexe Ziele zu erreichen.
Das A2A-Protokoll ermöglicht diese Kommunikation durch Mechanismen wie „Agent Cards“, die als digitale Visitenkarten dienen, mit denen Agenten ihre Funktionen und Verbindungsinformationen bewerben können.
Jetzt ist es an der Zeit, den Währungs-Agenten über A2A verfügbar zu machen, 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. Dies bietet eine Schnittstelle, um die Entwicklung und Integration mit dem A2A-Protokoll zu beschleunigen.
Mit einem AgentSkill werben Sie bei anderen Kundenservicemitarbeitern dafür, dass der Währungskundenservicemitarbeiter 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?'],
)
Im Rahmen von AgentCard werden dann die Fähigkeiten und Funktionen des Agents 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ährungs-Agenten zu kombinieren und die Leistungsfähigkeit von A2A zu demonstrieren.
8. A2A-Server des Währungs-Agents verfügbar machen
Das ADK vereinfacht das Erstellen und Verbinden von Agenten mit dem A2A-Protokoll. Um einen vorhandenen ADK-Agenten als A2A-Server zugänglich zu machen (offenzulegen), wird die to_a2a(root_agent)-Funktion des ADK verwendet (vollständige Informationen finden Sie in der ADK-Dokumentation).
Mit der Funktion to_a2a wird ein vorhandener Agent so konvertiert, dass er mit A2A verwendet und über uvicorn als Server bereitgestellt werden kann. Das bedeutet, dass Sie mehr Kontrolle darüber haben, was Sie offenlegen möchten, wenn Sie Ihren Agenten in der Produktion einsetzen möchten. Mit der Funktion to_a2a() wird automatisch eine Agentenkarte basierend auf Ihrem Agentencode mit dem A2A Python SDK im Hintergrund generiert.
Wenn Sie sich die Datei currency_agent/agent.py ansehen, sehen Sie, wie to_a2a verwendet wird und wie der Währungs-Agent mit nur zwei Zeilen Code 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 den folgenden Befehl in einem neuen Terminal aus, um den A2A-Server auszuführen:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Wenn der Server erfolgreich gestartet wird, sieht die Ausgabe so aus. Sie gibt an, dass der Server 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ährungs-Agent wird jetzt erfolgreich als A2A-Server ausgeführt und kann von anderen Agents oder Clients über das A2A-Protokoll aufgerufen werden.
Prüfen, ob der Remote-Agent ausgeführt wird
Sie können überprüfen, ob Ihr Agent ausgeführt wird, indem Sie die URL der Agent-Karte für den Währungsagenten aufrufen, der automatisch von der Funktion to_a2a() generiert wurde.
Rufen Sie in Ihrem Browser [http://localhost:10000/.well-known/agent.json] auf.
Sie sollten die folgende Agent-Karte 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 einige Anfragen über A2A senden.
Das A2A Python SDK bietet eine a2a.client.A2AClient-Klasse, die dies für Sie vereinfacht.
Die Datei currency_agent/test_client.py enthält Code, der verschiedene Testläufe für den A2A-Server ausführt.
# ... see file for full code
# Example test using A2AClient
async def run_single_turn_test(client: A2AClient) -> None:
"""Runs a single-turn non-streaming test."""
send_message_payload = create_send_message_payload(text="how much is 100 USD in CAD?")
request = SendMessageRequest(
id=str(uuid4()), params=MessageSendParams(**send_message_payload)
)
print("--- ✉️ Single Turn Request ---")
# Send Message
response: SendMessageResponse = await client.send_message(request)
print_json_response(response, "📥 Single Turn Request Response")
if not isinstance(response.root, SendMessageSuccessResponse):
print("received non-success response. Aborting get task ")
return
if not isinstance(response.root.result, Task):
print("received non-task response. Aborting get task ")
return
task_id: str = response.root.result.id
print("--- ❔ Query Task ---")
# query the task
get_request = GetTaskRequest(id=str(uuid4()), params=TaskQueryParams(id=task_id))
get_response: GetTaskResponse = await client.get_task(get_request)
print_json_response(get_response, "📥 Query Task Response")
# ----- Main Entrypoint (Create client --> Run tests) -----
async def main() -> None:
"""Main function to run the tests."""
print(f'--- 🔄 Connecting to agent at {AGENT_URL}... ---')
try:
async with httpx.AsyncClient() as httpx_client:
# Create a resolver to fetch the agent card
resolver = A2ACardResolver(
httpx_client=httpx_client,
base_url=AGENT_URL,
)
agent_card = await resolver.get_agent_card()
# Create a client to interact with the agent
client = A2AClient(
httpx_client=httpx_client,
agent_card=agent_card,
)
print('--- ✅ Connection successful. ---')
await run_single_turn_test(client)
await run_multi_turn_test(client)
except Exception as e:
traceback.print_exc()
print(f'--- ❌ An error occurred: {e} ---')
print('Ensure the agent server is running.')
Führen Sie die Tests mit dem folgenden Befehl aus:
uv run currency_agent/test_client.py
Ein erfolgreicher Testlauf führt zu Folgendem:
--- 🔄 Connecting to agent at http://localhost:10000... ---
--- ✅ Connection successful. ---
--- ✉️ Single Turn Request ---
--- 📥 Single Turn Request Response ---
{"id":"3bc92d7b-d857-4e93-9ff0-b2fb865f6e35","jsonrpc":"2.0","result":{"artifacts":[{"artifactId":"35e89e14-b977-4397-a23b-92c84bc32379","parts":[{"kind":"text","text":"Based on the current exchange rate, 1 USD is equivalent to 1.3704 CAD. Therefore, 100 USD would be 137.04 CAD.\n"}]}],"contextId":"2d66f277-152c-46ef-881d-7fe32866e9f5","history":[{"contextId":"2d66f277-152c-46ef-881d-7fe32866e9f5","kind":"message","messageId":"59819269f7d04849b0bfca7d43ec073c","parts":[{"kind":"text","text":"how much is 100 USD in CAD?"}],"role":"user","taskId":"52ae2392-84f5-429a-a14b-8413d3d20d97"},{"contextId":"2d66f277-152c-46ef-881d-7fe32866e9f5","kind":"message","messageId":"286095c6-12c9-40cb-9596-a9676d570dbd","parts":[],"role":"agent","taskId":"52ae2392-84f5-429a-a14b-8413d3d20d97"}],"id":"52ae2392-84f5-429a-a14b-8413d3d20d97","kind":"task","status":{"state":"completed"}}}
// ...
--- 🚀 First turn completed, no further input required for this test case. ---
Es funktioniert. Sie haben erfolgreich getestet, dass Sie über einen A2A-Server mit dem Währungs-Agent kommunizieren können. 🎉
Im Repository „a2a-samples“ auf GitHub finden Sie weitere erweiterte Anwendungsfälle.
Möchten Sie Ihren Agent bereitstellen? Vertex AI Agent Engine bietet eine verwaltete Umgebung für die Bereitstellung von KI-Agents in der Produktion.
9. Glückwunsch
Glückwunsch! Sie haben erfolgreich einen Remote-MCP-Server erstellt und bereitgestellt, einen Währungs-Agenten mit dem Agent Development Kit (ADK) erstellt, der über MCP eine Verbindung zu Tools herstellt, und Ihren Agenten über das Agent2Agent-Protokoll (A2A) verfügbar gemacht. Der Währungs-Agent kann jetzt über A2A mit anderen Agents beliebiger Frameworks interagieren.
Hier finden Sie einen Link zur vollständigen Codedokumentation.
Behandelte Themen
- Lokalen MCP-Server erstellen
- MCP-Server in Cloud Run bereitstellen
- Agenten mit dem Agent Development Kit erstellen, die MCP-Tools verwenden
- ADK-Agent als A2A-Server bereitstellen
- A2A-Server mit dem A2A-Client testen
Bereinigen
So 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 Beenden, um das Projekt zu löschen.