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

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

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

लेकिन, एजेंट को कैसे बनाया जाता है? इस कोडलैब में, आपको मुद्रा एजेंट बनाने का तरीका बताया जाएगा. यह एजेंट, अलग-अलग देशों की मुद्राओं को आपस में बदल सकता है. हमारा मकसद, आपको नई टेक्नोलॉजी के बारे में बताना है. साथ ही, आपको उन छोटे नामों (एमसीपी, एडीके, ए2ए) के बारे में जानकारी देना है जो आपने इंटरनेट पर देखे होंगे.

आर्किटेक्चर

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

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

Agent Development Kit (ADK)

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

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

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

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

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

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

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

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

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

  1. Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
  2. पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग चालू हो. किसी प्रोजेक्ट के लिए बिलिंग चालू है या नहीं, यह देखने का तरीका जानें.
  3. इस लिंक पर क्लिक करके, Cloud Shell चालू करें. Cloud Shell में जाकर, Cloud Shell टर्मिनल (क्लाउड कमांड चलाने के लिए) और एडिटर (प्रोजेक्ट बनाने के लिए) के बीच टॉगल किया जा सकता है. इसके लिए, Cloud Shell में मौजूद बटन पर क्लिक करें.
  4. Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट किया गया है, इस कमांड का इस्तेमाल करें:
gcloud auth list
  1. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं.
gcloud config list project
  1. अपना प्रोजेक्ट सेट करने के लिए, इस निर्देश का इस्तेमाल करें:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID
  1. नीचे दी गई कमांड का इस्तेमाल करके, ज़रूरी एपीआई चालू करें. इसमें कुछ मिनट लग सकते हैं.
gcloud services enable cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       aiplatform.googleapis.com \
                       compute.googleapis.com
  1. पक्का करें कि आपके पास Python 3.10 या इसके बाद का वर्शन हो

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

3. इंस्टॉल करना

  1. रिपॉज़िटरी को क्लोन करें:
git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent
  1. डिपेंडेंसी मैनेज करने के लिए, uv इंस्टॉल करें:
# 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"
  1. .env फ़ाइल के ज़रिए एनवायरमेंट वैरिएबल कॉन्फ़िगर करें:

नीचे दिए गए कोड को चलाकर, .env फ़ाइल बनाएं:

echo "GOOGLE_GENAI_USE_VERTEXAI=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=us-central1" >> .env

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

करेंसी एजेंट को मैनेज करने से पहले, आपको एक एमसीपी सर्वर बनाना होगा. इससे आपके टूल(टूल) को ऐक्सेस किया जा सकेगा, जिनकी आपके एजेंट को ज़रूरत होगी.

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

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 डॉलर (अमेरिकी डॉलर) से यूरो (यूरो) में बदलने की मौजूदा विनिमय दर दिखनी चाहिए:

--- 🛠️ 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) चलाएं जहां आपने इसे शुरू किया था.

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

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

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

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

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

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

6. एजेंट डेवलपमेंट किट (एडीके) की मदद से एजेंट बनाना

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

Agent Development Kit ने हाल ही में, v1.0.0 स्टेबल रिलीज़ किया है. इस माइलस्टोन का मतलब है कि Python ADK अब प्रोडक्शन के लिए तैयार है. यह डेवलपर के लिए एक भरोसेमंद और मज़बूत प्लैटफ़ॉर्म उपलब्ध कराता है, ताकि वे लाइव एनवायरमेंट में अपने एजेंट को कॉन्फ़िडेंट तरीके से बना सकें और डिप्लॉय कर सकें.

ADK की मदद से, एजेंट को बहुत कम समय में बनाया जा सकता है. साथ ही, एमसीपी टूल के लिए पहले से मौजूद सहायता की सुविधा के साथ, एजेंट को एमसीपी सर्वर से आसानी से कनेक्ट किया जा सकता है. मुद्रा एजेंट, ADK की 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-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")
            )
        )
    ],
)

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

uv run adk web

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

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

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

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

ADK Web Currency Agent

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

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

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

A2A प्रोटोकॉल

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

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

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 की ताकत दिखाएं!

8. मुद्रा एजेंट A2A सर्वर को ऐक्सेस करना

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

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.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.A2AClient क्लास उपलब्ध कराता है. इससे आपके लिए यह काम आसान हो जाता है.

currency_agent/test_client.py फ़ाइल में ऐसा कोड होता है जो A2A सर्वर के ख़िलाफ़ कई अलग-अलग टेस्ट केस में काम करता है.

# ... 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.')

यहां दिए गए कमांड का इस्तेमाल करके, जांच करें:

uv run currency_agent/test_client.py

टेस्ट रन पूरा होने पर, ये काम किए जा सकते हैं:

--- 🔄 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. ---

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

ज़्यादा बेहतर इस्तेमाल के उदाहरण देखने के लिए, GitHub पर a2a-samples repository देखें!

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

9. बधाई हो

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

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

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

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

व्यवस्थित करें

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

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