Google ADK ट्यूटोरियल: MCP सर्वर लॉजिस्टिक्स एजेंट बनाना

आज जटिल AI एजेंट बनाने में सबसे बड़ी बाधा मॉडल नहीं, बल्कि इंटीग्रेशन है। यदि आप चाहते हैं कि कोई एजेंट दस अलग-अलग एंटरप्राइज टूल्स तक पहुँचे, तो आमतौर पर आपको दस अलग-अलग API रैपर लिखने पड़ते हैं। मेरे अनुभव में, इससे रैपर थकान और भारी मेंटेनेंस बोझ पैदा होता है। हर बार जब कोई API बदलती है, आपका एजेंट टूट जाता है।

समाधान Google Agent Development Kit (ADK) और Model Context Protocol (MCP) की साझेदारी में निहित है। यदि हम AI को एक कार्यकर्ता मानें, तो ADK उसका "मस्तिष्क" है (लॉजिक और मेमोरी का संयोजन), जबकि MCP "हाथ" का प्रतिनिधित्व करता है (किसी भी टूल को उठाने और उपयोग करने का मानकीकृत तरीका)।

इस ट्यूटोरियल में, हम ADK का उपयोग करके एक वास्तविक लॉजिस्टिक्स रिकवरी एजेंट बनाएंगे। एजेंट यह करेगा:

1. BigQuery से उच्च-प्राथमिकता वाले विलंबित ऑर्डर क्वेरी करना। 
2. Google Maps MCP सर्वर का उपयोग करके वेयरहाउस से ग्राहक तक की वास्तविक ड्राइविंग दूरी की गणना करना। 
3. रिकवरी एक्शन की सिफारिश करना, जैसे लंबी दूरी की शिपमेंट के लिए एयर शिपिंग में अपग्रेड करना।

यह सब बिना एक भी लाइन कस्टम API कोड लिखे होता है। एजेंट स्वचालित रूप से टूल्स खोजता और उपयोग करता है।

Google Cloud में नए हैं? मैं सुझाव देता हूँ कि आप बिलिंग, प्रोजेक्ट्स और बेसिक सर्विसेज को कवर करने के लिए मुफ्त Introduction to GCP कोर्स से शुरुआत करें।

Google ADK क्या है?

Google Agent Development Kit (ADK) Google का ओपन-सोर्स, कोड-फ़र्स्ट फ़्रेमवर्क है जो AI एजेंट बनाने, टेस्ट करने और डिप्लॉय करने के लिए बना है। जहाँ LangChain जैसे फ़्रेमवर्क चेन पर फोकस करते हैं, ADK एक्जीक्यूशन के लिए बनाया गया है। यह एजेंट कैसे सोचते हैं, टूलसेट्स का उपयोग करते हैं, और प्रोडक्शन एनवायरनमेंट में चलते हैं—इसके लिए मानकीकृत संरचना देता है।

मुख्य अवधारणाएँ:

• Agents: कोर एंटिटी जो अपने मॉडल (जैसे, Gemini 2.0 Flash) और विशिष्ट निर्देशों के सेट से परिभाषित होती है।
• Toolsets: क्षमताओं का संग्रह। टूल्स को मैन्युअली परिभाषित करने के बजाय, हम ADK को किसी MCP सर्वर की ओर इंगित करते हैं, और यह स्वतः टूल्स "सीख" लेता है।
• Runners: एग्जीक्यूशन इंजन जो कन्वर्सेशन स्टेट और क्रमिक "सोच-कार्रवाई-प्रेक्षण" लूप को मैनेज करता है।

यह कोड-फ़र्स्ट तरीका हमें वर्ज़न कंट्रोल, टेस्टिंग और CI/CD वैसा ही उपयोग करने देता है जैसा हम सामान्य सॉफ़्टवेयर के साथ करते हैं। यह गूगल के साथ गहरा इंटीग्रेशन भी देता है, यानी मैनेज्ड MCP सर्वर के साथ BigQuery या Maps के लिए लगभग कोई डिप्लॉयमेंट नहीं चाहिए।

“बिग थ्री” क्लाउड प्रदाताओं और उनकी सेवाओं की तुलना के लिए, हमारा गाइड AWS बनाम Azure बनाम Google Cloud ज़रूर देखें।

Google ADK इंटीग्रेशन आर्किटेक्चर और लॉजिक फ्लो

हमारा लॉजिस्टिक्स रिकवरी एजेंट किसी बिज़नेस समस्या को हल करने के लिए एक स्पष्ट विचार-धारा का पालन करता है। इस फ्लो को समझना बाद में प्रॉम्प्ट निर्देश लिखते समय मदद करता है।

रीज़निंग लूप ये चरण अपनाता है:

1. एजेंट BigQuery MCP को कॉल करता है ताकि वे पंक्तियाँ ढूँढ़े जहाँ status='Delayed' और priority='High' हो। 

2. हर रिटर्न हुए ऑर्डर के लिए, एजेंट वेयरहाउस और ग्राहक के पते निकालता है। 

3. हर ऑर्डर के लिए ड्राइव दूरी की गणना करने हेतु एजेंट Google Maps MCP को कॉल करता है। 

4. एजेंट बिज़नेस लॉजिक लागू करता है (उदा., 500 मील से अधिक दूरी का मतलब एयर शिपिंग) और सिफारिशों की एक मार्कडाउन तालिका प्रस्तुत करता है।

MCP सर्वर सेट करना

कोड लिखना शुरू करने से पहले, हमें अंतर्निहित क्लाउड इंफ्रास्ट्रक्चर तैयार करना होगा और MCP सर्वर तैयार करने होंगे। मेरे अनुभव में, इस चरण में IAM परमिशन सही सेट करना सबसे महत्वपूर्ण भाग है।

चरण 1: Google Cloud CLI इनिशियलाइज़ करना 

पहले सुनिश्चित करें कि आपके पास Google Cloud CLI इंस्टॉल है। शुरू करने के लिए, अपना टर्मिनल खोलें और अपने लोकल एनवायरनमेंट को अपने Google अकाउंट से लिंक करने हेतु निम्न कमांड चलाएँ:

gcloud initसंचालित द्वारा

जैसे ही आप इसे चलाते हैं, एक ब्राउज़र विंडो अपने आप खुलेगी। आपको अपने Google अकाउंट से साइन इन करने के लिए कहा जाएगा। साइन इन करने के बाद, CLI को आपके संसाधनों को प्रबंधित करने की अनुमति देने के लिए Allow पर क्लिक करें। 

टर्मिनल पर वापस, प्रॉम्प्ट आपसे डिफ़ॉल्ट प्रोजेक्ट चुनने को कहेगा। यदि आपने पहले से एक बनाया है, तो प्रोजेक्ट का ID चुनें, या टर्मिनल में नया प्रोजेक्ट बनाएँ।

चरण 2: बिलिंग सेट करना

API सेवाओं का उपयोग करने के लिए, आपको बिलिंग सेट करनी होगी। ऐसा कहते हुए, Google Cloud आपको Compute, GKE और Maps जैसी सेवाएँ आज़माने के लिए 90 दिनों के लिए $300 का मुफ्त क्रेडिट देता है, और इस ट्यूटोरियल के उदाहरण के लिए वे क्रेडिट पर्याप्त से अधिक हैं। आपको केवल तभी चार्ज किया जाएगा जब आप पे-एज़-यू-गो या प्रीपे चालू करते हैं। बिलिंग सेट करने के लिए:

1. Google Console बिलिंग पेज पर जाएँ और उस अकाउंट से साइन इन करें जिसे आप gcloud के लिए उपयोग करते हैं।

2. यदि आपके पास बिलिंग अकाउंट नहीं है, तो एक बनाएँ (पेमेंट मेथड जोड़ना आवश्यक है, लेकिन पहले फ्री क्रेडिट लागू होते हैं)।

3. बिलिंग अकाउंट को अपने प्रोजेक्ट से लिंक करें: Billing → Link a project → अपना प्रोजेक्ट चुनें, या चलाएँ:

gcloud billing projects link YOUR_PROJECT_ID --billing-account=BILLING_ACCOUNT_IDसंचालित द्वारा

चरण 3: कोर APIs और MCP सेवाएँ सक्षम करना

अब हमें प्राथमिक उत्पाद APIs सक्षम करनी हैं। ये एजेंट को BigQuery और Maps जैसी रॉ डेटा सेवाओं तक पहुँचने देती हैं।

gcloud services enable bigquery.googleapis.com
gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com
gcloud services enable mapstools.googleapis.comसंचालित द्वारा

अब, हमें Managed MCP Endpoints सक्षम करने होंगे। मुझे यह इन्हें सामान्य APIs के ऊपर बैठी अनुवादक इंटरफ़ेस की तरह समझना उपयोगी लगा। 

पहले, आपके प्रोजेक्ट ID और अकाउंट ईमेल को एनवायरनमेंट वेरिएबल्स में स्टोर करें। इससे हमें हर अगले कमांड में इन्हें मैन्युअल रूप से टाइप नहीं करना पड़ेगा:

export PROJECT_ID=$(gcloud config get-value project)
export USER_EMAIL=$(gcloud config get-value account)संचालित द्वारा

इन वेरिएबल्स के सेट होने के साथ, अपने विशिष्ट प्रोजेक्ट के लिए बीटा MCP फीचर्स चालू करने हेतु निम्न कमांड चलाएँ। ये कमांड Google को आपके एजेंट द्वारा कॉल किए जाने के लिए रिमोट MCP एंडपॉइंट तैयार करने के लिए कहते हैं:

gcloud beta services mcp enable bigquery.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable mapstools.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable container.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable compute.googleapis.com --project=$PROJECT_IDसंचालित द्वारा

चरण 3: IAM और Maps Keys कॉन्फ़िगर करना 

MCP "डुअल-लेयर" सुरक्षा मॉडल का उपयोग करता है। आपको MCP सर्वर से बात करने की अनुमति और वास्तविक डेटा (जैसे टेबल की पंक्तियाँ) तक पहुँचने की अलग अनुमति चाहिए। आप इसे gcloud CLI या Google Cloud Console UI के माध्यम से कर सकते हैं।

IAM विकल्प A: gcloud CLI का उपयोग 

अपने अकाउंट को MCP उपयोग करने और BigQuery से इंटरैक्ट करने की अनुमति देने के लिए ये तीन कमांड चलाएँ:

# Permission to talk to the MCP Translator
gcloud projects add-iam-policy-binding $PROJECT_ID --member="user:$USER_EMAIL" --role="roles/mcp.toolUser"

# Permissions to run BigQuery jobs and view data
gcloud projects add-iam-policy-binding $PROJECT_ID --member="user:$USER_EMAIL" --role="roles/bigquery.jobUser"
gcloud projects add-iam-policy-binding $PROJECT_ID --member="user:$USER_EMAIL" --role="roles/bigquery.dataViewer"संचालित द्वारा

IAM विकल्प B: Google Cloud Console (UI) का उपयोग

यदि आप विज़ुअल इंटरफ़ेस पसंद करते हैं, तो ब्राउज़र में ये चरण फ़ॉलो कर सकते हैं:

1. अपने Google Cloud Console में IAM & Admin पेज पर जाएँ।
2. सूची में अपना ईमेल पता ढूँढ़ें और Edit Member (पेंसिल) आइकन पर क्लिक करें।
3. Add Another Role पर क्लिक करें और MCP Tool User खोजें।
4. इसी प्रक्रिया को दोहराकर BigQuery Data Viewer और BigQuery Job User जोड़ें।
5. Save पर क्लिक करें।

Maps API key बनाएँ

आखिर में, एक Maps API key बनाएँ। BigQuery के विपरीत, जो आपके लॉगिन क्रेडेंशियल्स का उपयोग करता है, Maps MCP सर्वर बिलिंग और कोटा ट्रैकिंग के लिए इस key का उपयोग करता है: 

gcloud alpha services api-keys create --display-name="Maps-MCP-Key"संचालित द्वारा

चरण 4: MCP Inspector के साथ स्थानीय रूप से सर्वर वैलिडेट करना

Python कोड लिखने से पहले, हमें MCP Inspector का उपयोग करके एक sanity check करना चाहिए। हम npx कमांड का उपयोग करेंगे, जो Node.js के साथ आता है। 

इसका उद्देश्य आपको किसी पैकेज (जैसे इंस्पेक्टर) को तुरंत रन करने देना है, बिना उसे अपने कंप्यूटर पर स्थायी रूप से इंस्टॉल किए। टर्मिनल में यह चलाएँ:

npx @modelcontextprotocol/inspectorसंचालित द्वारा

यह आपके ब्राउज़र में एक वेब इंटरफ़ेस लॉन्च करेगा (आम तौर पर http://localhost:3000 पर)। मैंने नीचे सेटअप सूची में विशिष्ट विकल्प इसलिए चुने ताकि हम Google के सर्वरों के Remote Managed संस्करण का परीक्षण करें, न कि कोई स्थानीय मॉक:

1. Transport type: Streamable HTTP. हम इसे चुनते हैं क्योंकि यह मैनेज्ड क्लाउड सर्वरों के लिए Google द्वारा उपयोग किया जाने वाला प्रोडक्शन-स्टैंडर्ड प्रोटोकॉल है।

2. URL: https://mapstools.googleapis.com/mcp दर्ज करें। यह Google के Maps MCP का डायरेक्ट फ्रंट डोर है।

3. Connection Type: via Proxy. यह एक महत्वपूर्ण विकल्प है। "Proxy" चुनने पर इंस्पेक्टर आपकी स्थानीय gcloud लॉगिन का उपयोग करके सभी जटिल सुरक्षा हैंडशेक अपने-आप संभाल लेगा।

4. Custom Headers: X-Goog-Api-Key जोड़ें और चरण 3 से अपनी key पेस्ट करें।

5. Connect पर क्लिक करें।

अब आपको हरे रंग का Connected स्टेटस दिखना चाहिए। सर्वर द्वारा दी जाने वाली हर क्षमता की सूची देखने के लिए List Tools बटन पर क्लिक करें। यदि आपको उस सूची में compute_routes दिखता है, तो आपका इंफ्रास्ट्रक्चर बिल्कुल सही कॉन्फ़िगर है।

यह समझने के लिए कि अपने एजेंट्स के लिए BigQuery, Maps और अन्य Google सेवाओं का उपयोग कैसे करें, इस ट्यूटोरियल Google MCP Servers को ज़रूर देखें।

Google ADK के साथ MCP सर्वर एजेंट बनाना

इन्फ्रास्ट्रक्चर तैयार होने के बाद, अब हम अपने लोकल डेवलपमेंट एनवायरनमेंट पर बढ़ सकते हैं। हम अपने प्रोजेक्ट फ़ाइलों को व्यवस्थित करने से शुरू करेंगे।

चरण 1: प्रोजेक्ट संरचना और डिपेंडेंसी सेट करना

शुरू करने के लिए, अपने प्रोजेक्ट के लिए एक फ़ोल्डर बनाएँ और एक वर्चुअल एनवायरनमेंट सेट करें।

mkdir my-agents
cd my-agents
python -m venv .venv
source .venv/bin/activateसंचालित द्वारा

ऊपर दी गई अंतिम कमांड macOS या Linux उपयोगकर्ताओं के लिए है; यदि आप Windows उपयोग कर रहे हैं, तो इसके बजाय .venv\Scripts\activate का उपयोग करें।

इसके बाद, आप google-adk पैकेज को इसकी सपोर्टिंग लाइब्रेरीज़ के साथ इंस्टॉल कर सकते हैं।

pip install google-adk google-generativeai python-dotenv httpx  google-authसंचालित द्वारा

एक और काम आपको करना है—अपने रूट फ़ोल्डर में .env फ़ाइल बनाकर उसमें अपना PROJECT_ID और पिछले चरण में जनरेट की गई MAPS_API_KEY स्टोर करें।

चरण 2: MCP टूलसेट्स कॉन्फ़िगर करना

tools.py नाम की स्क्रिप्ट में, हम "डेटा पाने" का कोड नहीं लिख रहे हैं। इसके बजाय, हम ऐसे सर्वर से कनेक्ट होने का कोड लिख रहे हैं जो डेटा पाना जानता है। 

मैंने पाया कि टूल्स को लॉजिक से अलग करना प्रोजेक्ट को डिबग करना बहुत सरल बनाता है। क्योंकि हम रिमोट Google Cloud एंडपॉइंट्स से बात कर रहे हैं, हम ऑथेंटिकेशन हेडर्स संभालने के लिए StreamableHTTPConnectionParams का उपयोग करते हैं।

import os
import google.auth
import google.auth.transport.requests
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams 

# --- BigQuery Toolset ---
def get_bigquery_mcp_toolset():   
    credentials, project_id = google.auth.default(
        scopes=["https://www.googleapis.com/auth/bigquery"]
    )
    credentials.refresh(google.auth.transport.requests.Request())
        
    return MCPToolset(
        connection_params=StreamableHTTPConnectionParams(
            url="https://bigquery.googleapis.com/mcp",
            headers={
                "Authorization": f"Bearer {credentials.token}",
                # 'x-goog-user-project' is vital for BigQuery billing
                "x-goog-user-project": project_id,
                "Content-Type": "application/json"
            }
        )
    )

# --- Maps Toolset ---
def get_maps_mcp_toolset():
    maps_api_key = os.getenv('MAPS_API_KEY')
    
    return MCPToolset(
        connection_params=StreamableHTTPConnectionParams(
            url="https://mapstools.googleapis.com/mcp",
            headers={
                "X-Goog-Api-Key": maps_api_key,
                "Content-Type": "application/json"
            }
        )
    )संचालित द्वारा

चरण 3: एजेंट का मिशन परिभाषित करना

अब हम "मस्तिष्क" बनाते हैं। मेरे अनुभव में, यहाँ Gemini Flash मॉडलों में से किसी एक का उपयोग सबसे अच्छा विकल्प है क्योंकि वे टूल-कॉलिंग में बेहद तेज़ हैं। 

हम agent.py फ़ाइल में दिए निर्देशों के माध्यम से एजेंट को एक स्टैंडर्ड ऑपरेटिंग प्रोसीजर देते हैं। देखें कि हम एजेंट को भ्रमित होने से बचाने के लिए कैसे एक स्पष्ट, चार-चरण पाइपलाइन का उपयोग करते हैं।

from .tools import get_maps_mcp_toolset, get_bigquery_mcp_toolset
from google.adk.agents import LlmAgent

# We're giving the agent a very structured 'Instruction' set. 
# Think of this as the SOP (Standard Operating Procedure) for your agent.
root_agent = LlmAgent(
    model='gemini-2.0-flash',
    name='logistics_recovery_agent',
    instruction="""
      You are an expert Retail Operations Recovery Agent. 
      Your job is to find high-priority problems and solve them using the tools provided.

      Step 1: Use 'execute_sql' to find orders where status is 'Delayed' and priority is 'High'.
      Step 2: For every result, pull the warehouse and customer addresses.
      Step 3: Call the Maps 'compute_routes' tool to find the exact drive distance.
      Step 4: Use this logic: If distance > 500 miles, recommend 'Air Shipping'. 
            Otherwise, recommend 'Regional Express Ground'.
    
      Output the final result as a clean Markdown table.
    """,
    # We simply drop our toolsets here. 
    # ADK handles the complexity of deciding which tool to call when.
    tools=[get_maps_mcp_toolset(), get_bigquery_mcp_toolset()]
)संचालित द्वारा

चरण 4: एजेंट लूप चलाना 

एजेंट चलाने के लिए, हम रनर का उपयोग करते हैं। यह कंपोनेंट कन्वर्सेशन स्टेट पर नज़र रखता है ताकि एजेंट जान सके कि उसने क्या कर लिया है और आगे क्या करना है।

from google.adk.runners import Runner
from google.genai import types

async def main():
    # The Runner acts as the host for our agent.
    runner = Runner(app_name="logistics_app", agent=root_agent)

    # Wrap the user input in the standard GenAI Content format
    user_input = "Identify high-priority delayed orders and suggest recovery shipping methods."
    content = types.Content(role="user", parts=[types.Part(text=user_input)])

    print("--- Starting Smart Logistics Agent ---")
    
    # We use run_async to stream the 'events' (Thoughts and Tool Calls)
    async for event in runner.run_async(user_id="admin_user", new_message=content):
        # We only want to print the text part of the response to the console
        if hasattr(event, 'content') and event.content.parts:
            print(event.content.parts[0].text)संचालित द्वारा

पर्दे के पीछे क्या होता है?

जब आप runner.run_async कॉल करते हैं, तो ADK एक क्रमिक लूप शुरू करता है:

1. Gemini सोचता है: "मुझे पहले विलंबित ऑर्डर देखने हैं।"

2. ADK कार्य करता है: यह आपके BigQuery MCP टूलसेट से execute_sql टूल को कॉल करता है।

3. प्रेक्षण: टूल ऑर्डर डेटा लौटाता है।

4. Gemini सोचता है: "अब मुझे इन दो ऑर्डर्स के लिए दूरी चाहिए।"

5. ADK कार्य करता है: यह Maps MCP टूल को दो बार कॉल करता है।

6. अंतिम प्रतिक्रिया: Gemini सारा डेटा देखता है, आपके "500-माइल" लॉजिक को लागू करता है, और तालिका को फ़ॉर्मेट करता है।

वेब कंसोल में हमारे Google ADK एजेंट का परीक्षण

टर्मिनल लॉग्स के लिए बेहतरीन है, लेकिन ADK में एक बिल्ट-इन वेब कंसोल भी है जो एजेंट की आंतरिक रीज़निंग को विज़ुअलाइज़ करता है। डिबगिंग के लिए मुझे यह सबसे उपयोगी टूल लगा।

इंटरफ़ेस लॉन्च करने के लिए adk web चलाएँ। सर्वर शुरू होने के बाद, अपने ब्राउज़र में http://127.0.0.1:8000 खोलें। आपको एक साफ, चैट-जैसा इंटरफ़ेस दिखेगा जहाँ आप यह कमांड भेज सकते हैं: "उच्च-प्राथमिकता वाले विलंबित ऑर्डर की पहचान करें और रिकवरी शिपिंग विधियाँ सुझाएँ।"

एक्जीक्यूशन ट्रेस का विश्लेषण

ADK कंसोल यह दिखाने के लिए पारदर्शी "ट्रेस" देता है कि एजेंट आपके क्लाउड इंफ्रास्ट्रक्चर से ठीक-ठीक कैसे इंटरैक्ट कर रहा है।

आइए इसे चरण-दर-चरण तोड़ें:

1. टूल हैंडशेक्स: execute_sql और compute_routes लेबल वाले आइकन्स पर ध्यान दें। ट्रेस में, बिजली का निशान टूल इनवोकेशन दर्शाता है। एजेंट ने बस अंदाज़ा नहीं लगाया; उसने आपके ऑर्डर्स टेबल पर एक विशिष्ट SQL क्वेरी चलाने के लिए वास्तव में BigQuery MCP सर्वर से संपर्क किया।

2. अनुक्रमिक लॉजिक: ट्रेस में ऑपरेशंस का स्पष्ट क्रम दिखता है। पहले यह BigQuery के जरिए डेटा लाता है (पहला चेकमार्क)। एक बार वेयरहाउस और ग्राहक पते मिल जाने पर, आप कई compute_routes कॉल देखते हैं। एजेंट विलंबित ऑर्डर्स पर बुद्धिमानी से "लूप" कर रहा है ताकि Maps MCP सर्वर से वास्तविक दुनिया की दूरी का डेटा मिल सके।

3. अंतिम संश्लेषण: ट्रेस के निचले हिस्से में अंतिम प्रतिक्रिया दिखाई देती है।

डेटा देखें:

• ORD-101: दूरी 380 मील है।
• ORD-103: दूरी 352 मील है।

क्योंकि हमने एजेंट को यह लॉजिक दिया: "यदि दूरी > 500 मील है, तो Air Shipping की सिफारिश करें, अन्यथा Regional Express Ground," एजेंट ने दोनों ऑर्डर्स पर सही ढंग से यह बिज़नेस रूल लागू किया और उन्हें एक सुंदर Markdown तालिका में फ़ॉर्मेट किया।

निष्कर्ष

हमने BigQuery या Google Maps के लिए एक भी लाइन कस्टम API कोड लिखे बिना एक फ़ंक्शनल लॉजिस्टिक्स एजेंट बनाया। ADK और MCP का उपयोग करके, हमने एक ऐसी आर्किटेक्चर बनाई जो मॉड्यूलर, सुरक्षित और डेवलपर-फ़र्स्ट है।

AI का भविष्य केवल बात करने वाले चैटबॉट्स के बारे में नहीं, बल्कि ऐसे एजेंट्स के बारे में है जो कार्रवाई करते हैं। इन टूल्स के साथ, हम आखिरकार उस हकीकत की ओर बढ़ रहे हैं।

यह ट्यूटोरियल Google ADK और MCP सर्वर्स के साथ आपके प्रयोग के लिए एक बेहतरीन शुरुआती बिंदु हो सकता है: 

• डेटा सोर्स बदलने की सहजता देखने के लिए BigQuery की जगह कोई अलग डेटासेट (या कोई लोकल SQLite MCP सर्वर) आज़माएँ।
• प्लग-एंड-प्ले प्रकृति साबित करने के लिए Maps को किसी अन्य MCP सर्वर (उदा., क्लस्टर हेल्थ चेक्स के लिए GKE) से बदलें।
• प्रॉम्प्ट में और बिज़नेस लॉजिक जोड़ें (कॉस्ट तुलना, ईमेल ड्राफ्ट) और इसे ADK वेब UI में लाइव टेस्ट करें।

यदि आप एजेंट ऑर्केस्ट्रेशन के बारे में और सीखना चाहते हैं, तो मैं हमारे करियर ट्रैक Associate AI Engineer for Developers में नामांकन करने की अत्यधिक सिफारिश करता/करती हूँ।