1. खास जानकारी
एआई एजेंट तेज़ी से लोकप्रिय हो रहे हैं. ये टास्क ऑटोमेशन और फ़ैसले लेने की प्रोसेस में क्रांतिकारी बदलाव ला रहे हैं. ये एजेंट, खुद काम करने, सीखने, और अपने आस-पास के माहौल से इंटरैक्ट करने की क्षमता रखते हैं, ताकि लक्ष्यों को हासिल किया जा सके.
इस कोडलैब की मदद से, एंड-टू-एंड मल्टी-एजेंट सिस्टम बनाया जा सकता है. आपको एक करेंसी एमसीपी सर्वर बनाना होगा. साथ ही, एक करेंसी एजेंट बनाना होगा, जो एमसीपी सर्वर का इस्तेमाल करता हो और Agent2Agent (A2A) प्रोटोकॉल के ज़रिए उपलब्ध हो. इसके बाद, आपको एक ट्रैवल एजेंट बनाना होगा, जिसमें इन-प्रोसेस मौसम की जानकारी देने वाला सब-एजेंट हो. यह सब-एजेंट, A2A के ज़रिए करेंसी एजेंट का इस्तेमाल करता हो. आखिर में, आपको सभी सेवाओं को Cloud Run पर डिप्लॉय करना होगा.
Core Technologies
मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी)
मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) एक ओपन प्रोटोकॉल है. यह ऐप्लिकेशन के लिए, एलएलएम को कॉन्टेक्स्ट और टूल उपलब्ध कराने का तरीका तय करता है. एमसीपी को एआई ऐप्लिकेशन के लिए यूएसबी-सी पोर्ट की तरह समझें: यह एआई मॉडल को बाहरी डेटा सोर्स, एपीआई, और टूल से कनेक्ट करने का एक स्टैंडर्ड तरीका उपलब्ध कराता है.
इस कोडलैब में, currency_mcp_server, स्ट्रीम किए जा सकने वाले एचटीटीपी (/mcp) पर get_exchange_rate टूल को एक्सपोज़ करता है. इसे सार्वजनिक Frankfurter API की मदद से बनाया गया है.
Agent Development Kit (ADK)
Agent Development Kit (ADK), एआई एजेंट बनाने और उन्हें डिप्लॉय करने के लिए, ज़रूरत के हिसाब से काम करने वाला एक ऑर्केस्ट्रेशन फ़्रेमवर्क है. एडीके को किसी भी मॉडल और डिप्लॉयमेंट के साथ इस्तेमाल किया जा सकता है. साथ ही, इसे अन्य फ़्रेमवर्क के साथ काम करने के लिए बनाया गया है. एडीके की मदद से, एजेंट को स्टैंडर्ड सॉफ़्टवेयर इंजीनियरिंग की तरह डेवलप किया जा सकता है. इससे एजेंट के मुश्किल वर्कफ़्लो को आसानी से बनाया, टेस्ट, और मैनेज किया जा सकता है.
एडीके, उपयोगकर्ता की बातचीत को मैनेज करता है, इंटरैक्टिव वेब यूआई उपलब्ध कराता है, McpToolset के ज़रिए एमसीपी टूल से कनेक्ट करता है, और A2A कम्यूनिकेशन को मैनेज करता है.
Agent2Agent (A2A) प्रोटोकॉल
Agent2Agent (A2A) प्रोटोकॉल एक ओपन स्टैंडर्ड है. इसे एआई एजेंट के बीच कम्यूनिकेशन और साथ मिलकर काम करने की सुविधा देने के लिए डिज़ाइन किया गया है. जिस तरह एमसीपी, एजेंट और टूल के बीच कनेक्शन को स्टैंडर्ड बनाता है उसी तरह A2A, एजेंट और एजेंट के बीच सहयोग को स्टैंडर्ड बनाता है! आज के समय में, एजेंट अलग-अलग फ़्रेमवर्क, होस्टिंग एनवायरमेंट, और संगठनों के हिसाब से बनाए जाते हैं. ऐसे में, A2A एक ऐसी कॉमन लैंग्वेज उपलब्ध कराता है जिससे एजेंट एक-दूसरे को खोज पाते हैं और टास्क असाइन कर पाते हैं.
एडीके, currency_agent को A2A सेवा (to_a2a) के तौर पर दिखाता है. साथ ही, travel_agent को इसे AgentTool (RemoteA2aAgent) के तौर पर, कहीं से भी इस्तेमाल करने की अनुमति देता है.
लोकल सबएजेंट बनाम रिमोट एटूए एजेंट
यह आर्किटेक्चर, मल्टी-एजेंट डिज़ाइन में एक अहम पैटर्न को हाइलाइट करता है:
- लोकल एजेंट टूल (
weather_agent): यह ऑर्केस्ट्रेटर के अंदरAgentToolके तौर पर प्रोसेस में चलता है. इसमें नेटवर्क लेटेंसी या प्रोटोकॉल सीरियलाइज़ेशन ओवरहेड नहीं होता. - रिमोट एजेंट टूल (
currency_agent): यह एक स्वतंत्र माइक्रोसर्विस के तौर पर काम करता है. इसे A2A प्रोटोकॉल के ज़रिए नेटवर्क पर कॉल किया जाता है.
आपको क्या सीखने को मिलेगा
- स्ट्रीम किए जा सकने वाले एचटीटीपी पर FastMCP का इस्तेमाल करके, लोकल एमसीपी सर्वर बनाने और उसे टेस्ट करने का तरीका
- एमसीपी टूल (
McpToolset) का इस्तेमाल करने वाले ADK की मदद से एजेंट बनाने का तरीका - एडीके एजेंट को ए2ए सर्वर के तौर पर कैसे एक्सपोज़ करें (
to_a2a) - A2A Python क्लाइंट (
a2a.client) का इस्तेमाल करके, A2A सर्वर को टेस्ट करने का तरीका - लोकल सब-एजेंट टूल को रिमोट एटूए एजेंट के साथ जोड़ने वाला ऑर्केस्ट्रेटर एजेंट बनाने का तरीका
- ADK वेब यूज़र इंटरफ़ेस (यूआई) की मदद से, पूरे मल्टी-एजेंट सिस्टम को लोकल लेवल पर चलाने और टेस्ट करने का तरीका
- तीनों कॉम्पोनेंट का कंटेनर बनाने और उन्हें Google Cloud Run पर डिप्लॉय करने का तरीका
आपको किन चीज़ों की ज़रूरत होगी
- Chrome जैसा कोई ब्राउज़र.
- बिलिंग की सुविधा वाला Google क्लाउड प्रोजेक्ट.
2. शुरू करने से पहले
प्रोजेक्ट बनाना
अगर आपके पास कोई Google Cloud प्रोजेक्ट नहीं है, तो एक प्रोजेक्ट बनाएं.
Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर जाकर, कोई Google Cloud प्रोजेक्ट चुनें या बनाएं.
यह भी पक्का करें कि आपके क्लाउड प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें.
Cloud Shell चालू करें
Google Cloud Shell, ब्राउज़र पर आधारित एक इंटरैक्टिव डेवलपमेंट एनवायरमेंट है. इसे सीधे Google Cloud Console में उपलब्ध कराया जाता है. यह Google Cloud का इस्तेमाल शुरू करने का सबसे आसान तरीका है. इसके लिए, आपको स्थानीय तौर पर टूल इंस्टॉल करने की ज़रूरत नहीं पड़ती.
इस लिंक पर क्लिक करके, Cloud Shell को चालू करें. Cloud Shell में मौजूद बटन पर क्लिक करके, Cloud Shell टर्मिनल (क्लाउड कमांड चलाने के लिए) और एडिटर (फ़ाइलें देखने के लिए) के बीच टॉगल किया जा सकता है.
Cloud Shell से कनेक्ट होने के बाद, पुष्टि करें कि आपकी पहचान की पुष्टि हो गई है:
gcloud auth list
पुष्टि करें कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है:
gcloud config list project
अपना प्रोजेक्ट आईडी सेट करें:
export PROJECT_ID=<YOUR_GOOGLE_CLOUD_PROJECT_ID>
gcloud config set project $PROJECT_ID
Cloud API चालू करना
Cloud Run, Cloud Build, Artifact Registry, और Vertex AI के लिए ज़रूरी एपीआई चालू करें:
gcloud services enable run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com
कोड प्राप्त करें
डेटा स्टोर करने की जगह को क्लोन करें और python डायरेक्ट्री पर जाएं:
git clone https://github.com/meteatamel/getting-started-mcp-a2a-adk.git
cd getting-started-mcp-a2a-adk/python
uv की मदद से डिपेंडेंसी इंस्टॉल करें
uv, Python पैकेज और प्रोजेक्ट मैनेजर है. यह तेज़ी से काम करता है. यह Cloud Shell में पहले से इंस्टॉल होता है. अगर इसे स्थानीय तौर पर चलाया जा रहा है, तो इसे इस तरह इंस्टॉल किया जा सकता है:
# macOS and Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows (PowerShell)
# powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
Python डायरेक्ट्री को यूनिफ़ाइड uv के तौर पर स्ट्रक्चर किया गया है
Workspace. सभी डिपेंडेंसी को वर्कस्पेस के सभी सदस्यों (currency_mcp_server, currency_agent, और travel_agent) के लिए एक ही वर्चुअल एनवायरमेंट में इंस्टॉल करें. इसके लिए, यह कमांड चलाएं:
uv sync
एनवायरमेंट वैरिएबल कॉन्फ़िगर करना
python डायरेक्ट्री में मौजूद .env फ़ाइल में, एनवायरमेंट वैरिएबल कॉन्फ़िगर करें:
पहला विकल्प: Gemini Enterprise (Google Cloud / Cloud Shell)
echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env
दूसरा विकल्प: Google AI Studio (लोकल एपीआई पासकोड)
अगर आपको Google AI Studio से मिले एपीआई पासकोड का इस्तेमाल करना है, तो:
echo "GOOGLE_API_KEY=<your_api_key_here>"<>>/span> .env \
&& echo "GOOGLE_GENAI_USE_ENTERPRISE=FALSE" >> .env
3. मुद्रा के लिए एमसीपी सर्वर बनाना
एजेंट बनाने से पहले, आपको एमसीपी सर्वर को एक्सप्लोर करना होगा. इससे आपको मुद्रा को दूसरी मुद्रा में बदलने की प्रोसेस वाले टूल के बारे में जानकारी मिलेगी.
एमसीपी सर्वर की मदद से, कम साइज़ वाले प्रोग्राम लिखे जा सकते हैं, ताकि क्षमताओं को टूल के तौर पर दिखाया जा सके. इसके बाद, कोई एजेंट (या कई एजेंट) स्टैंडर्ड मॉडल कॉन्टेक्स्ट प्रोटोकॉल का इस्तेमाल करके, इन टूल को ऐक्सेस कर सकता है.
FastMCP Python पैकेज का इस्तेमाल करके, एक ऐसा एमसीपी सर्वर बनाया जा सकता है जो get_exchange_rate नाम के एक टूल को एक्सपोज़ करता है. get_exchange_rate टूल, दो मुद्राओं के बीच मौजूदा एक्सचेंज रेट पाने के लिए, Frankfurter API को कॉल करता है.
एमसीपी सर्वर का कोड currency_mcp_server/server.py में मौजूद है:
import asyncio
import logging
import os
import httpx
from fastmcp import FastMCP
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.dev/v1/{currency_date}",
params={"from": currency_from, "to": currency_to},
)
response.raise_for_status()
data = response.json()
if "rates" not in data:
logger.error(f"❌ rates not found in response: {data}")
return {"error": "Invalid API response format."}
logger.info(f"✅ API response: {data}")
return data
except httpx.HTTPError as e:
logger.error(f"❌ API request failed: {e}")
return {"error": f"API request failed: {e}"}
except ValueError:
logger.error("❌ Invalid JSON response from API")
return {"error": "Invalid JSON response from API."}
if __name__ == "__main__":
port = int(os.getenv("PORT", 8080))
logger.info(f"🚀 MCP server started on port {port}")
# 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=port,
)
)
एमसीपी सर्वर को स्थानीय तौर पर शुरू करना
अपने टर्मिनल में एमसीपी सर्वर को चालू करें:
uv run python currency_mcp_server/server.py
सर्वर, पोर्ट 8080 पर शुरू होता है. साथ ही, स्ट्रीम किए जा सकने वाले एचटीटीपी एंडपॉइंट, /mcp (http://localhost:8080/mcp) पर उपलब्ध होते हैं.
एमसीपी सर्वर की जांच करना
दूसरी टर्मिनल विंडो खोलें (एमसीपी सर्वर को पहली विंडो में चलने दें), python फ़ोल्डर (cd getting-started-mcp-a2a-adk/python) पर जाएं, और टेस्ट स्क्रिप्ट चलाएं:
uv run python currency_mcp_server/test_server.py
टेस्ट स्क्रिप्ट, FastMCP के Client का इस्तेमाल करके एमसीपी एंडपॉइंट से कनेक्ट करती है, टूल की सूची बनाती है, और get_exchange_rate को शुरू करती है:
Connecting to MCP server at: http://localhost:8080/mcp
--- 🛠️ Tool found: get_exchange_rate ---
--- 🪛 Calling get_exchange_rate tool for USD to EUR ---
--- ✅ Success: {"amount":1.0,"base":"USD","date":"2026-09-29","rates":{"EUR":0.84919}} ---
बहुत बढ़िया! आपके पास एक ऐसा एमसीपी सर्वर है जो काम कर रहा है और लाइव करेंसी टूल उपलब्ध कराता है. अगले चरणों के लिए, इस टर्मिनल को खुला रखें.
4. ADK की मदद से करेंसी एजेंट बनाना
अब Agent Development Kit (ADK) का इस्तेमाल करके, करेंसी एजेंट बनाने का समय आ गया है.
एडीके, McpToolset क्लास के ज़रिए एमसीपी टूल के लिए पहले से मौजूद सहायता उपलब्ध कराता है. करंसी एजेंट, StreamableHTTPConnectionParams का इस्तेमाल करके हमारे एमसीपी सर्वर से कनेक्ट करता है.
currency_agent/agent.py में, मुद्रा एजेंट की परिभाषा देखें:
import logging
import os
from urllib.parse import urlparse
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."
)
mcp_server_url = os.getenv("MCP_SERVER_URL", "http://localhost:8080/mcp")
if not mcp_server_url.endswith("/mcp"):
mcp_server_url = f"{mcp_server_url.rstrip('/')}/mcp"
logger.info(f"--- 🔧 Loading MCP tools from MCP Server at {mcp_server_url}... ---")
logger.info("--- 🤖 Creating ADK Currency Agent... ---")
root_agent = LlmAgent(
model="gemini-3.8-flash",
name="currency_agent",
description="An agent that can help with currency conversions",
instruction=SYSTEM_INSTRUCTION,
tools=[
McpToolset(
connection_params=StreamableHTTPConnectionParams(
url=mcp_server_url
)
)
],
)
ध्यान दें कि McpToolset, एचटीटीपी पर चल रहे एमसीपी सर्वर से सीधे get_exchange_rate टूल को कैसे अपने-आप खोजता और लोड करता है.
ADK के वेब यूज़र इंटरफ़ेस की मदद से, करेंसी एजेंट की जांच करना
एडीके के डेवलपमेंट वेब इंटरफ़ेस का इस्तेमाल करके, एजेंट को अलग से टेस्ट किया जा सकता है. अपने दूसरे टर्मिनल में, यह चलाएं:
uv run adk web --allow_origins "*" currency_agent
http://localhost:8000 पर अपना ब्राउज़र खोलें या Cloud Shell में वेब की झलक पर क्लिक करें.
एजेंट से पूछें:
"250 डॉलर कितने यूरो के बराबर है?"
आपको दिखेगा कि एजेंट, get_exchange_rate एमसीपी टूल को कॉल करता है और बदली हुई रकम दिखाता है. आगे बढ़ने से पहले, Ctrl+C का इस्तेमाल करके adk web प्रोसेस को रोकें.
5. Agent2Agent (A2A) प्रोटोकॉल
Agent2Agent (A2A) प्रोटोकॉल एक ओपन स्टैंडर्ड है. इसे एआई एजेंट के बीच कम्यूनिकेशन और साथ मिलकर काम करने की सुविधा देने के लिए डिज़ाइन किया गया है.
मल्टी-एजेंट सिस्टम में, एजेंट अक्सर अलग-अलग फ़्रेमवर्क (ADK, LangChain, CrewAI, AutoGen) का इस्तेमाल करके बनाए जाते हैं और अलग-अलग इन्फ़्रास्ट्रक्चर पर डिप्लॉय किए जाते हैं. A2A, कम्यूनिकेशन के लिए एक स्टैंडर्ड कॉन्ट्रैक्ट तय करके, इन साइलो को खत्म करता है.
A2A के मुख्य सिद्धांत
- एजेंट की खोज (एजेंट कार्ड): A2A के मुताबिक काम करने वाला हर एजेंट, अपनी क्षमताओं, काम करने वाले I/O मोड, पुष्टि करने की ज़रूरी शर्तों, और कौशल का विज्ञापन दिखाता है. इसके लिए, वह
/.well-known/agent-card.jsonपर होस्ट की गई स्टैंडर्ड JSON फ़ाइल का इस्तेमाल करता है. - एजेंट की स्किल (
AgentSkill): ऐसी खास क्षमताएँ या टूल जिनका इस्तेमाल एजेंट कर सकता है. अन्य एजेंट इन स्किल को पढ़कर तय करते हैं कि टास्क कब असाइन करना है. - JSON-RPC कम्यूनिकेशन: एजेंट, एचटीटीपी JSON-RPC 2.0 जैसे स्टैंडर्ड ट्रांसपोर्ट का इस्तेमाल करके, स्ट्रक्चर्ड मैसेज, टास्क, और आर्टफ़ैक्ट शेयर करते हैं.
अगले चरण में, आपको हमारे ADK Currency Agent को A2A सर्वर के तौर पर एक्सपोज़ करना होगा. इससे अन्य एजेंट इसे खोज पाएंगे और मुद्रा को दूसरी मुद्रा में बदलने के टास्क इसे सौंप पाएंगे!
6. करेंसी एजेंट को A2A सर्वर के तौर पर एक्सपोज़ करना
एडीके, to_a2a() यूटिलिटी फ़ंक्शन की मदद से, किसी भी LlmAgent को A2A के साथ काम करने वाले सर्वर में आसानी से बदल देता है.
currency_agent/agent.py के सबसे नीचे मौजूद सेक्शन को देखें:
# Make the agent A2A-compatible
PORT = int(os.getenv("PORT", 8081))
AGENT_URL = os.getenv("AGENT_URL")
if AGENT_URL:
parsed = urlparse(AGENT_URL)
protocol = parsed.scheme or "https"
host = parsed.hostname
port = parsed.port or 443
else:
protocol = "http"
host = "localhost"
port = PORT
a2a_app = to_a2a(root_agent, host=host, port=port, protocol=protocol)
if __name__ == "__main__":
import uvicorn
logger.info(f"🚀 Starting currency_agent on port {PORT}")
uvicorn.run(a2a_app, host="0.0.0.0", port=PORT)
to_a2a() हेल्पर अपने-आप:
LlmAgentके टूल और निर्देशों की जांच करता है.- यह
AgentCardके लिए, A2A जनरेट करता है.इसमें इसकी स्किल के बारे में बताया जाता है. जैसे,currency_agent-get_exchange_rate. - एजेंट को FastAPI ऐप्लिकेशन (
a2a_app) में रैप करता है, जो JSON-RPC एंडपॉइंट के साथ काम करता है. AGENT_URL(या लोकलहोस्ट) के आधार पर, एजेंट कार्ड में विज्ञापन के तौर पर दिखाए गएurlको डाइनैमिक तरीके से कॉन्फ़िगर करता है.
Currency Agent A2A सर्वर को चालू करें
अपने दूसरे टर्मिनल में, मुद्रा एजेंट को चालू करें:
uv run python currency_agent/agent.py
सर्वर, पोर्ट 8081 पर शुरू होता है:
[INFO]: --- 🔧 Loading MCP tools from MCP Server at http://localhost:8080/mcp... ---
[INFO]: --- 🤖 Creating ADK Currency Agent... ---
[INFO]: 🚀 Starting currency_agent on port 8081
INFO: Started server process
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://0.0.0.0:8081 (Press CTRL+C to quit)
एजेंट कार्ड की जांच करना
अपने ब्राउज़र में, एजेंट कार्ड के एंडपॉइंट पर जाएं: http://localhost:8081/.well-known/agent-card.json
आपको अपने-आप जनरेट हुआ JSON मेटाडेटा दिखेगा:
{
"name": "currency_agent",
"description": "An agent that can help with currency conversions",
"supportedInterfaces": [
{
"url": "http://localhost:8081",
"protocolBinding": "JSONRPC",
"protocolVersion": "1.0"
}
],
"version": "0.0.1",
"capabilities": {
"streaming": true
},
"defaultInputModes": [
"text/plain"
],
"defaultOutputModes": [
"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"
]
}
]
}
A2A क्लाइंट की मदद से टेस्ट करना
तीसरा टर्मिनल खोलें, python फ़ोल्डर (cd getting-started-mcp-a2a-adk/python) पर जाएं, और खास तौर पर बनाए गए A2A टेस्ट क्लाइंट स्क्रिप्ट का इस्तेमाल करके, A2A एंडपॉइंट की जांच करें:
uv run python currency_agent/test_a2aclient.py
क्लाइंट, A2ACardResolver का इस्तेमाल करके एजेंट कार्ड को रिज़ॉल्व करता है और JSON-RPC मैसेज भेजता है:
🔄 Fetching the agent card at http://localhost:8081
✅ Successfully fetched the agent card
====================================================
AgentCard
====================================================
Name : currency_agent
Description : An agent that can help with currency conversions
Interfaces : [0] http://localhost:8081 (JSONRPC 1.0)
Skills : currency_agent, currency_agent-get_exchange_rate
====================================================
🔄 Initializing a non-streaming client
Sending request: "how much is 100 USD in GBP?"
Response:
100 USD is currently equal to approximately 73.37 GBP...
करंसी एजेंट अब पूरी तरह से काम करने वाले A2A सर्वर के तौर पर काम कर रहा है!
7. ट्रैवल एजेंट बनाना
अब आपको ऑर्केस्ट्रेटर ट्रैवल एजेंट बनाना होगा. यह एजेंट दिखाता है कि ADK एजेंट, दो अलग-अलग टूल पैराडाइम को आसानी से कैसे जोड़ सकता है:
- लोकल एजेंट टूल (
weather_agent): यह एक इन-प्रोसेस ADK सबएजेंट है, जो उसी Python रनटाइम में चलता है. इससे नेटवर्क या सीरियलाइज़ेशन में होने वाली देरी से बचा जा सकता है. - रिमोट एजेंट टूल (
currency_agent): यह एक बाहरी एजेंट होता है, जोRemoteA2aAgentका इस्तेमाल करके, A2A प्रोटोकॉल के ज़रिए नेटवर्क से कनेक्ट होता है.
+-----------------------------+
| travel_agent |
| (Orchestrator with Web UI) |
+--------------+--------------+
|
+---------------------+---------------------+
| (In-process call) | (A2A Network Hop)
v v
+-------------------------+ +-------------------------+
| weather_agent | | currency_agent |
| (Local AgentTool) | | (Remote A2A Agent) |
| Calls wttr.in API | | Calls Currency MCP Svc |
+-------------------------+ +-------------------------+
1. मौजूदा जगह का मौसम बताने वाला सबएजेंट
travel_agent/subagents/weather_agent.py पर एक नज़र डालें:
import logging
import httpx
from google.adk.agents import LlmAgent
logger = logging.getLogger(__name__)
SYSTEM_INSTRUCTION = (
"You are a specialized assistant for providing weather forecasts and conditions for travel destinations. "
"Your sole purpose is to use the 'get_weather' tool to fetch weather information. "
"Provide clear, concise summaries of current weather conditions, temperatures, and forecasts to help travelers pack and plan."
)
def get_weather(location: str = "London") -> dict:
"""Gets the current weather and forecast for a given location or city."""
logger.info(f"--- 🌤️ Tool: get_weather called for {location} ---")
try:
response = httpx.get(
f"https://wttr.in/{location}?format=j1",
headers={"User-Agent": "curl/7.68.0"},
timeout=8.0,
)
response.raise_for_status()
data = response.json()
current = data["current_condition"][0]
return {
"location": location,
"condition": current.get("weatherDesc", [{}])[0].get("value", "Unknown"),
"temperature_celsius": f"{current.get('temp_C', 'N/A')}°C",
"temperature_fahrenheit": f"{current.get('temp_F', 'N/A')}°F",
"humidity": f"{current.get('humidity', 'N/A')}%",
"wind_speed_kmph": f"{current.get('windspeedKmph', 'N/A')} km/h",
}
except Exception as e:
logger.warning(f"⚠️ Weather lookup failed: {e}. Returning simulated estimate.")
return {
"location": location,
"condition": "Partly Cloudy",
"temperature_celsius": "20°C",
"temperature_fahrenheit": "68°F",
"humidity": "55%",
"wind_speed_kmph": "10 km/h",
"note": f"Live data unavailable ({e}); showing estimated conditions.",
}
weather_agent = LlmAgent(
model="gemini-3.8-flash",
name="weather_agent",
description="A local specialist agent that provides current weather reports and forecasts for travel destinations.",
instruction=SYSTEM_INSTRUCTION,
tools=[get_weather],
)
मौसम की जानकारी देने वाला एजेंट, LlmAgent है. इसमें एक फ़ंक्शन टूल है, जो wttr.in से रीयल-टाइम में मौसम की जानकारी फ़ेच करता है. साथ ही, इसमें एक मज़बूत फ़ॉलबैक भी है.
2. ट्रैवल एजेंट ऑर्केस्ट्रेटर
अब 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
try:
from travel_agent.subagents.weather_agent import weather_agent
except ImportError:
from subagents.weather_agent import weather_agent
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.\n\n"
"- Whenever a user asks about currency exchange rates or money conversions, "
"delegate the request to the 'currency_agent' tool.\n"
"- Whenever a user asks about the weather, climate, or forecasts for a destination, "
"delegate the request to the 'weather_agent' tool."
)
CURRENCY_AGENT_URL = os.getenv("CURRENCY_AGENT_URL", "http://localhost:8081").rstrip("/")
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.8-flash",
name="travel_agent",
description="A travel assistant that can help plan trips, check weather forecasts via the local weather agent, and convert currencies via the remote currency agent.",
instruction=SYSTEM_INSTRUCTION,
tools=[
AgentTool(agent=currency_remote_agent),
AgentTool(agent=weather_agent),
],
)
if __name__ == "__main__":
import uvicorn
from google.adk.cli.fast_api import get_fast_api_app
PORT = int(os.getenv("PORT", 8082))
logger.info(f"🚀 Starting travel_agent Web UI on port {PORT}")
app = get_fast_api_app(web=True, allow_origins=["*"], agents_dir=os.path.dirname(__file__) or ".")
uvicorn.run(app, host="0.0.0.0", port=PORT)
खास बातें:
RemoteA2aAgent,http://localhost:8081/.well-known/agent-card.jsonसे मुद्रा एजेंट का कार्ड फ़ेच करता है.currency_remote_agentऔरweather_agent, दोनों को ADK केAgentToolका इस्तेमाल करके रैप किया गया है.travel_agent/agent.pyको चलाने से,get_fast_api_app(web=True)का इस्तेमाल करके पोर्ट8082पर एडीके वेब यूज़र इंटरफ़ेस (यूआई) सीधे तौर पर बूट हो जाता है.
8. मल्टी-एजेंट सिस्टम को लोकल लेवल पर चलाना और टेस्ट करना
अब आपके पास तीनों कॉम्पोनेंट तैयार हैं! चलिए, पूरे सिस्टम को लोकल लेवल पर चलाकर उसकी जांच करते हैं.
तीनों सेवाएं चालू होने पर
पक्का करें कि सेवाएं, तीन अलग-अलग टर्मिनल विंडो (getting-started-mcp-a2a-adk/python डायरेक्ट्री से) में इस क्रम में चल रही हों:
टर्मिनल 1 (करंसी एमसीपी सर्वर):
uv run python currency_mcp_server/server.py
(पोर्ट 8080 पर चल रहा है)
टर्मिनल 2 (करंसी एटूए एजेंट):
uv run python currency_agent/agent.py
(पोर्ट 8081 पर चल रहा है)
टर्मिनल 3 (वेब यूज़र इंटरफ़ेस वाला ट्रैवल एजेंट):
uv run python travel_agent/agent.py
(पोर्ट 8082 पर चल रहा है)
एडीके वेब यूज़र इंटरफ़ेस (यूआई) की मदद से जांच करना
अपने ब्राउज़र में http://localhost:8082 खोलें या Cloud Shell में पोर्ट 8082 पर वेब की झलक का इस्तेमाल करें.
ट्रैवल एजेंट से ऐसा सवाल पूछें जिसके जवाब के लिए, दोनों टूल की ज़रूरत पड़े:
"मैं लंदन जाने का प्लान बना रहा हूँ. मौसम कैसा है और 200 यूरो कितने पाउंड स्टर्लिंग के बराबर है?"
एक्ज़ीक्यूशन फ़्लो देखें:
- ट्रैवल एजेंट को वेब यूज़र इंटरफ़ेस (यूआई) में अनुरोध मिलता है.
- यह मौसम से जुड़े सवाल को प्रोसेस करने के लिए, स्थानीय
weather_agentको भेजता है. यहwttr.inसे मौजूदा मौसम की जानकारी फ़ेच करता है. - यह A2A प्रोटोकॉल के ज़रिए, मुद्रा को दूसरी मुद्रा में बदलने की प्रोसेस को पोर्ट 8081 पर
currency_agentको डेलिगेट करता है. currency_agent, एक्सचेंज रेट फ़ेच करने के लिए, एमसीपी पर पोर्ट 8080 परcurrency_mcp_serverको कॉल करता है.- सभी नतीजों को एक साथ जोड़कर, आपको एक ही जवाब में काम की जानकारी दी जाती है!
कमांड लाइन की मदद से टेस्ट करना
ब्राउज़र खोले बिना, सीधे सीएलआई से भी क्वेरी की जांच की जा सकती है:
uv run adk run travel_agent "What is the weather in London and how much is 100 USD in EUR?"
अब जब आपकी लोकल मशीन पर सब कुछ आसानी से काम कर रहा है, तो चलिए पूरे सिस्टम को Google Cloud Run पर डिप्लॉय करते हैं!
9. मल्टी-एजेंट सिस्टम को Cloud Run पर डिप्लॉय करना
हर कॉम्पोनेंट का अपना Dockerfile और pyproject.toml होता है. इसलिए, इसे Cloud Run में अलग से बनाया और डिप्लॉय किया जा सकता है.
gcloud का इस्तेमाल करके, हर सेवा को डिप्लॉय किया जाएगा और उनके यूआरएल अपने-आप एक साथ जुड़ जाएंगे.
एनवायरमेंट वैरिएबल सेट करना
अपना क्लाउड प्रोजेक्ट आईडी और टारगेट क्षेत्र सेट करें:
export PROJECT_ID=<YOUR_GOOGLE_CLOUD_PROJECT_ID>
export REGION=us-central1
पहला चरण: Currency MCP Server को डिप्लॉय करना
एमसीपी सर्वर को सीधे सोर्स से डिप्लॉय करें:
# 1. Deploy MCP server
gcloud run deploy currency-mcp-server \
--source currency_mcp_server \
--region $REGION \
--allow-unauthenticated
# 2. Capture the deployed MCP server URL
MCP_SERVER_URL=$(gcloud run services describe currency-mcp-server --region $REGION --format='value(status.url)')/mcp
echo "MCP Server URL: $MCP_SERVER_URL"
दूसरा चरण: करेंसी एजेंट को डिप्लॉय करना
currency-agent का सार्वजनिक यूआरएल, इसके पहले डिप्लॉयमेंट पर असाइन किया जाता है. इसलिए, पहले सेवा को डिप्लॉय करें, उसका यूआरएल कैप्चर करें, और उसके AGENT_URL एनवायरमेंट वैरिएबल को अपडेट करें, ताकि उसका एटूए एजेंट कार्ड, सही सार्वजनिक एचटीटीपीएस पते का विज्ञापन दिखाए:
# 1. Deploy Currency Agent connected to the deployed MCP Server
gcloud run deploy currency-agent \
--source currency_agent \
--region $REGION \
--allow-unauthenticated \
--update-env-vars MCP_SERVER_URL="$MCP_SERVER_URL",GOOGLE_GENAI_USE_ENTERPRISE="true",GOOGLE_CLOUD_PROJECT="$PROJECT_ID",GOOGLE_CLOUD_LOCATION="global"
# 2. Capture its assigned Cloud Run URL
CURRENCY_AGENT_URL=$(gcloud run services describe currency-agent --region $REGION --format='value(status.url)')
echo "Currency Agent URL: $CURRENCY_AGENT_URL"
# 3. Update AGENT_URL so the agent advertises its public HTTPS endpoint in its Agent Card
gcloud run services update currency-agent \
--region $REGION \
--update-env-vars AGENT_URL="$CURRENCY_AGENT_URL"
तीसरा चरण: ट्रैवल एजेंट को डिप्लॉय करना
अब ट्रैवल एजेंट को डिप्लॉय करें और उसे CURRENCY_AGENT_URL के साथ कॉन्फ़िगर करें:
# 1. Deploy Travel Agent (with ADK Web UI) connected to Currency Agent
gcloud run deploy travel-agent \
--source travel_agent \
--region $REGION \
--allow-unauthenticated \
--update-env-vars CURRENCY_AGENT_URL="$CURRENCY_AGENT_URL",GOOGLE_GENAI_USE_ENTERPRISE="true",GOOGLE_CLOUD_PROJECT="$PROJECT_ID",GOOGLE_CLOUD_LOCATION="global"
# 2. Capture its assigned Cloud Run URL
TRAVEL_AGENT_URL=$(gcloud run services describe travel-agent --region $REGION --format='value(status.url)')
echo "Travel Agent URL: $TRAVEL_AGENT_URL"
10. Cloud Run में मल्टी-एजेंट सिस्टम को टेस्ट करना
तीनों माइक्रोसर्विस को डिप्लॉय करने के बाद, Cloud Run में हर लेयर की पुष्टि करें.
1. रिमोट एमसीपी सर्वर को टेस्ट करना
अपनी कमांड लाइन से, डिप्लॉय किए गए Cloud Run एमसीपी सर्वर की जांच करें:
MCP_SERVER_URL="$MCP_SERVER_URL" uv run python currency_mcp_server/test_server.py
आपको टूल की सूची दिखेगी और Cloud Run पर उसे चालू किया जा सकेगा.
2. A2A पर Currency Agent को टेस्ट करना
A2A टेस्ट क्लाइंट का इस्तेमाल करके, डिप्लॉय किए गए Currency Agent की जांच करें:
AGENT_URL="$CURRENCY_AGENT_URL" uv run python currency_agent/test_a2aclient.py
क्लाइंट, Cloud Run से रिमोट एजेंट कार्ड फ़ेच करेगा और एचटीटीपीएस JSON-RPC के ज़रिए मैसेज एक्सचेंज करेगा.
3. Cloud Run में ट्रैवल एजेंट के वेब यूज़र इंटरफ़ेस (यूआई) की जांच करना
अपने ब्राउज़र में $TRAVEL_AGENT_URL खोलें!
ADK का पूरा वेब यूज़र इंटरफ़ेस (यूआई), सीधे Cloud Run से उपलब्ध कराया जाता है. ये निर्देश देकर देखें:
"मुझे टोक्यो जाना है. मौसम कैसा है और 500 डॉलर कितने जैपनीज़ येन के बराबर है?"
[Browser]
│
▼ (HTTPS)
[Cloud Run: travel-agent]
├──> Local in-process tool: weather_agent (wttr.in)
└──> A2A JSON-RPC (HTTPS)
│
▼
[Cloud Run: currency-agent]
└──> MCP Streamable HTTP (HTTPS)
│
▼
[Cloud Run: currency-mcp-server] (Frankfurter API)
ये तीनों सेवाएं, सर्वरलेस इन्फ़्रास्ट्रक्चर पर अलग-अलग स्केल होती हैं. साथ ही, ओपन प्रोटोकॉल के ज़रिए आसानी से कम्यूनिकेट करती हैं!
11. बधाई और साफ़-सफ़ाई
आपने क्या-क्या हासिल किया है
बधाई हो! आपने प्रोडक्शन-ग्रेड मल्टी-एजेंट सिस्टम बनाया और डिप्लॉय किया है:
- मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी): हमने एक FastMCP सर्वर बनाया है, जो स्ट्रीम किए जा सकने वाले एचटीटीपी पर लाइव एपीआई टूल उपलब्ध कराता है.
- Agent Development Kit (ADK):
LlmAgentका इस्तेमाल करके मॉड्यूलर एजेंट बनाए,McpToolsetके साथ एमसीपी टूल कनेक्ट किए, और ADK वेब यूज़र इंटरफ़ेस (यूआई) को होस्ट किया. - Agent2Agent (A2A) प्रोटोकॉल: एजेंट को A2A सेवा (
to_a2a) के तौर पर एक्सपोज़ किया गया, एजेंट कार्ड (agent-card.json) पब्लिश किए गए, औरRemoteA2aAgentका इस्तेमाल करके रिमोट एजेंट इस्तेमाल किए गए. - मल्टी-एजेंट आर्किटेक्चर: इसमें लोकल इन-प्रोसेस सबएजेंट (
weather_agent) और डिस्ट्रिब्यूटेड रिमोट एजेंट (currency_agent) को एक साथ इस्तेमाल किया जाता है. - Cloud Run सर्वरलेस डिप्लॉयमेंट: तीनों सेवाओं को कंटेनर में रखा गया और ऑटोमेटेड कॉन्फ़िगरेशन वायरिंग के साथ डिप्लॉय किया गया.
पूरा कोड (Python और Java, दोनों के लिए लागू करने का तरीका) और आने वाले समय में होने वाले अपडेट के लिए, getting-started-mcp-a2a-adk रिपॉज़िटरी पर जाएं.
व्यवस्थित करें
इस कोडलैब में बनाई गई Cloud Run सेवाओं के लिए, अपने Google Cloud खाते पर शुल्क लगने से बचने के लिए:
डिप्लॉय की गई Cloud Run सेवाओं को मिटाएं:
gcloud run services delete currency-mcp-server --region $REGION --quiet
gcloud run services delete currency-agent --region $REGION --quiet
gcloud run services delete travel-agent --region $REGION --quiet
इसके अलावा, अगर आपने इस कोडलैब के लिए कोई खास प्रोजेक्ट बनाया है, तो पूरे प्रोजेक्ट को बंद किया जा सकता है:
gcloud projects delete $PROJECT_ID