एमसीपी, एडीके, और A2A का इस्तेमाल शुरू करना

1. खास जानकारी

एआई एजेंट तेज़ी से लोकप्रिय हो रहे हैं. ये एजेंट, टास्क को ऑटोमेट करने और फ़ैसले लेने की प्रोसेस में क्रांति ला रहे हैं. ऐसा इसलिए, क्योंकि ये अपने-आप काम कर सकते हैं, सीख सकते हैं, और लक्ष्यों को हासिल करने के लिए अपने एनवायरमेंट के साथ इंटरैक्ट कर सकते हैं.

लेकिन असल में कोई एजेंट कैसे बनाया जाता है? यह कोडलैब, आपको एजेंट बनाने की प्रोसेस शुरू करने में मदद करेगा. इसमें, आपको मुद्रा एजेंट बनाने का तरीका बताया जाएगा. यह एजेंट, अलग-अलग देशों की मुद्राओं के बीच कन्वर्ज़न कर सकता है. इसके बाद, आपको ट्रैवल एजेंसी का एजेंट बनाना होगा और उसे मुद्रा एजेंट से कनेक्ट करना होगा. हमारा मकसद है कि आपको नई टेक्नोलॉजी के बारे में बताया जाए, ताकि आपको उन ऐक्रनिम के बारे में पता चल सके जो आपको इंटरनेट पर दिखते हैं. जैसे, एमसीपी, एडीके, A2A. साथ ही, यह भी बताया जाएगा कि ये एक साथ कैसे काम करते हैं.

आर्किटेक्चर

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी)

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) एक ओपन प्रोटोकॉल है. यह प्रोटोकॉल, एलएलएम को कॉन्टेक्स्ट उपलब्ध कराने के लिए, ऐप्लिकेशन के स्टैंडर्ड तरीके तय करता है. एमसीपी, एआई मॉडल को संसाधन, प्रॉम्प्ट, और टूल से कनेक्ट करने का एक स्टैंडर्ड तरीका उपलब्ध कराता है.

एजेंट डेवलपमेंट किट (एडीके)

एजेंट डेवलपमेंट किट (एडीके), एआई एजेंट को डेवलप और डिप्लॉय करने के लिए, एक फ़्लेक्सिबल ऑर्केस्ट्रेशन फ़्रेमवर्क है. एडीके, मॉडल और डिप्लॉयमेंट पर निर्भर नहीं करता. इसे अन्य फ़्रेमवर्क के साथ काम करने के लिए बनाया गया है. एडीके को इस तरह डिज़ाइन किया गया है कि एजेंट डेवलपमेंट, सॉफ़्टवेयर डेवलपमेंट जैसा लगे. इससे डेवलपर के लिए, एजेंटिक आर्किटेक्चर बनाना, डिप्लॉय करना, और ऑर्केस्ट्रेट करना आसान हो जाता है. इन आर्किटेक्चर की मदद से, आसान टास्क से लेकर मुश्किल वर्कफ़्लो तक को ऑटोमेट किया जा सकता है.

Agent2Agent (A2A) प्रोटोकॉल

Agent2Agent (A2A) प्रोटोकॉल एक ओपन स्टैंडर्ड है. इसे एआई एजेंट के बीच, बिना किसी रुकावट के कम्यूनिकेशन और सहयोग को बढ़ावा देने के लिए डिज़ाइन किया गया है. जिस तरह एमसीपी, एलएलएम को डेटा और टूल का ऐक्सेस देने का एक स्टैंडर्ड तरीका उपलब्ध कराता है, उसी तरह A2A, एजेंट को दूसरे एजेंट से बात करने का एक स्टैंडर्ड तरीका उपलब्ध कराता है! आजकल एजेंट, अलग-अलग फ़्रेमवर्क और वेंडर की मदद से बनाए जाते हैं. ऐसे में, A2A एक कॉमन लैंग्वेज उपलब्ध कराता है. इससे, अलग-अलग एजेंट के बीच कम्यूनिकेशन में आने वाली रुकावटें दूर होती हैं और इंटरऑपरेबिलिटी को बढ़ावा मिलता है.

आपको क्या सीखने को मिलेगा

  • लोकल एमसीपी सर्वर बनाने का तरीका
  • एमसीपी सर्वर को Cloud Run पर डिप्लॉय करने का तरीका
  • एजेंट डेवलपमेंट किट की मदद से, ऐसा एजेंट बनाने का तरीका जो एमसीपी टूल का इस्तेमाल करता है
  • एडीके एजेंट को A2A सर्वर के तौर पर दिखाने का तरीका
  • A2A क्लाइंट का इस्तेमाल करके, A2A सर्वर की जांच करने का तरीका
  • A2A प्रोटोकॉल की मदद से, एक एजेंट को दूसरे एजेंट से बात करने के लिए बनाने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

  • Chrome या Firefox जैसे ब्राउज़र
  • बिलिंग की सुविधा वाला Google क्लाउड प्रोजेक्ट.

2. शुरू करने से पहले

प्रोजेक्ट बनाना

अगर आपके पास कोई Google Cloud प्रोजेक्ट नहीं है, तो एक प्रोजेक्ट बनाएं.

Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, कोई Google Cloud प्रोजेक्ट चुनें या बनाएं.

यह भी पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें.

Cloud Shell चालू करें

Google Cloud Shell, ब्राउज़र पर आधारित एक इंटरैक्टिव डेवलपमेंट एनवायरमेंट है. यह Google Cloud Console में सीधे तौर पर उपलब्ध है. यह Google Cloud का इस्तेमाल शुरू करने का सबसे आसान तरीका है. इसके लिए, आपको टूल को स्थानीय तौर पर इंस्टॉल करने की ज़रूरत नहीं होती.

Cloud Shell को चालू करने के लिए, इस लिंक पर क्लिक करें. Cloud Shell में, Cloud Shell टर्मिनल (क्लाउड कमांड चलाने के लिए) और एडिटर (प्रोजेक्ट बनाने के लिए) के बीच टॉगल किया जा सकता है. इसके लिए, Cloud Shell में मौजूद बटन पर क्लिक करें.

Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपने पहले से ही पुष्टि की है या नहीं और प्रोजेक्ट को अपने प्रोजेक्ट आईडी पर सेट किया गया है या नहीं, यह कमांड चलाएं:

gcloud auth list

Cloud Shell में यह कमांड चलाकर पुष्टि करें कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है.

gcloud config list project

अपने प्रोजेक्ट को सेट करने के लिए, यह कमांड चलाएं:

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

Cloud API चालू करें

ज़रूरी एपीआई चालू करने के लिए, यह कमांड चलाएं. इसमें कुछ मिनट लग सकते हैं.

gcloud services enable cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       aiplatform.googleapis.com \
                       compute.googleapis.com

gcloud कमांड और उनके इस्तेमाल के बारे में जानने के लिए, यह दस्तावेज़ देखें.

कोड प्राप्त करें

डेटाबेस क्लोन करें:

git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent

uv का इस्तेमाल, डिपेंडेंसी मैनेज करने के लिए किया जाता है. यह Cloud Shell में पहले से इंस्टॉल है. हालांकि, अगर कोडलैब को स्थानीय तौर पर चलाया जा रहा है, तो इसे इस तरह इंस्टॉल किया जा सकता है:

# 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"

एनवायरमेंट वैरिएबल को .env फ़ाइल के साथ कॉन्फ़िगर करने के लिए, यह कमांड चलाएं:

echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env

3. लोकल एमसीपी सर्वर बनाना

मुद्रा एजेंट को ऑर्केस्ट्रेट करने से पहले, आपको एक एमसीपी सर्वर बनाना होगा. इसकी मदद से, अपने टूल को दिखाया जा सकेगा. आपके एजेंट को इन टूल की ज़रूरत होगी.

एमसीपी सर्वर की मदद से, हल्के-फुल्के प्रोग्राम लिखे जा सकते हैं. इनकी मदद से, खास क्षमताओं (जैसे, मुद्रा की एक्सचेंज रेट फ़ेच करना) को टूल के तौर पर दिखाया जा सकता है. इसके बाद, कोई एजेंट या एक से ज़्यादा एजेंट, स्टैंडर्ड मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) का इस्तेमाल करके इन टूल को ऐक्सेस कर सकते हैं.

FastMCP Python पैकेज का इस्तेमाल करके, एक एमसीपी सर्वर बनाया जा सकता है. यह सर्वर, get_exchange_rate नाम का एक टूल दिखाता है. get_exchange_rate टूल, दो मुद्राओं के बीच मौजूदा एक्सचेंज रेट पाने के लिए, Frankfurter API को इंटरनेट पर कॉल करता है.

एमसीपी सर्वर का कोड, 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),
        )
    )

एमसीपी सर्वर को स्थानीय तौर पर शुरू करने के लिए, एक टर्मिनल खोलें और यह कमांड चलाएं. सर्वर, http://localhost:8080 पर शुरू होगा:

uv run mcp-server/server.py

जांच करें कि एमसीपी सर्वर सही तरीके से काम कर रहा है और मॉडल कॉन्टेक्स्ट प्रोटोकॉल का इस्तेमाल करके, get_exchange_rate टूल को ऐक्सेस किया जा सकता है.

नए टर्मिनल विंडो में (ताकि लोकल एमसीपी सर्वर बंद न हो), यह कमांड चलाएं:

uv run mcp-server/test_server.py

आपको 1 डॉलर (अमेरिकी डॉलर) की मौजूदा एक्सचेंज रेट, यूरो (EUR) में दिखेगी:

--- 🛠️ 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
  }
} ---

बहुत बढ़िया! आपके पास अब एक ऐसा एमसीपी सर्वर है जो काम कर रहा है. इसमें एक ऐसा टूल है जिसे आपका एजेंट ऐक्सेस कर पाएगा.

अगले स्टेशन पर जाने से पहले, स्थानीय तौर पर चल रहे एमसीपी सर्वर को बंद करें. इसके लिए, उस टर्मिनल में Ctrl+C (Mac पर Command+C) दबाएं जहां आपने इसे शुरू किया था.

4. अपने एमसीपी सर्वर को Cloud Run पर डिप्लॉय करना

अब एमसीपी सर्वर को रिमोट एमसीपी सर्वर के तौर पर Cloud Run पर डिप्लॉय किया जा सकता है 🚀☁️

रिमोट तौर पर एमसीपी सर्वर चलाने के फ़ायदे

Cloud Run पर रिमोट तौर पर एमसीपी सर्वर चलाने के कई फ़ायदे हो सकते हैं:

  • 📈स्केलेबिलिटी: Cloud Run को इस तरह बनाया गया है कि यह सभी आने वाले अनुरोधों को हैंडल करने के लिए, तेज़ी से स्केल आउट हो सके. Cloud Run, मांग के आधार पर आपके एमसीपी सर्वर को अपने-आप स्केल करेगा.
  • 👥सेंट्रलाइज़्ड सर्वर: IAM के अधिकारों की मदद से, टीम के सदस्यों के साथ सेंट्रलाइज़्ड एमसीपी सर्वर का ऐक्सेस शेयर किया जा सकता है. इससे वे अपने स्थानीय कंप्यूटर से इस सर्वर से कनेक्ट कर पाएंगे. उन्हें स्थानीय तौर पर अपने सर्वर चलाने की ज़रूरत नहीं होगी. अगर एमसीपी सर्वर में कोई बदलाव किया जाता है, तो टीम के सभी सदस्यों को इसका फ़ायदा मिलेगा.
  • 🔐सुरक्षा: Cloud Run, पुष्टि किए गए अनुरोधों को लागू करने का आसान तरीका उपलब्ध कराता है. इससे आपके एमसीपी सर्वर से सिर्फ़ सुरक्षित कनेक्शन हो पाते हैं. साथ ही, अनधिकृत ऐक्सेस को रोका जा सकता है.

mcp-server डायरेक्ट्री में जाएं:

cd mcp-server

एमसीपी सर्वर को Cloud Run पर डिप्लॉय करें:

gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .

अगर आपकी सेवा को सफलतापूर्वक डिप्लॉय कर दिया गया है, तो आपको इस तरह का मैसेज दिखेगा:

Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

एमसीपी क्लाइंट की पुष्टि करना

पुष्टि करने की ज़रूरत के लिए, --no-allow-unauthenticated तय किया गया है. इसलिए, रिमोट एमसीपी सर्वर से कनेक्ट होने वाले किसी भी एमसीपी क्लाइंट को पुष्टि करनी होगी.

Cloud Run पर एमसीपी सर्वर होस्ट करने से जुड़े आधिकारिक दस्तावेज़ में, इस विषय के बारे में ज़्यादा जानकारी दी गई है. यह जानकारी, इस बात पर निर्भर करती है कि एमसीपी क्लाइंट कहां चलाया जा रहा है.

आपको अपने स्थानीय कंप्यूटर पर, Cloud Run प्रॉक्सी चलाना होगा, ताकि रिमोट एमसीपी सर्वर के लिए पुष्टि किया गया टनल बनाया जा सके.

डिफ़ॉल्ट रूप से, Cloud Run सेवाओं के यूआरएल के लिए ज़रूरी है कि सभी अनुरोधों को Cloud Run Invoker (roles/run.invoker) IAM की भूमिका के साथ अनुमति दी जाए. IAM की इस नीति के तहत, यह पक्का किया जाता है कि आपके लोकल एमसीपी क्लाइंट की पुष्टि करने के लिए, सुरक्षा का मज़बूत तरीका इस्तेमाल किया जाए.

आपको यह पक्का करना होगा कि रिमोट एमसीपी सर्वर को ऐक्सेस करने की कोशिश करने वाले आपके या टीम के किसी भी सदस्य के पास, roles/run.invoker IAM की भूमिका हो. यह भूमिका, उनके IAM प्रिंसिपल (Google Cloud खाता) से जुड़ी होनी चाहिए.

gcloud run services proxy mcp-server --region=us-central1

आपको यह आउटपुट दिखेगा:

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

http://127.0.0.1:8080 पर आने वाले सभी ट्रैफ़िक की पुष्टि की जाएगी और इसे रिमोट एमसीपी सर्वर पर फ़ॉरवर्ड किया जाएगा.

रिमोट एमसीपी सर्वर की जांच करना

नए टर्मिनल में, रूट फ़ोल्डर पर वापस जाएं और mcp-server/test_server.py फ़ाइल को फिर से चलाएं, ताकि यह पक्का किया जा सके कि रिमोट एमसीपी सर्वर काम कर रहा है.

cd ..
uv run mcp-server/test_server.py

आपको वैसा ही आउटपुट दिखेगा जैसा सर्वर को स्थानीय तौर पर चलाने पर दिखता है:

--- 🛠️ 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
  }
} ---

अगर आपको यह पुष्टि करनी है कि रिमोट सर्वर को कॉल किया गया था, तो डिप्लॉय किए गए Cloud Run एमसीपी सर्वर के लॉग की क्वेरी की जा सकती है:

gcloud run services logs read mcp-server --region us-central1 --limit 5

आपको लॉग में यह आउटपुट दिखेगा:

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}}

अब आपके पास एक रिमोट एमसीपी सर्वर है. अब एजेंट बनाया जा सकता है! 🤖

5. एडीके की मदद से एजेंट बनाना

आपने एमसीपी सर्वर डिप्लॉय कर दिया है. अब एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, मुद्रा एजेंट बनाने का समय आ गया है.

एडीके की मदद से, एजेंट को बहुत आसानी से बनाया जा सकता है. साथ ही, यह एजेंट को एमसीपी टूल के लिए बिल्ट-इन सपोर्ट के साथ, एमसीपी सर्वर से कनेक्ट करने की अनुमति देता है. मुद्रा एजेंट, एडीके की MCPToolset क्लास का इस्तेमाल करके, get_exchange_rate टूल को ऐक्सेस करेगा.

मुद्रा एजेंट का कोड, 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")
            )
        )
    ],
)

मुद्रा एजेंट को तुरंत टेस्ट करने के लिए, एडीके के डेवलपमेंट यूज़र इंटरफ़ेस (यूआई) का फ़ायदा लिया जा सकता है. इसे adk web चलाकर ऐक्सेस किया जा सकता है:

uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"

किसी ब्राउज़र में, http://localhost:8000 पर जाएं और एजेंट को देखें और टेस्ट करें!

पक्का करें कि वेब यूआई के सबसे ऊपर बाएं कोने में, currency_agent को एजेंट के तौर पर चुना गया हो.

ADK का वेब यूज़र इंटरफ़ेस (यूआई)

चैट एरिया में अपने एजेंट से "250 CAD to USD?" जैसा कुछ पूछें. आपको दिखेगा कि एजेंट, जवाब देने से पहले, हमारे get_exchange_rate एमसीपी टूल को कॉल करता है.

ADK Web Currency Agent

एजेंट काम कर रहा है! यह मुद्रा कन्वर्ज़न 💸 से जुड़ी क्वेरी को हैंडल कर सकता है.

6. Agent2Agent (A2A) प्रोटोकॉल

Agent2Agent (A2A) प्रोटोकॉल एक ओपन स्टैंडर्ड है. इसे एआई एजेंट के बीच, बिना किसी रुकावट के कम्यूनिकेशन और सहयोग को बढ़ावा देने के लिए डिज़ाइन किया गया है. इससे, अलग-अलग फ़्रेमवर्क और वेंडर की मदद से बनाए गए एजेंट, एक कॉमन लैंग्वेज में एक-दूसरे से कम्यूनिकेट कर पाते हैं. साथ ही, अलग-अलग एजेंट के बीच कम्यूनिकेशन में आने वाली रुकावटें दूर होती हैं और इंटरऑपरेबिलिटी को बढ़ावा मिलता है.

A2A प्रोटोकॉल

A2A की मदद से एजेंट ये काम कर सकते हैं:

  • डिस्कवर करना: स्टैंडर्ड एजेंट कार्ड का इस्तेमाल करके, दूसरे एजेंट ढूंढना और उनकी स्किल (AgentSkill) और क्षमताओं (AgentCapabilities) के बारे में जानना.
  • कम्यूनिकेट करना: सुरक्षित तरीके से मैसेज और डेटा का आदान-प्रदान करना.
  • साथ मिलकर काम करना: मुश्किल लक्ष्यों को हासिल करने के लिए, टास्क सौंपना और कार्रवाइयों को कोऑर्डिनेट करना.

A2A प्रोटोकॉल, "एजेंट कार्ड" जैसे तरीकों से इस कम्यूनिकेशन को आसान बनाता है. एजेंट कार्ड, डिजिटल बिज़नेस कार्ड की तरह काम करते हैं. एजेंट इनका इस्तेमाल, अपनी क्षमताओं और कनेक्शन की जानकारी का विज्ञापन करने के लिए कर सकते हैं.

A2A एजेंट कार्ड

अब मुद्रा एजेंट को A2A का इस्तेमाल करके दिखाना होगा, ताकि इसे अन्य एजेंट और क्लाइंट कॉल कर सकें.

A2A Python SDK

A2A Python SDK, ऊपर बताए गए हर संसाधन के लिए Pydantic मॉडल उपलब्ध कराता है. जैसे, AgentSkill, AgentCapabilities, और AgentCard. इससे, A2A प्रोटोकॉल के साथ डेवलपमेंट और इंटिग्रेशन को तेज़ करने के लिए एक इंटरफ़ेस मिलता है.

AgentSkill की मदद से, अन्य एजेंट को यह बताया जाएगा कि मुद्रा एजेंट के पास 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?'],
)

इसके बाद, AgentCard के हिस्से के तौर पर, एजेंट की स्किल और क्षमताओं के साथ-साथ, इनपुट और आउटपुट मोड जैसी अतिरिक्त जानकारी भी दिखाई जाएगी. एजेंट इन मोड को हैंडल कर सकता है:

# 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],
)

अब मुद्रा एजेंट के साथ इन सभी को जोड़कर, A2A की ताकत दिखाएं!

7. मुद्रा एजेंट को A2A सर्वर के तौर पर दिखाना

एडीके, A2A प्रोटोकॉल का इस्तेमाल करके, एजेंट बनाने और कनेक्ट करने की प्रोसेस को आसान बनाता है. किसी मौजूदा एडीके एजेंट को A2A सर्वर के तौर पर ऐक्सेस करने (दिखाने) के लिए, एडीके के to_a2a(root_agent) फ़ंक्शन का इस्तेमाल किया जाता है. ज़्यादा जानकारी के लिए, एडीके का दस्तावेज़ देखें.

to_a2a फ़ंक्शन, किसी मौजूदा एजेंट को A2A के साथ काम करने के लिए बदलता है. साथ ही, इसे uvicorn की मदद से सर्वर के तौर पर दिखाया जा सकता है. इसका मतलब है कि अगर आपको अपने एजेंट को प्रोडक्शन में ले जाना है, तो आपके पास यह कंट्रोल करने का विकल्प होता है कि आपको क्या दिखाना है. to_a2a() फ़ंक्शन, बैकग्राउंड में A2A Python SDK का इस्तेमाल करके, आपके एजेंट कोड के आधार पर एजेंट कार्ड को अपने-आप जनरेट करता है.

currency_agent/agent.py फ़ाइल में, to_a2a का इस्तेमाल देखा जा सकता है. साथ ही, यह भी देखा जा सकता है कि सिर्फ़ दो लाइनों के कोड से, मुद्रा एजेंट को A2A सर्वर के तौर पर कैसे दिखाया जाता है!

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)

A2A सर्वर को चलाने के लिए, नए टर्मिनल में यह कमांड चलाएं:

uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000

अगर सर्वर सफलतापूर्वक शुरू होता है, तो आउटपुट इस तरह दिखेगा. इससे पता चलेगा कि यह पोर्ट 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)

मुद्रा एजेंट अब A2A सर्वर के तौर पर सफलतापूर्वक चल रहा है. इसे A2A प्रोटोकॉल का इस्तेमाल करके, अन्य एजेंट या क्लाइंट कॉल कर सकते हैं!

पुष्टि करना कि रिमोट एजेंट चल रहा है

यह पक्का करने के लिए कि आपका एजेंट चल रहा है, मुद्रा एजेंट के एजेंट कार्ड के यूआरएल पर जाएं. यह यूआरएल, to_a2a() फ़ंक्शन से अपने-आप जनरेट हुआ था.

अपने ब्राउज़र में, http://localhost:10000/.well-known/agent-card.json पर जाएं

आपको यह एजेंट कार्ड दिखेगा:

{
  "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 सर्वर की जांच करना

अब A2A का इस्तेमाल करके, सर्वर को कुछ अनुरोध भेजकर उसकी जांच की जा सकती है!

A2A Python SDK, a2a.client.Client क्लास उपलब्ध कराता है. इससे यह प्रोसेस आसान हो जाती है.

currency_agent/test_a2aclient.py फ़ाइल में ऐसा कोड है जो दिखाता है कि एजेंट कार्ड को कैसे फ़ेच किया जाता है और 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()

जांच करने के लिए, यह कमांड चलाएं:

uv run currency_agent/test_a2aclient.py

जांच के सफल होने पर, यह आउटपुट दिखेगा:

🔄 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)."
    }
  }
  ...

यह काम करता है! आपने सफलतापूर्वक जांच की है कि A2A क्लाइंट की मदद से, A2A प्रोटोकॉल पर मुद्रा एजेंट से कम्यूनिकेट किया जा सकता है! 🎉

A2A के ज़्यादा सैंपल देखने के लिए, GitHub पर a2a-samples डेटाबेस देखें.

8. A2A के ज़रिए, रिमोट मुद्रा एजेंट का इस्तेमाल करना

पिछले चरण में, आपने A2A क्लाइंट का इस्तेमाल करके, A2A पर मुद्रा एजेंट से कम्यूनिकेट किया था.

इस चरण में, आइए देखते हैं कि किसी दूसरे ट्रैवल एजेंट से, मुद्रा एजेंट को रिमोट एजेंट के तौर पर कैसे इस्तेमाल किया जा सकता है.

ट्रैवल एजेंट का कोड, 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)],
)

ध्यान दें कि RemoteA2aAgent का इस्तेमाल करके, मुद्रा एजेंट को कैसे ऐक्सेस किया जाता है.

ट्रैवल एजेंट को टेस्ट करने के लिए, adk web चलाएं:

uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"

किसी ब्राउज़र में, http://localhost:8000 पर जाएं और एजेंट को देखें और टेस्ट करें.

पक्का करें कि वेब यूआई के सबसे ऊपर बाएं कोने में, travel_agent को एजेंट के तौर पर चुना गया हो.

चैट एरिया में अपने एजेंट से "250 CAD to USD?" जैसा कुछ पूछें.

आपको दिखेगा कि ट्रैवल एजेंट, जवाब देने से पहले, currency_agent को रिमोट तौर पर कॉल करता है.

ADK Web Remote Currency Agent

एजेंट काम कर रहा है! यह A2A का इस्तेमाल करके, रिमोट एजेंट को कॉल करके, मुद्रा कन्वर्ज़न 💸 से जुड़ी क्वेरी को हैंडल कर सकता है!

9. बधाई हो

बधाई हो! आपने रिमोट एमसीपी सर्वर को सफलतापूर्वक बनाया और डिप्लॉय किया है. साथ ही, एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, मुद्रा एजेंट बनाया है. यह एजेंट, एमसीपी का इस्तेमाल करके टूल से कनेक्ट होता है. इसके अलावा, आपने Agent2Agent (A2A) प्रोटोकॉल का इस्तेमाल करके, अपने एजेंट को दिखाया है. इसके बाद, आपने A2A का इस्तेमाल करके, मुद्रा एजेंट से रिमोट तौर पर बात करने के लिए, एक ट्रैवल एजेंट बनाया है!

यहां कोड के पूरे दस्तावेज़ का लिंक दिया गया है.

क्या आपको अपना एजेंट डिप्लॉय करना है? Gemini Enterprise Agent Platform का एजेंट रनटाइम, एआई एजेंट को प्रोडक्शन में डिप्लॉय करने के लिए, मैनेज किया गया अनुभव उपलब्ध कराता है!

हमने क्या-क्या कवर किया

  • लोकल एमसीपी सर्वर बनाने का तरीका
  • एमसीपी सर्वर को Cloud Run पर डिप्लॉय करने का तरीका
  • एजेंट डेवलपमेंट किट की मदद से, ऐसा एजेंट बनाने का तरीका जो एमसीपी टूल का इस्तेमाल करता है
  • एडीके एजेंट को A2A सर्वर के तौर पर दिखाने का तरीका
  • A2A क्लाइंट का इस्तेमाल करके, A2A सर्वर की जांच करने का तरीका
  • A2A प्रोटोकॉल की मदद से, एक एजेंट को दूसरे एजेंट से बात करने के लिए बनाने का तरीका

स्टोरेज में जगह बनाएं

इस लैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क न लिए जाने के लिए, यह तरीका अपनाएं:

  1. Google Cloud Console में, संसाधन मैनेज करें पेज पर जाएं.
  2. प्रोजेक्ट की सूची में, वह प्रोजेक्ट चुनें जिसे आपको मिटाना है. इसके बाद, मिटाएं पर क्लिक करें.
  3. डायलॉग में, प्रोजेक्ट आईडी डालें. इसके बाद, प्रोजेक्ट मिटाने के लिए शट डाउन करें पर क्लिक करें.