1. Przegląd
Agenty AI zyskują na popularności, rewolucjonizując automatyzację zadań i podejmowanie decyzji dzięki swojej zdolności do samodzielnego działania, uczenia się i interakcji ze środowiskiem w celu osiągania celów.
Ale jak dokładnie tworzy się agenta? To ćwiczenie pomoże Ci zacząć. Dowiesz się, jak utworzyć agenta walutowego, który może przeliczać waluty różnych krajów. Następnie utworzysz agenta biura podróży i połączysz go z agentem walutowym. Celem jest zapoznanie Cię z najnowszymi technologiami, aby pomóc Ci zrozumieć skróty, które mogłeś/mogłaś zobaczyć w internecie (MCP, ADK, A2A), i pokazać, jak one ze sobą współpracują.
Model Context Protocol (MCP)
Model Context Protocol (MCP) to otwarty protokół, który standaryzuje sposób, w jaki aplikacje udostępniają kontekst dużym modelom językowym. MCP zapewnia standardowy sposób łączenia modeli AI z zasobami, promptami i narzędziami.
Agent Development Kit (ADK)
pakiet Agent Development Kit (ADK) to elastyczna platforma do tworzenia i wdrażania agentów AI. ADK jest niezależny od modelu i wdrożenia oraz został stworzony z myślą o zgodności z innymi platformami. ADK został zaprojektowany tak, aby tworzenie agentów przypominało tworzenie oprogramowania. Ułatwia to deweloperom tworzenie, wdrażanie i zarządzanie architekturami agentów, które obejmują zarówno proste zadania, jak i złożone przepływy pracy.
Protokół Agent2Agent (A2A)
Protokół Agent2Agent (A2A) to otwarty standard, który umożliwia bezproblemową komunikację i współpracę między agentami AI. Podobnie jak MCP zapewnia standardowy sposób uzyskiwania przez duże modele językowe dostępu do danych i narzędzi, A2A zapewnia standardowy sposób komunikowania się agentów z innymi agentami. W świecie, w którym agenty są tworzone za pomocą różnych platform i przez różnych dostawców, A2A zapewnia wspólny język, który umożliwia współpracę i interoperacyjność.
Czego się nauczysz
- Jak utworzyć lokalny serwer MCP
- Wdrażanie serwera MCP w Cloud Run
- Jak utworzyć agenta za pomocą pakietu Agent Development Kit, który korzysta z narzędzi MCP
- Jak udostępnić agenta ADK jako serwer A2A
- Testowanie serwera A2A za pomocą klienta A2A
- Jak utworzyć agenta, który będzie komunikować się z innym agentem za pomocą protokołu A2A
Czego potrzebujesz
2. Zanim zaczniesz
Utwórz projekt
Jeśli nie masz projektu Google Cloud, utwórz go.
W konsoli Google Cloud na stronie selektora projektu wybierz lub utwórz projekt Google Cloud.
Sprawdź też, czy w projekcie w chmurze włączone są płatności. Dowiedz się, jak sprawdzić, czy w projekcie są włączone płatności.
Aktywowanie Cloud Shell
Google Cloud Shell to interaktywne środowisko programistyczne w przeglądarce, dostępne bezpośrednio w konsoli Google Cloud. To najłatwiejszy sposób na rozpoczęcie korzystania z Google Cloud bez konieczności instalowania narzędzi lokalnie.
Aktywuj Cloud Shell, klikając ten link. Możesz przełączać się między terminalem Cloud Shell (do uruchamiania poleceń w chmurze) a edytorem (do tworzenia projektów), klikając odpowiedni przycisk w Cloud Shell.
Po połączeniu z Cloud Shell możesz sprawdzić, czy uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu, używając tego polecenia:
gcloud auth list
Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Aby ustawić projekt, użyj tego polecenia:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
Włączanie interfejsów Cloud API
Włącz wymagane interfejsy API za pomocą tego polecenia: Może to potrwać kilka minut.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
compute.googleapis.com
Szczegółowe informacje o poleceniach gcloud i ich użyciu znajdziesz w dokumentacji.
Pobierz kod
Sklonuj repozytorium:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
uv służy do zarządzania zależnościami i jest już zainstalowany w Cloud Shell. Jeśli jednak korzystasz z ćwiczenia lokalnie, możesz go zainstalować w ten sposób:
# 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"
Skonfiguruj zmienne środowiskowe za pomocą pliku .env, uruchamiając to polecenie:
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
3. Tworzenie lokalnego serwera MCP
Zanim zaczniesz zarządzać agentem walutowym, musisz najpierw utworzyć serwer MCP, aby udostępnić narzędzia, których będzie potrzebować Twój agent.
Serwer MCP umożliwia pisanie lekkich programów, które udostępniają określone funkcje (np. pobieranie kursów walut) jako narzędzia. Agent lub nawet kilku agentów może następnie uzyskiwać dostęp do tych narzędzi za pomocą standardowego protokołu Model Context Protocol (MCP).
Aby utworzyć serwer MCP, który udostępnia jedno narzędzie o nazwie get_exchange_rate, możesz użyć pakietu FastMCP Python. Narzędzie get_exchange_rate wysyła wywołanie przez internet do interfejsu API Frankfurter, aby uzyskać aktualny kurs wymiany między dwiema walutami.
Kod serwera MCP znajdziesz w pliku 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),
)
)
Aby uruchomić serwer MCP lokalnie, otwórz terminal i uruchom to polecenie (serwer zostanie uruchomiony pod adresem http://localhost:8080):
uv run mcp-server/server.py
Sprawdź, czy serwer MCP działa prawidłowo i czy narzędzie get_exchange_rate jest dostępne za pomocą protokołu Model Context Protocol.
W nowym oknie terminala (aby nie zatrzymywać lokalnego serwera MCP) uruchom to polecenie:
uv run mcp-server/test_server.py
Powinien się wyświetlić aktualny kurs wymiany 1 USD (dolar amerykański) na 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
}
} ---
Świetnie! Masz już działający serwer MCP z narzędziem, do którego będzie mógł uzyskać dostęp Twój agent.
Zanim przejdziesz do następnego kroku, zatrzymaj lokalnie działający serwer MCP, naciskając Ctrl+C (lub Command+C na Macu) w terminalu, w którym go uruchomiłeś/uruchomiłaś.
4. Wdrażanie serwera MCP w Cloud Run
Możesz teraz wdrożyć serwer MCP jako zdalny serwer MCP w Cloud Run 🚀☁️
Zalety zdalnego uruchamiania serwera MCP
Zdalne uruchamianie serwera MCP w Cloud Run może przynieść kilka korzyści:
- 📈 Skalowalność: Cloud Run został zaprojektowany tak, aby szybko skalować w poziomie w celu obsługi wszystkich żądań przychodzących. Cloud Run automatycznie skaluje serwer MCP w zależności od zapotrzebowania.
- 👥 Scentralizowany serwer: możesz udostępniać dostęp do scentralizowanego serwera MCP członkom zespołu za pomocą uprawnień IAM, co pozwoli im łączyć się z nim z ich lokalnych komputerów zamiast uruchamiać własne serwery lokalnie. Jeśli wprowadzisz zmiany na serwerze MCP, skorzystają z nich wszyscy członkowie zespołu.
- 🔐 Bezpieczeństwo: Cloud Run umożliwia łatwe wymuszanie uwierzytelnionych żądań. Dzięki temu do serwera MCP będą mogły łączyć się tylko bezpieczne połączenia, co zapobiegnie nieautoryzowanemu dostępowi.
Przejdź do katalogu mcp-server:
cd mcp-server
Wdróż serwer MCP w Cloud Run:
gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .
Jeśli usługa zostanie wdrożona, zobaczysz komunikat podobny do tego:
Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.
Uwierzytelnianie klientów MCP
Ponieważ określono --no-allow-unauthenticated, aby wymagać uwierzytelniania, każdy klient MCP łączący się ze zdalnym serwerem MCP będzie musiał się uwierzytelnić.
Więcej informacji na ten temat znajdziesz w oficjalnej dokumentacji na temat hostowania serwerów MCP w Cloud Run, w zależności od tego, gdzie uruchamiasz klienta MCP.
Aby utworzyć uwierzytelniony tunel do zdalnego serwera MCP na komputerze lokalnym, musisz uruchomić serwer proxy Cloud Run.
Domyślnie adres URL usług Cloud Run wymaga, aby wszystkie żądania były autoryzowane za pomocą roli IAM wywołującego Cloud Run (roles/run.invoker). To powiązanie zasad IAM zapewnia, że do uwierzytelniania lokalnego klienta MCP używany jest silny mechanizm zabezpieczeń.
Upewnij się, że Ty i wszyscy członkowie zespołu, którzy próbują uzyskać dostęp do zdalnego serwera MCP, mają rolę IAM roles/run.invoker powiązaną z ich podmiotem zabezpieczeń IAM (kontem Google Cloud).
gcloud run services proxy mcp-server --region=us-central1
Powinny się wyświetlić te dane wyjściowe:
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
Cały ruch do http://127.0.0.1:8080 będzie teraz uwierzytelniany i przekazywany do zdalnego serwera MCP.
Testowanie zdalnego serwera MCP
W nowym terminalu wróć do folderu głównego i ponownie uruchom plik mcp-server/test_server.py, aby sprawdzić, czy zdalny serwer MCP działa.
cd ..
uv run mcp-server/test_server.py
Powinny się pojawić wyniki podobne do tych, które zostały wyświetlone podczas uruchamiania serwera lokalnie:
--- 🛠️ 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
}
} ---
Jeśli chcesz sprawdzić, czy zdalny serwer został rzeczywiście wywołany, możesz wysłać zapytanie do logów wdrożonego serwera MCP Cloud Run:
gcloud run services logs read mcp-server --region us-central1 --limit 5
W logach powinny się wyświetlić te dane wyjściowe:
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}}
Teraz, gdy masz zdalny serwer MCP, możesz przejść do tworzenia agenta. 🤖
5. Tworzenie agenta za pomocą pakietu ADK
Masz już wdrożony serwer MCP, więc możesz teraz utworzyć agenta walutowego za pomocą pakietu Agent Development Kit (ADK).
ADK sprawia, że tworzenie agentów jest bardzo proste i umożliwia im łączenie się z serwerami MCP dzięki wbudowanej obsłudze narzędzi MCP. Agent walutowy będzie uzyskiwać dostęp do narzędzia get_exchange_rate za pomocą klasy MCPToolset pakietu ADK.
Kod agenta walutowego znajduje się w pliku 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")
)
)
],
)
Aby szybko przetestować agenta walutowego, możesz skorzystać z interfejsu programistycznego ADK, do którego dostęp uzyskasz, uruchamiając adk web:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
W przeglądarce otwórz adres http://localhost:8000, aby zobaczyć i przetestować agenta.
W lewym górnym rogu interfejsu internetowego upewnij się, że jako agent jest wybrany currency_agent.
W obszarze czatu zapytaj agenta np. "Ile to 250 CAD w USD?". Zanim agent odpowie, powinien wywołać narzędzie MCP get_exchange_rate.
Agent działa. Może obsługiwać zapytania dotyczące przeliczania walut 💸.
6. Protokół Agent2Agent (A2A)
Protokół Agent2Agent (A2A) to otwarty standard, który umożliwia bezproblemową komunikację i współpracę między agentami AI. Dzięki temu agenty utworzone za pomocą różnych platform i przez różnych dostawców mogą komunikować się ze sobą w wspólnym języku, co umożliwia współpracę i interoperacyjność.
A2A umożliwia agentom:
- Odkrywanie: znajdowanie innych agentów i poznawanie ich umiejętności (AgentSkill) oraz możliwości (AgentCapabilities) za pomocą standardowych kart agenta.
- Komunikowanie się: bezpieczne wymienianie wiadomości i danych.
- Współpracowanie: delegowanie zadań i koordynowanie działań w celu osiągania złożonych celów.
Protokół A2A ułatwia tę komunikację dzięki mechanizmom takim jak „karty agenta”, które działają jak cyfrowe wizytówki. Agenci mogą ich używać do reklamowania swoich możliwości i informacji o połączeniu.
Teraz możesz udostępnić agenta walutowego za pomocą A2A, aby można go było wywoływać przez inne agenty i klientów.
Pakiet A2A Python SDK
Pakiet A2A Python SDK zawiera modele Pydantic dla każdego z wymienionych zasobów: AgentSkill, AgentCapabilities i AgentCard. Umożliwia to przyspieszenie tworzenia i integracji z protokołem A2A.
AgentSkill to sposób, w jaki będziesz informować innych agentów, że agent walutowy ma narzędzie 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?'],
)
Następnie w ramach AgentCard zostaną wymienione umiejętności i możliwości agenta wraz z dodatkowymi szczegółami, takimi jak tryby wejścia i wyjścia, które agent może obsługiwać:
# 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],
)
Nadszedł czas, aby połączyć to wszystko z agentem walutowym i pokazać możliwości A2A.
7. Udostępnianie agenta walutowego jako serwera A2A
ADK upraszcza proces tworzenia agentów i łączenia ich za pomocą protokołu A2A. Udostępnianie istniejącego agenta ADK jako serwera A2A odbywa się za pomocą funkcji to_a2a(root_agent) pakietu ADK (szczegółowe informacje znajdziesz w dokumentacji ADK).
Funkcja to_a2a przekształca istniejącego agenta, aby mógł on współpracować z A2A i być udostępniany jako serwer za pomocą uvicorn. Oznacza to, że masz większą kontrolę nad tym, co chcesz udostępnić, jeśli planujesz wdrożyć agenta w środowisku produkcyjnym. Funkcja to_a2a() automatycznie generuje kartę agenta na podstawie kodu agenta za pomocą pakietu A2A Python SDK.
W pliku currency_agent/agent.py możesz zobaczyć, jak używana jest funkcja to_a2a i jak agent walutowy jest udostępniany jako serwer A2A za pomocą zaledwie 2 wierszy kodu.
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)
Aby uruchomić serwer A2A, w nowym terminalu uruchom to polecenie:
uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000
Jeśli serwer uruchomi się prawidłowo, dane wyjściowe będą wyglądać tak, jak poniżej, co oznacza, że działa on na porcie 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)
Agent walutowy działa teraz jako serwer A2A i może być wywoływany przez inne agenty lub klientów za pomocą protokołu A2A.
Sprawdzanie, czy zdalny agent działa
Możesz sprawdzić, czy agent działa, otwierając adres URL karty agenta walutowego, który został automatycznie wygenerowany przez funkcję to_a2a().
W przeglądarce otwórz adres http://localhost:10000/.well-known/agent-card.json.
Powinna się wyświetlić ta karta agenta:
{
"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"
}
Testowanie serwera A2A
Możesz teraz przetestować serwer, wysyłając do niego żądania za pomocą A2A.
Pakiet A2A Python SDK zawiera klasę a2a.client.Client, która ułatwia to zadanie.
Plik currency_agent/test_a2aclient.py zawiera kod, który pokazuje, jak pobrać kartę agenta i wysłać wiadomość do serwera 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()
Uruchom testy za pomocą tego polecenia:
uv run currency_agent/test_a2aclient.py
Jeśli testy zakończą się pomyślnie, zobaczysz te dane wyjściowe:
🔄 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)."
}
}
...
Udało się Udało Ci się przetestować komunikację z agentem walutowym za pomocą protokołu A2A i klienta A2A. 🎉
Więcej przykładów A2A znajdziesz w repozytorium a2a-samples na GitHubie.
8. Korzystanie ze zdalnego agenta walutowego za pomocą A2A
W poprzednim kroku użyłeś/użyłaś klienta A2A do komunikowania się z agentem walutowym za pomocą A2A.
W tym kroku zobaczysz, jak możesz korzystać z agenta walutowego jako zdalnego agenta z innego agenta biura podróży.
Kod agenta biura podróży znajduje się w pliku 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)],
)
Zwróć uwagę, jak uzyskiwany jest dostęp do agenta walutowego za pomocą RemoteA2aAgent.
Aby przetestować agenta biura podróży, uruchom adk web:
uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"
W przeglądarce otwórz adres http://localhost:8000, aby zobaczyć i przetestować agenta.
W lewym górnym rogu interfejsu internetowego upewnij się, że jako agent jest wybrany travel_agent.
W obszarze czatu zapytaj agenta np. "Ile to 250 CAD w USD?".
Zanim agent biura podróży odpowie, powinien zdalnie wywołać currency_agent.
Agent działa. Może obsługiwać zapytania dotyczące przeliczania walut 💸, wywołując zdalnego agenta za pomocą A2A.
9. Gratulacje
Gratulacje! Udało Ci się utworzyć i wdrożyć zdalny serwer MCP, utworzyć agenta walutowego za pomocą pakietu Agent Development Kit (ADK), który łączy się z narzędziami za pomocą MCP, oraz udostępnić agenta za pomocą protokołu Agent2Agent (A2A). Następnie utworzyłeś/utworzyłaś agenta biura podróży, który komunikuje się ze zdalnym agentem walutowym za pomocą A2A.
Oto link do pełnej dokumentacji kodu.
Chcesz wdrożyć agenta? Środowisko wykonawcze agenta w Gemini Enterprise Agent Platform zapewnia zarządzane środowisko do wdrażania agentów AI w środowisku produkcyjnym.
Omówione zagadnienia
- Jak utworzyć lokalny serwer MCP
- Wdrażanie serwera MCP w Cloud Run
- Jak utworzyć agenta za pomocą pakietu Agent Development Kit, który korzysta z narzędzi MCP
- Jak udostępnić agenta ADK jako serwer A2A
- Testowanie serwera A2A za pomocą klienta A2A
- Jak utworzyć agenta, który będzie komunikować się z innym agentem za pomocą protokołu A2A
Zwalnianie miejsca
Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym ćwiczeniu, wykonaj te czynności:
- W konsoli Google Cloud otwórz stronę Zarządzanie zasobami.
- Z listy projektów wybierz projekt do usunięcia, a potem kliknij Usuń.
- W oknie wpisz identyfikator projektu i kliknij Wyłącz , aby usunąć projekt.