Google की Agent Development Kit (ADK): डेमो प्रोजेक्ट के साथ मार्गदर्शिका

प्रोजेक्ट ओवरव्यू: ADK और A2A के साथ AI-संचालित ट्रैवल प्लानर

यह प्रोजेक्ट एक ट्रैवल प्लानर बनाता है जो:

• गंतव्य, तारीखें और बजट को इनपुट के रूप में लेता है।
• तीन अलग-अलग एजेंट्स को कॉल करता है:
• flight_agent:  फ्लाइट विकल्प सुझाता है।
• stay_agent: बजट के भीतर होटल ढूंढता है।
• activities_agent: रोचक गतिविधियाँ सुझाता है।
• फिर, सभी रिक्वेस्ट्स को ऑर्केस्ट्रेट करने के लिए एक केंद्रीय host_agent का उपयोग करता है।
• अंत में, उपयोगकर्ता इंटरैक्शन के लिए Streamlit UI का उपयोग करता है।

सभी एजेंट्स अलग-अलग FastAPI सर्वर के रूप में होस्ट किए गए हैं और एक /run एंडपॉइंट एक्सपोज़ करते हैं। संचार साझा A2A-कम्पैटिबल क्लाइंट के जरिए होता है।

नोट: सरलता के लिए यह प्रोजेक्ट पूरी तरह आपकी लोकल मशीन पर चलता है, लेकिन आप प्रत्येक एजेंट और UI को Render, Railway, या Google Cloud Run जैसी क्लाउड प्लेटफ़ॉर्म्स पर आसानी से डिप्लॉय कर सकते हैं ताकि स्केलेबल एक्सेस मिल सके।

स्टेप 1: पूर्वापेक्षाएँ

आइए निम्नलिखित लाइब्रेरीज़ इंस्टॉल करके शुरू करें:

pip install google-adk litellm fastapi uvicorn httpx pydantic openai streamlitसंचालित द्वारा

फिर, अपना OpenAI API key सेट करें—आप किसी अन्य मॉडल प्रदाता का उपयोग करने के लिए स्वतंत्र हैं। OpenAI का API key सेट करने का तरीका सीखने के लिए, मैं GPT-4o API पर यह शुरुआती ट्यूटोरियल सुझाता/सुझाती हूं।

export OPENAI_API_KEY="your_key_here"संचालित द्वारा

स्टेप 2: साझा स्कीमा और यूटिलिटीज़

बुद्धिमान एजेंट बनाने से पहले, हमें उनके लिए आपस में बात करने की एक साझा भाषा परिभाषित करनी होगी। हमारे सेटअप में, यह निम्न के जरिए होता है:

• इनपुट के लिए साझा स्कीमा (Pydantic के जरिए परिभाषित)
• एजेंट्स को कॉल करने के लिए REST क्लाइंट यूटिलिटी
• सभी एजेंट्स में /run एंडपॉइंट को मानकीकृत करने के लिए REST सर्वर रैपर

कोड को मॉड्यूलर रखने के लिए इन्हें shared/ और common/ फोल्डर्स में रखा जाता है। आइए एक-एक करके देखें।

एक shared/schemas.py फ़ाइल बनाना

हम Pydantic का उपयोग करके एक TravelRequest स्कीमा परिभाषित करते हैं। यह सुनिश्चित करता है कि सभी एजेंट्स इनकमिंग रिक्वेस्ट्स की स्ट्रक्चर पर सहमत हों, जिसमें गंतव्य, यात्रा की तिथियाँ और उपयोगकर्ता बजट शामिल हैं।

from pydantic import BaseModel
class TravelRequest(BaseModel):
    destination: str
    start_date: str
    end_date: str
    budget: floatसंचालित द्वारा

यह क्लास इन बातों में मदद करता है:

• सभी एजेंट्स के लिए इनपुट को सुसंगत रखना।
• FastAPI के साथ स्वचालित वैलिडेशन जोड़ना।
• कोड री-यूज़ को सरल बनाना।

एक common/a2a_client.py फ़ाइल बनाना

यह हल्की-फुल्की async यूटिलिटी किसी भी एजेंट (विशेषकर होस्ट) को /run एंडपॉइंट कॉल करके A2A प्रोटोकॉल का उपयोग करते हुए दूसरे एजेंट को इनवोक करने देती है।

import httpx
async def call_agent(url, payload):
    async with httpx.AsyncClient() as client:
        response = await client.post(url, json=payload, timeout=60.0)
        response.raise_for_status()
        return response.json()संचालित द्वारा

यह यूटिलिटी httpx का उपयोग कर दूसरे एजेंट के /run एंडपॉइंट पर असिंक्रोनस POST रिक्वेस्ट भेजती है। यह पार्स किया हुआ JSON रिस्पॉन्स लौटाती है और रिक्वेस्ट असफल होने पर त्रुटि उठाती है।

हम इस यूटिलिटी का उपयोग अपने होस्ट एजेंट में flight_agent, stay_agent और activities_agent को कॉल करने के लिए करेंगे।

एक common/a2a_server.py फ़ाइल बनाना

प्रत्येक एजेंट के लिए कस्टम FastAPI रूट लिखने की बजाय, हम इसे create_app(agent) फ़ंक्शन के जरिए सामान्यीकृत करते हैं, जो निम्न को संभालता है:

• /run पर एजेंट को सर्व करना
• यात्रा रिक्वेस्ट प्राप्त करना
• स्ट्रक्चर्ड रिस्पॉन्स लौटाना

from fastapi import FastAPI
import uvicorn
def create_app(agent):
    app = FastAPI()
    @app.post("/run")
    async def run(payload: dict):
        return await agent.execute(payload)
    return appसंचालित द्वारा

यह यूटिलिटी एक मानक /run रूट के साथ FastAPI ऐप बनाती है जो दिए गए एजेंट को निष्पादन डेलीगेट करती है। यह स्ट्रक्चर्ड JSON इनपुट का उपयोग करते हुए सभी सेवाओं के लिए सुसंगत एजेंट-टू-एजेंट (A2A) इंटरफेस सुनिश्चित करती है।

साथ मिलकर, ये साझा कॉम्पोनेंट्स हमारे मल्टी-एजेंट सिस्टम को अधिक मेंटेन करने योग्य, पुन: प्रयोज्य और Google की A2A फिलॉसफ़ी—सरल, स्ट्रक्चर्ड इंटर-एजेंट मैसेजिंग—के अनुरूप बनाते हैं।

स्टेप 3: ADK और A2A के साथ मल्टी-एजेंट सिस्टम बनाना

अब जब हमारे पास साझा कॉन्ट्रैक्ट्स और यूटिलिटीज़ मौजूद हैं, तो आइए व्यक्तिगत एजेंट्स बनाना शुरू करें। इसे वास्तव में मॉड्यूलर और मल्टी-एजेंट सिस्टम में बदलने के लिए, हम Google के A2A प्रोटोकॉल—एक सरल HTTP-आधारित इंटरफेस—का उपयोग करेंगे जो एजेंट्स को सुसंगत और इंटरऑपरेबल तरीके से संवाद करने देता है।

A2A (Agent-to-Agent) एजेंट्स के बीच प्लग-एंड-प्ले कोऑर्डिनेशन सक्षम करता है, चाहे वे लोकल Python फंक्शंस हों या नेटवर्क्स पर होस्टेड। प्रत्येक एजेंट एक सामान्य स्कीमा के साथ /run एंडपॉइंट एक्सपोज़ करता है और एक सेवा की तरह कार्य करता है।

हमारे डेमो में चार एजेंट्स हैं:

• host_agent: अन्य सभी एजेंट्स को ऑर्केस्ट्रेट करता है
• flight_agent: उपयुक्त फ्लाइट ढूंढता है
• stay_agent: ठहरने के विकल्प सुझाता है
• activities_agent: स्थानीय गतिविधियों में शामिल होने की सिफारिश करता है

सभी एजेंट्स समान रूप से संरचित हैं, 3 फाइलों और एक सबफोल्डर के साथ:

agents/
├── host_agent/
│   │   ├── agent.py              # Optional if host logic is minimal
│   │   ├── task_manager.py       # Calls other agents and aggregates responses
│   │   ├── __main__.py           # Starts FastAPI app via common/a2a_server.py
│   │   └── .well-known/
│   │       └── agent.json        # A2A Agent Card metadata
├── flight_agent/
├── stay_agent/
└── activities_agent/संचालित द्वारा

हर एजेंट google.adk.agents.Agent, एक LiteLlm मॉडल रैपर, और निष्पादन के लिए Runner का उपयोग करता है। activities_agent फोल्डर के भीतर निम्न फाइलें बनाकर शुरू करें, और यही प्रक्रिया flight_agent और stay_agent के लिए दोहराएँ।

एक agent.py फ़ाइल बनाना

अब हम अपने activities_agent की लॉजिक परिभाषित करते हैं, जो उपयोगकर्ता की यात्रा योजना के आधार पर रोचक स्थानीय अनुभव उत्पन्न करने के लिए जिम्मेदार होगा। 

स्टेप 1: इम्पोर्ट्स

हम अपने एजेंट को कॉन्फ़िगर और चलाने के लिए आवश्यक मॉड्यूल इम्पोर्ट करके शुरू करते हैं।

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
import jsonसंचालित द्वारा

यह एजेंट Google ADK के कॉम्पोनेंट्स जैसे Agent, ' Runner, ' और LiteLlm का उपयोग करता है और InMemorySessionService के जरिए स्टेट मैनेजमेंट संभालता है। Types लाइब्रेरी स्ट्रक्चर्ड प्रॉम्प्ट्स बनाने के लिए उपयोग होती है।

स्टेप 2: एक्टिविटीज़ एजेंट 

अब, हम ADK की Agent क्लास का उपयोग करके एजेंट को ही इंस्टैंशिएट करते हैं।

activities_agent = Agent(
    name="activities_agent",
    model=LiteLlm("openai/gpt-4o"),
    description="Suggests interesting activities for the user at a destination.",
    instruction=(
        "Given a destination, dates, and budget, suggest 2-3 engaging tourist or cultural activities. "
        "For each activity, provide a name, a short description, price estimate, and duration in hours. "
        "Respond in plain English. Keep it concise and well-formatted."
    )
)संचालित द्वारा

instruction पैरामीटर वह सिस्टम प्रॉम्प्ट परिभाषित करता है जो LLM के व्यवहार को निर्देशित करता है। भले ही इस उदाहरण में सामान्य अंग्रेज़ी का उपयोग किया गया है, आप आसान पार्सिंग के लिए instruction को स्ट्रक्चर्ड JSON वापस करने हेतु समायोजित कर सकते हैं।

स्टेप 3: सेशन मैनेजमेंट

इसके बाद, उपयोगकर्ता इंटरैक्शंस का ट्रैक रखने के लिए, हम सेशन जानकारी के साथ Runner कॉन्फ़िगर करते हैं।

session_service = InMemorySessionService()
runner = Runner(
    agent=activities_agent,
    app_name="activities_app",
    session_service=session_service
)
USER_ID = "user_activities"
SESSION_ID = "session_activities"संचालित द्वारा

Runner किसी विशेष ऐप सेशन के लिए एजेंट निष्पादन को मैनेज करता है। वहीं InMemorySessionService क्लास संदर्भ को मेमोरी में स्टोर करता है। फिर, हम यूज़र और सेशन IDs परिभाषित करते हैं। हालांकि, प्रोडक्शन में ये डायनेमिक या यूज़र-विशिष्ट हो सकते हैं। यह सुनिश्चित करता है कि LLM एजेंट को कोई प्रॉम्प्ट भेजने से पहले एक नया ADK सेशन मौजूद हो।

स्टेप 4: एजेंट लॉजिक को निष्पादित करना

execute() फ़ंक्शन इनकमिंग रिक्वेस्ट्स को हैंडल करता है, प्रॉम्प्ट बनाता है, मॉडल को इनवोक करता है और आउटपुट पार्स करता है।

async def execute(request):
    session_service.create_session(
        app_name="activities_app",
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    prompt = (
        f"User is flying to {request['destination']} from {request['start_date']} to {request['end_date']}, "
        f"with a budget of {request['budget']}. Suggest 2-3 activities, each with name, description, price estimate, and duration. "
        f"Respond in JSON format using the key 'activities' with a list of activity objects."
    )
    message = types.Content(role="user", parts=[types.Part(text=prompt)])
    async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=message):
        if event.is_final_response():
            response_text = event.content.parts[0].text
            try:
                parsed = json.loads(response_text)
                if "activities" in parsed and isinstance(parsed["activities"], list):
                    return {"activities": parsed["activities"]}
                else:
                    print("'activities' key missing or not a list in response JSON")
                    return {"activities": response_text}  # fallback to raw text
            except json.JSONDecodeError as e:
                print("JSON parsing failed:", e)
                print("Response content:", response_text)
                return {"activities": response_text}  # fallback to raw textसंचालित द्वारा

execute() फ़ंक्शन इनकमिंग रिक्वेस्ट पैरामीटर्स—जैसे गंतव्य, तारीखें और बजट—का उपयोग करके डायनेमिक रूप से प्रॉम्प्ट बनाता है। अंदरखाने यह होता है:

• प्रॉम्प्ट मॉडल को गतिविधियों की सूची समेटे हुए एक स्ट्रक्चर्ड JSON ऑब्जेक्ट लौटाने का निर्देश देता है।
• एक Content ऑब्जेक्ट बनाया जाता है और ADK Runner को पास किया जाता है, जो स्ट्रीमिंग जेनरेटर का उपयोग कर असिंक्रोनस रूप से मॉडल के अंतिम रिस्पॉन्स की प्रतीक्षा करता है।
• जब अंतिम रिस्पॉन्स मिल जाता है, एजेंट कच्चे टेक्स्ट आउटपुट को निकालता है और उसे JSON के रूप में पार्स करने का प्रयास करता है।
• यदि पार्सिंग सफल होती है और अपेक्षित activities कुंजी मौजूद होती है, तो स्ट्रक्चर्ड डेटा लौटाया जाता है।
• यदि कुंजी गुम है या विकृत है, तो फॉलबैक के रूप में रॉ टेक्स्ट लौटाया जाता है ताकि UI के पास फिर भी उपयोगी आउटपुट हो।
• यह डुअल-हैंडलिंग दृष्टिकोण तब भी सहज अनुभव सुनिश्चित करता है जब LLM स्ट्रक्चर्ड JSON की बजाय सादा टेक्स्ट लौटाता है।

यह रणनीति मज़बूती और उपयोगकर्ता अनुभव में सुधार करती है, खासकर जब मॉडल आउटपुट तापमान या प्रॉम्प्ट व्याख्या के कारण थोड़ा-बहुत भिन्न हो सकते हैं।

एक task_manager.py फ़ाइल बनाना

agent.py के अंदर execute() लॉजिक परिभाषित करने के बाद, अब हम इसे task_manager.py का उपयोग करके ADK-कम्पैटिबल सर्वर सेटअप में वायर करते हैं।

from .agent import execute
async def run(payload):
    return await execute(payload)संचालित द्वारा

यह फ़ाइल पहले परिभाषित execute() फ़ंक्शन के चारों ओर एक पतला रैपर का काम करती है। यह run() मेथड को बाहरी मॉड्यूल्स—खासकर __main__.py में सर्वर स्क्रिप्ट—के लिए उपलब्ध कराती है।

एक __main__.py फ़ाइल बनाना

__main__.py फ़ाइल पोर्ट 8003 पर एक FastAPI सर्वर लॉन्च करती है, जो एजेंट को /run एंडपॉइंट पर सर्व करती है।

from common.a2a_server import create_app
from .task_manager import run
app = create_app(agent=type("Agent", (), {"execute": run}))
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, port=8003)संचालित द्वारा

यहाँ क्या हो रहा है:

• create_app() (common/a2a_server.py से) हमारे एजेंट को एक मानक A2A-कम्पैटिबल FastAPI इंटरफेस में रैप करता है।
• हम डायनेमिक रूप से एक ऐसा ऑब्जेक्ट बनाते हैं जिसमें execute() मेथड हो ताकि ADK, run() को ठीक से इनवोक कर सके।
• यह पृथक्करण हमें स्टेटलेस API इंटरफेसेज़ बनाए रखने देता है, जबकि कोर एजेंट लॉजिक को री-यूज़ किया जाता है।

एक .well-known/agent.json फ़ाइल बनाना

हम इस JSON फ़ाइल का उपयोग A2A (Agent-to-Agent) प्रोटोकॉल के अनुरूप एजेंट की पहचान और उद्देश्य बताने के लिए करते हैं।

{
    "name": "activity_agent",
    "description": "Agent providing activity details."
  }संचालित द्वारा

नोट: भले ही इस प्रोजेक्ट में हमारे एजेंट्स द्वारा .well-known/agent.json फ़ाइल का सीधे उपयोग नहीं होता, यह A2A स्पेसिफिकेशन का पालन करती है और LangGraph, CrewAI या Google के एजेंट रजिस्ट्री जैसे ऑर्केस्ट्रेटर्स के साथ डिस्कवरी, इंट्रोस्पेक्शन और भविष्य की कम्पैटिबिलिटी के लिए महत्वपूर्ण है।

इसी तरह की लॉजिक flight_agent और stay_agent के लिए भी उपयोग होती है।

स्टेप 4: host_agent के साथ समन्वय

host_agent डेमो के लिए एक केंद्रीय प्लानर के रूप में कार्य करता है। host_agent मल्टी-एजेंट सिस्टम्स में कंट्रोलर पैटर्न का उदाहरण देता है। यह निर्णय-निर्माण और निष्पादन को अलग करता है, जिससे प्रत्येक डाउनस्ट्रीम एजेंट अपने विशेष क्षेत्र पर ध्यान दे सके, जबकि समन्वय लॉजिक केंद्रीकृत रहता है। यह न केवल टेस्टिंग और स्केलिंग को सरल बनाता है, बल्कि वितरित सिस्टम्स में वास्तविक दुनिया के माइक्रोसर्विस आर्किटेक्चर को भी प्रतिबिंबित करता है।

यह तीनों एजेंट्स को उनके एक्सपोज़्ड /run APIs का उपयोग करते हुए समान payload भेजता है और परिणामों को मर्ज करता है। आइए host_agent फोल्डर में निम्न फाइलें जोड़ें।

एक agent.py फ़ाइल बनाना

बेसिक इम्पोर्ट्स से शुरू करते हैं।

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import typesसंचालित द्वारा

यह इम्पोर्ट ब्लॉक Google ADK का उपयोग करके LLM-आधारित एजेंट को परिभाषित और चलाने के लिए आवश्यक सभी कोर बिल्डिंग ब्लॉक्स लाता है: Agent क्लास, लाइटवेट LLM रैपर, निष्पादन संभालने के लिए Runner, और इन-मेमोरी सेशन मैनेजमेंट।

host_agent = Agent(
    name="host_agent",
    model=LiteLlm("openai/gpt-4o"),
    description="Coordinates travel planning by calling flight, stay, and activity agents.",
    instruction="You are the host agent responsible for orchestrating trip planning tasks. "
                "You call external agents to gather flights, stays, and activities, then return a final result."
)
session_service = InMemorySessionService()
runner = Runner(
    agent=host_agent,
    app_name="host_app",
    session_service=session_service
)
USER_ID = "user_host"
SESSION_ID = "session_host"संचालित द्वारा

ऊपर का कोड पूर्ण ट्रिप प्लान कोऑर्डिनेट करने के लिए जिम्मेदार टॉप-लेवल ADK एजेंट परिभाषित करता है। भले ही इस इम्प्लीमेंटेशन में हम LLM से सब-एजेंट्स को इनवोक नहीं करते, सिस्टम प्रॉम्प्ट भविष्य के ऐसे एक्सटेंशन के लिए भूमिका तय करता है जहाँ LLM संभावित रूप से टूल-यूज़ और मेटा-रीज़निंग संभाल सकता है।

async def execute(request):
    # Ensure session exists
    session_service.create_session(
        app_name="host_app",
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    prompt = (
        f"Plan a trip to {request['destination']} from {request['start_date']} to {request['end_date']} "
        f"within a total budget of {request['budget']}. Call the flights, stays, and activities agents for results."
    )
    message = types.Content(role="user", parts=[types.Part(text=prompt)])
    async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=message):
        if event.is_final_response():
            return {"summary": event.content.parts[0].text}संचालित द्वारा

यह execute() फ़ंक्शन होस्ट एजेंट के LLM के मुख्य एंट्री प्वाइंट के रूप में कार्य करता है। यह:

• एक सेशन इनिशियलाइज़ करता है (आवश्यक होने पर मेमोरी सपोर्ट के लिए)
• डायनेमिक रूप से यूज़र प्रॉम्प्ट बनाता है
• ADK के runner.run_async() मेथड का उपयोग करके इसे मॉडल को भेजता है
• अंततः, अंतिम रिस्पॉन्स की प्रतीक्षा करता है और उसे एक्सट्रैक्ट करता है

एक task_manager.py फ़ाइल बनाना

टास्क मैनेजर रिमोट एजेंट्स को कॉल करके और पूर्ण ट्रिप-प्लानिंग वर्कफ़्लो को हैंडल करके ऑर्केस्ट्रेशन लॉजिक निष्पादित करता है। व्यावहारिक इम्प्लीमेंटेशन के लिए, हम प्रत्येक चाइल्ड एजेंट के लिए सर्विस URLs परिभाषित करते हैं। ये एंडपॉइंट्स A2A /run प्रोटोकॉल का पालन करते हैं और साझा TravelRequest` JSON स्कीमा की अपेक्षा करते हैं।

from common.a2a_client import call_agent
FLIGHT_URL = "http://localhost:8001/run"
STAY_URL = "http://localhost:8002/run"
ACTIVITIES_URL = "http://localhost:8003/run"संचालित द्वारा

अब, हम payload परिभाषित करते हैं।

async def run(payload):
    #Print what the host agent is sending
    print("Incoming payload:", payload)
    flights = await call_agent(FLIGHT_URL, payload)
    stay = await call_agent(STAY_URL, payload)
    activities = await call_agent(ACTIVITIES_URL, payload)
    # Log outputs
    print("flights:", flights)
    print("stay:", stay)
    print("activities:", activities)
    # Ensure all are dicts before access
    flights = flights if isinstance(flights, dict) else {}
    stay = stay if isinstance(stay, dict) else {}
    activities = activities if isinstance(activities, dict) else {}
    return {
        "flights": flights.get("flights", "No flights returned."),
        "stay": stay.get("stays", "No stay options returned."),
        "activities": activities.get("activities", "No activities found.")
    }संचालित द्वारा

यह फ़ंक्शन call_agent() हेल्पर का उपयोग करके payload को प्रत्येक डाउनस्ट्रीम सेवा तक भेजता है और डेवलपमेंट के दौरान दृश्यता के लिए इनपुट और आउटपुट लॉग करता है। वास्तव में यही वह फ़ाइल है जहाँ सच्चा ऑर्केस्ट्रेशन लॉजिक रहता है।

एक __main__.py फ़ाइल बनाना

__main__.py फ़ाइल उस FastAPI सर्वर के एंट्री प्वाइंट के रूप में कार्य करती है जो होस्ट एजेंट को रैप करता है। 

from common.a2a_server import create_app
from .task_manager import run
app = create_app(agent=type("Agent", (), {"execute": run}))
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, port=8000)संचालित द्वारा

मुख्य फ़ाइल यह करती है:

• यह common/a2a_server.py की create_app() का उपयोग करके एक मानकीकृत /run एंडपॉइंट के साथ FastAPI एप्लिकेशन जनरेट करती है।
• फिर, यह execute() मेथड वाले एक सरल एजेंट-जैसे ऑब्जेक्ट को पास करती है जो आंतरिक रूप से task_manager.run() फ़ंक्शन को डेलीगेट करता है।
• अंत में, यह निर्दिष्ट पोर्ट (आमतौर पर 8000) पर uvicorn का उपयोग करके FastAPI सर्वर शुरू करती है।

यह होस्ट एजेंट के इंटरफेस को अन्य डाउनस्ट्रीम एजेंट्स के साथ संरेखित करता है, जिससे सिस्टम भर में सुसंगतता बनी रहती है।

एक .well-known/agent.json फ़ाइल बनाना

यह फ़ाइल एक क्लासिक मल्टी-एजेंट पैटर्न की तरह कार्य करती है जहाँ एक केंद्रीय नोड कार्यों को डेलीगेट और कंपोज़ करता है। 

{
  "name": "host_agent",
  "description": "Coordinates travel planning among specialized agents."
}संचालित द्वारा

यद्यपि वैकल्पिक है, जैसा पहले समझाया गया, इसे सभी एजेंट डायरेक्टरीज़ में शामिल करना एक उत्कृष्ट अभ्यास है।

स्टेप 5: Streamlit के साथ UI बनाना

अंततः, आइए एक सरल ऐप बनाते हैं जहाँ उपयोगकर्ता अपनी प्राथमिकताएँ दर्ज कर सकें और एक स्ट्रक्चर्ड यात्रा कार्यक्रम प्राप्त कर सकें। रूट डायरेक्टरी में एक travel_ui.py फ़ाइल बनाकर निम्न कोड इसमें जोड़ें।

import streamlit as st
import requestsसंचालित द्वारा

हम UI सपोर्ट के लिए Streamlit और requests जैसी बेसिक लाइब्रेरीज़ इम्पोर्ट करते हैं।

st.set_page_config(page_title="ADK-Powered Travel Planner", page_icon="✈️")
st.title("🌍 ADK-Powered Travel Planner")
origin = st.text_input("Where are you flying from?", placeholder="e.g., New York")
destination = st.text_input("Destination", placeholder="e.g., Paris")
start_date = st.date_input("Start Date")
end_date = st.date_input("End Date")
budget = st.number_input("Budget (in USD)", min_value=100, step=50)
if st.button("Plan My Trip ✨"):
    if not all([origin, destination, start_date, end_date, budget]):
        st.warning("Please fill in all the details.")
    else:
        payload = {
            "origin": origin,
            "destination": destination,
            "start_date": str(start_date),
            "end_date": str(end_date),
            "budget": budget
        }
        response = requests.post("http://localhost:8000/run", json=payload)
        if response.ok:
            data = response.json()
            st.subheader("✈️ Flights")
            st.markdown(data["flights"])
            st.subheader("🏨 Stays")
            st.markdown(data["stay"])
            st.subheader("🗺️ Activities")
            st.markdown(data["activities"])
        else:
            st.error("Failed to fetch travel plan. Please try again.")संचालित द्वारा

Streamlit ऐप, ADK का उपयोग करके बने मल्टी-एजेंट ट्रैवल प्लानर के साथ इंटरैक्ट करने के लिए एक उपयोगकर्ता-अनुकूल UI प्रदान करता है। ऊपर दिए गए कोड में हम कुछ बातों पर ध्यान देते हैं।

• यह origin, destination, तारीखें और बजट इकट्ठा करने के लिए text_input, date_input और number_input का उपयोग करता है।
• “Plan My Trip” पर क्लिक करने पर, यह सुनिश्चित करने के लिए इनपुट वैलिडेट करता है कि कोई फ़ील्ड खाली न रहे।
• यदि वैध है, तो यह एक JSON payload बनाता है और http://localhost:8000/run. पर host_agent को POST रिक्वेस्ट भेजता है।
• host_agent सभी चाइल्ड एजेंट्स (फ्लाइट, स्टे, एक्टिविटी) को इनवोक करता है, उनके रिस्पॉन्सेज को एग्रीगेट करता है और एक एकीकृत ट्रैवल प्लान लौटाता है।
• रिस्पॉन्स को पार्स करके फ्लाइट्स, स्टेज़ और एक्टिविटीज़ के अलग-अलग हेडर्स के अंतर्गत st.markdown() के जरिए प्रदर्शित किया जाता है।
• यदि बैकएंड विफल होता है, तो st.error() के जरिए एक फॉलबैक त्रुटि संदेश दिखाया जाता है।

अब, अपनी टर्मिनल पर लोकली निम्न कमांड चलाएँ:

uvicorn agents.host_agent.__main__:app --port 8000 &
uvicorn agents.flight_agent.__main__:app --port 8001 &
uvicorn agents.stay_agent.__main__:app --port 8002 &      
uvicorn agents.activities_agent.__main__:app --port 8003 &
streamlit run travel_ui.pyसंचालित द्वारा

जब उपयोगकर्ता “Plan My Trip” पर क्लिक करता/करती है, तो होस्ट एजेंट नियंत्रण संभाल लेता है, एजेंट्स को सक्रिय करता है और UI में परिणाम दिखाता है:

आपकी समग्र फ़ाइल संरचना कुछ इस तरह दिखेगी:

ADK_demo/
├── agents/
│   ├── host_agent/
│   │   ├── agent.py              
│   │   ├── task_manager.py      
│   │   ├── __main__.py         
│   │   └── .well-known/
│   │       └── agent.json   
│   │
│   ├── flight_agent/
│   │   ├── agent.py        
│   │   ├── task_manager.py    
│   │   ├── __main__.py         
│   │   └── .well-known/
│   │       └── agent.json        
│   │
│   ├── stay_agent/
│   │   ├── agent.py              
│   │   ├── task_manager.py       
│   │   ├── __main__.py           
│   │   └── .well-known/
│   │       └── agent.json     
│   │
│   └── activities_agent/
│       ├── agent.py              
│       ├── task_manager.py       
│       ├── __main__.py           
│       └── .well-known/
│           └── agent.json       
│
├── common/
│   ├── a2a_client.py             # Utility to send requests to other agents
│   └── a2a_server.py             # Shared FastAPI A2A-compatible server template
│
├── shared/
│   └── schemas.py                # Shared Pydantic schema
│
├── streamlit_app.py             # Frontend UI for user input and response rendering
├── requirements.txt           
└── README.md                    संचालित द्वारा

और बस! मैंने जो कुछ भी हमने बनाया है, उसे इस GitHub प्रोजेक्ट में इकट्ठा कर दिया है।

निष्कर्ष

सिर्फ कुछ FastAPI ऐप्स और ADK एजेंट्स के साथ, हमने एक सहयोगी ट्रैवल प्लानर बनाया जो:

• A2A प्रोटोकॉल के जरिए संचार करता है
• फ्लाइट, स्टे और एक्टिविटीज़ के लिए LLM एजेंट्स का उपयोग करता है
• नतीजों को साफ-सुथरे Streamlit UI में एकत्रित कर दिखाता है

भले ही सभी एजेंट्स भीतरखाने एक ही मॉडल का उपयोग करते हों, यह सिस्टम व्यवहार में मल्टी-एजेंट है—यानी एजेंट्स की भूमिकाएँ अलग-अलग हैं, ज़िम्मेदारियाँ पृथक हैं और संचार स्ट्रक्चर्ड है।

शुरू करने के लिए कुछ संसाधन यहाँ हैं:

• A2A GitHub
• ADK के साथ वेदर बॉट बनाएं
• A2A तकनीकी डाक्यूमेंटेशन