मल्टी-एजेंट सिस्टम बनाना

1. परिचय

इस लैब में, आपको सामान्य चैटबॉट से आगे बढ़कर, डिस्ट्रिब्यूट किया गया मल्टी-एजेंट सिस्टम बनाना होगा.

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

आपको कोर्स बनाने का एक सिस्टम तैयार करना होगा. इसमें ये शामिल होंगे:

  • रिसर्चर एजेंट: ताज़ा जानकारी पाने के लिए, google_search का इस्तेमाल करना.
  • जज एजेंट: रिसर्च की क्वालिटी और पूरी जानकारी के लिए उसकी आलोचना करना.
  • कॉन्टेंट बिल्डर एजेंट: रिसर्च को व्यवस्थित कोर्स में बदलना.
  • ऑर्केस्ट्रेटर एजेंट: यह एजेंट, वर्कफ़्लो और इन विशेषज्ञों के बीच बातचीत को मैनेज करता है.

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

  • वेब पर खोज करने वाले टूल का इस्तेमाल करने वाले एजेंट (रिसर्चर) को तय करें.
  • जज के लिए, Pydantic की मदद से स्ट्रक्चर्ड आउटपुट लागू करें.
  • Agent-to-Agent (A2A) प्रोटोकॉल का इस्तेमाल करके, रिमोट एजेंट से कनेक्ट करें.
  • रिसर्चर और जज के बीच फ़ीडबैक लूप बनाने के लिए, LoopAgent बनाएं.
  • ADK का इस्तेमाल करके, डिस्ट्रिब्यूट किए गए सिस्टम को स्थानीय तौर पर चलाएं.
  • मल्टी-एजेंट सिस्टम को Google Cloud Run पर डिप्लॉय करें.
  • कॉन्टेंट बिल्डर एजेंट के लिए, Cloud Run के जीपीयू पर Gemma मॉडल का इस्तेमाल करें.

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

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

2. आर्किटेक्चर और ऑर्केस्ट्रेशन के सिद्धांत

सबसे पहले, यह समझते हैं कि ये एजेंट एक साथ कैसे काम करते हैं. हम कोर्स बनाने की पाइपलाइन तैयार कर रहे हैं.

सिस्टम डिज़ाइन

आर्किटेक्चर डायग्राम

एजेंट की मदद से ऑर्केस्ट्रेशन करना

स्टैंडर्ड एजेंट (जैसे, रिसर्चर) काम करते हैं. ऑर्केस्ट्रेटर एजेंट (जैसे, LoopAgent या SequentialAgent) अन्य एजेंट मैनेज करते हैं. उनके पास अपने टूल नहीं होते. उनका "टूल" काम सौंपना होता है.

  1. LoopAgent: यह कोड में while लूप की तरह काम करता है. यह किसी शर्त के पूरा होने या ज़्यादा से ज़्यादा इटरेशन तक पहुंचने तक, एजेंट के क्रम को बार-बार चलाता है. हम इसका इस्तेमाल रिसर्च लूप के लिए करते हैं:
    • रिसर्चर को जानकारी मिलती है.
    • जज इसकी समीक्षा करता है.
    • अगर Judge "Fail" कहता है, तो EscalationChecker लूप को जारी रखने देता है.
    • अगर जज "पास" कहता है, तो EscalationChecker लूप को तोड़ देता है.
  2. SequentialAgent: यह स्टैंडर्ड स्क्रिप्ट के तौर पर काम करता है. यह एक के बाद एक एजेंट को चलाता है. हम इसका इस्तेमाल हाई-लेवल पाइपलाइन के लिए करते हैं:
    • सबसे पहले, रिसर्च लूप को तब तक चलाएं, जब तक कि यह अच्छे डेटा के साथ पूरा न हो जाए.
    • इसके बाद, कोर्स लिखने के लिए Content Builder का इस्तेमाल करें.

इन दोनों को मिलाकर, हम एक ऐसा मज़बूत सिस्टम बनाते हैं जो फ़ाइनल आउटपुट जनरेट करने से पहले, खुद ही गड़बड़ियों को ठीक कर सकता है.

3. सेटअप

प्रोजेक्ट सेटअप करना

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

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

Cloud Shell शुरू करना

Cloud Shell, Google Cloud में चलने वाला एक कमांड-लाइन एनवायरमेंट है. इसमें ज़रूरी टूल पहले से लोड होते हैं.

  1. Google Cloud कंसोल में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.
  2. Cloud Shell से कनेक्ट होने के बाद, अपने क्रेडेंशियल की पुष्टि करें:
    gcloud auth list
  3. पुष्टि करें कि आपका प्रोजेक्ट कॉन्फ़िगर किया गया है:
    gcloud config get project
  4. अगर आपका प्रोजेक्ट उम्मीद के मुताबिक सेट नहीं है, तो इसे सेट करें:
    export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

एनवायरमेंट सेटअप करना

  1. Cloud Shell खोलें: Google Cloud Console में सबसे ऊपर दाईं ओर मौजूद, Cloud Shell चालू करें आइकॉन पर क्लिक करें.

स्टार्टर कोड पाना

  1. स्टार्टर रिपॉज़िटरी को अपनी होम डायरेक्ट्री में क्लोन करें:अपनी होम डायरेक्ट्री में जाएं
      cd ~
    Google Cloud DevRel Demos फ़ोल्डर से, इस कोडलैब के लिए ज़रूरी कोड को क्लोन करें.
    git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git temp-repo && cd temp-repo && git sparse-checkout set agents/multi-agent-system && cd .. && mv temp-repo/agents/multi-agent-system . && rm -rf temp-repo
    उस फ़ोल्डर में जाएं जिसमें इस कोडलैब का कोड मौजूद है
    cd multi-agent-system
  2. एपीआई चालू करें: ज़रूरी Google Cloud सेवाएं चालू करने के लिए, यह कमांड चलाएं:
    gcloud services enable \
    run.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com
  3. इस फ़ोल्डर को अपने एडिटर में खोलें.
    cloudshell edit .

सेटअप एनवायरमेंट

  1. एनवायरमेंट वैरिएबल सेट अप करें. हम इन वैरिएबल को सेव करने के लिए, .env फ़ाइल बनाएंगे. इससे सेशन बंद होने पर, इन्हें आसानी से फिर से लोड किया जा सकेगा.
    cat <<EOF > .env
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=europe-west4
export GOOGLE_GENAI_USE_VERTEXAI=true
EOF
  2. एनवायरमेंट वैरिएबल सोर्स करें:
    source .env

4. 🕵️ रिसर्चर एजेंट

रिसर्चर एजेंट

रिसर्चर एक विशेषज्ञ होता है. इसका काम सिर्फ़ जानकारी ढूंढना है. इसके लिए, इसे एक टूल का ऐक्सेस चाहिए: Google Search.

रिसर्चर को अलग क्यों किया गया है?

ज़्यादा जानकारी: एक ही एजेंट से सभी काम क्यों नहीं कराए जाते?

छोटे और फ़ोकस किए गए एजेंटों का आकलन और डीबग करना आसान होता है. अगर रिसर्च सही नहीं है, तो रिसर्चर के प्रॉम्प्ट में बदलाव करो. अगर कोर्स का फ़ॉर्मैट सही नहीं है, तो कॉन्टेंट बिल्डर का इस्तेमाल करके उसे ठीक करें. "सब कुछ करने वाले" एक ही प्रॉम्प्ट में, किसी एक चीज़ को ठीक करने से अक्सर दूसरी चीज़ खराब हो जाती है.

  1. अगर Cloud Shell में काम किया जा रहा है, तो Cloud Shell एडिटर खोलने के लिए, यह कमांड चलाएं:
    cloudshell workspace .
  2. agents/researcher/agent.py खोलें.
  3. researcher एजेंट को तय करने वाला यह कोड देखें:
    # ... existing imports ...

# Define the Researcher Agent
researcher = Agent(
    name="researcher",
    model=MODEL,
    description="Gathers information on a topic using Google Search.",
    instruction="""
    You are an expert researcher. Your goal is to find comprehensive and accurate information on the user's topic.
    Use the `google_search` tool to find relevant information.
    Summarize your findings clearly.
    If you receive feedback that your research is insufficient, use the feedback to refine your next search.
    """,
    tools=[google_search],
)

root_agent = researcher

मुख्य कॉन्सेप्ट: टूल का इस्तेमाल

हम tools=[google_search] को नोटिस भेजते हैं. ADK, LLM को इस टूल के बारे में बताने की जटिलता को हैंडल करता है. जब मॉडल को लगता है कि उसे जानकारी की ज़रूरत है, तब वह स्ट्रक्चर्ड टूल कॉल जनरेट करता है. इसके बाद, एडीके Python फ़ंक्शन google_search को लागू करता है और नतीजे को वापस मॉडल को भेजता है.

5. ⚖️ जज एजेंट

जज एजेंट

रिसर्चर कड़ी मेहनत करता है, लेकिन एलएलएम सुस्त हो सकते हैं. काम की समीक्षा करने के लिए, हमें जज की ज़रूरत है. जज, रिसर्च को स्वीकार करता है और पास/फ़ेल का आकलन करके जवाब देता है.

स्ट्रक्चर्ड आउटपुट

ज़्यादा जानकारी: वर्कफ़्लो को ऑटोमेट करने के लिए, हमें अनुमानित आउटपुट की ज़रूरत होती है. टेक्स्ट की लंबी-चौड़ी समीक्षा को प्रोग्राम के हिसाब से पार्स करना मुश्किल होता है. Pydantic का इस्तेमाल करके, JSON स्कीमा लागू करने से यह पक्का किया जाता है कि Judge, बूलियन pass या fail वैल्यू देता है. इस वैल्यू के आधार पर हमारा कोड भरोसेमंद तरीके से काम कर सकता है.

  1. agents/judge/agent.py खोलें.
  2. JudgeFeedback स्कीमा और judge एजेंट के बारे में बताने वाले इस कोड की समीक्षा करें.
    # 1. Define the Schema
class JudgeFeedback(BaseModel):
    """Structured feedback from the Judge agent."""
    status: Literal["pass", "fail"] = Field(
        description="Whether the research is sufficient ('pass') or needs more work ('fail')."
    )
    feedback: str = Field(
        description="Detailed feedback on what is missing. If 'pass', a brief confirmation."
    )

# 2. Define the Agent
judge = Agent(
    name="judge",
    model=MODEL,
    description="Evaluates research findings for completeness and accuracy.",
    instruction="""
    You are a strict editor.
    Evaluate the 'research_findings' against the user's original request.
    If the findings are missing key info, return status='fail'.
    If they are comprehensive, return status='pass'.
    """,
    output_schema=JudgeFeedback,
    # Disallow delegation because it should only output the schema
    disallow_transfer_to_parent=True,
    disallow_transfer_to_peers=True,
)

root_agent = judge

मुख्य कॉन्सेप्ट: एजेंट के व्यवहार को सीमित करना

हम disallow_transfer_to_parent=True और disallow_transfer_to_peers=True सेट करते हैं. इससे जज को सिर्फ़ स्ट्रक्चर्ड JudgeFeedback वापस करने के लिए मजबूर किया जाता है. यह उपयोगकर्ता के साथ "चैट" करने या किसी दूसरे एजेंट को काम सौंपने का फ़ैसला नहीं कर सकता. इससे यह हमारे लॉजिक फ़्लो में एक डिटरमिनिस्टिक कॉम्पोनेंट बन जाता है.

6. ✍️ कॉन्टेंट बिल्डर एजेंट

कॉन्टेंट बिल्डर

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

आइए, सबसे पहले उस Cloud Run सेवा को देखें जो मॉडल को होस्ट करती है

  1. ollama_backend/Dockerfile खोलें
  2. यहां देखा जा सकता है कि Dockerfile, Ollama इमेज का इस्तेमाल कैसे करता है, पोर्ट 8080 पर अनुरोधों को कैसे सुनता है, और अनुरोध किए गए मॉडल को /model फ़ोल्डर में कैसे सेव करता है.
FROM ollama/ollama:latest

# Listen on all interfaces, port 8080 (Cloud Run default)
ENV OLLAMA_HOST 0.0.0.0:8080

# Store model weight files in /models
ENV OLLAMA_MODELS /models

⚙️ डिप्लॉय करते समय, आपको ये कॉन्फ़िगरेशन सेट करने होंगे:

  • जीपीयू: NVIDIA L4 को चुना गया है. यह अनुमान लगाने से जुड़े वर्कलोड के लिए, कीमत और परफ़ॉर्मेंस के हिसाब से सबसे अच्छा जीपीयू है. L4 में 24 जीबी जीपीयू मेमोरी और ऑप्टिमाइज़ किए गए टेंसर ऑपरेशन होते हैं. इसलिए, यह 27 करोड़ पैरामीटर वाले मॉडल के लिए सबसे सही है. जैसे, Gemma
  • मेमोरी: मॉडल को लोड करने, CUDA ऑपरेशनों को मैनेज करने, और Ollama की मेमोरी को मैनेज करने के लिए 16 जीबी सिस्टम मेमोरी
  • सीपीयू: बेहतर I/O हैंडलिंग और प्रीप्रोसेसिंग टास्क के लिए 8 कोर
  • कॉन्करेंसी: हर इंस्टेंस के लिए चार अनुरोधों से, जीपीयू मेमोरी के इस्तेमाल के साथ थ्रूपुट को बैलेंस किया जाता है
  • टाइम आउट: 600 सेकंड, शुरुआती मॉडल लोडिंग और कंटेनर स्टार्टअप के लिए तय किया गया है

अब हम कॉन्टेंट बिल्डर एजेंट के बारे में जानते हैं, जो Gemma मॉडल का इस्तेमाल करता है.

  1. agents/content_builder/agent.py खोलें.
  2. content_builder एजेंट को तय करने वाला यह कोड देखें.
# the `ollama-gemma-gpu` Cloud Run service URL which hosts the Gemma model
target_url = os.environ.get("OLLAMA_API_BASE")

# ... existing code ...

# (Note: We use 'ollama/gemma3:270m' to align with ADK's expected prefix)
gemma_model_name = os.environ.get("GEMMA_MODEL_NAME", "gemma3:270m")
model = LiteLlm(
    model=f"ollama_chat/{gemma_model_name}",
    api_base=target_url
)

# 5. Define the Agent
content_builder = Agent(
    name="content_builder",
    model=model,
    description="Transforms research findings into a structured course.",
    instruction="""
    You are an expert course creator.
    Take the approved 'research_findings' and transform them into a well-structured, engaging course module.

    **Formatting Rules:**
    1. Start with a main title using a single `#` (H1).
    2. Use `##` (H2) for main section headings. These will be used for the Table of Contents.
    3. Use `###` (H3) for sub-sections within main sections.
    4. Use bullet points and clear paragraphs.
    5. Maintain a professional but engaging tone.

    **Structure Requirements:**
    - Begin with a brief Introduction section explaining what the learner will gain.
    - Organize content into 3-5 main sections with clear headings.
    - Include Key Takeaways at the end as a bulleted summary.
    - Keep each section focused and concise.

    Ensure the content directly addresses the user's original request.
    Do not include any preamble or explanation outside the course content itself.
    """,
)

root_agent = content_builder

मुख्य कॉन्सेप्ट: कॉन्टेक्स्ट प्रोपगेशन

आपके मन में यह सवाल आ सकता है कि "कॉन्टेंट बिल्डर को यह कैसे पता चलता है कि रिसर्चर ने क्या खोजा है?" ADK में, पाइपलाइन में मौजूद एजेंट session.state शेयर करते हैं. बाद में, Orchestrator में हम Researcher और Judge को कॉन्फ़िगर करेंगे, ताकि वे अपने आउटपुट को इस शेयर की गई स्थिति में सेव कर सकें. Content Builder के प्रॉम्प्ट के पास इस इतिहास का ऐक्सेस होता है.

7. 🎻 ऑर्केस्ट्रेटर

ऑर्केस्ट्रेटर एजेंट

ऑर्केस्ट्रेटर, हमारी मल्टी-एजेंट टीम का मैनेजर होता है. विशेषज्ञ एजेंट (रिसर्चर, जज, कॉन्टेंट बिल्डर) खास टास्क पूरे करते हैं. हालांकि, ऑर्केस्ट्रेटर का काम वर्कफ़्लो को मैनेज करना और यह पक्का करना है कि उनके बीच जानकारी सही तरीके से शेयर हो.

🌐 आर्किटेक्चर: एजेंट-टू-एजेंट (A2A)

A2A आर्किटेक्चर

इस लैब में, हम डिस्ट्रिब्यूटेड सिस्टम बना रहे हैं. हम सभी एजेंट को एक ही Python प्रोसेस में चलाने के बजाय, उन्हें स्वतंत्र माइक्रोसेवाओं के तौर पर डिप्लॉय करते हैं. इससे हर एजेंट को अलग-अलग स्केल करने और पूरे सिस्टम को क्रैश किए बिना काम न करने की अनुमति मिलती है.

इसके लिए, हम Agent-to-Agent (A2A) प्रोटोकॉल का इस्तेमाल करते हैं.

A2A प्रोटोकॉल

ज़्यादा जानकारी: प्रोडक्शन सिस्टम में, एजेंट अलग-अलग सर्वर (या अलग-अलग क्लाउड) पर काम करते हैं. A2A प्रोटोकॉल, उन्हें एचटीटीपी पर एक-दूसरे को खोजने और उनसे बातचीत करने का एक स्टैंडर्ड तरीका उपलब्ध कराता है. RemoteA2aAgent, इस प्रोटोकॉल के लिए एडीके क्लाइंट है.

  1. agents/orchestrator/agent.py खोलें.
  2. कनेक्शन तय करने वाले इस कोड की समीक्षा करें.
    # ... existing code ...

# Connect to the Researcher (Localhost port 8001)
researcher_url = os.environ.get("RESEARCHER_AGENT_CARD_URL", "http://localhost:8001/a2a/agent/.well-known/agent-card.json")
researcher = RemoteA2aAgent(
    name="researcher",
    agent_card=researcher_url,
    description="Gathers information using Google Search.",
    # IMPORTANT: Save the output to state for the Judge to see
    after_agent_callback=create_save_output_callback("research_findings"),
    # IMPORTANT: Use authenticated client for communication
    httpx_client=create_authenticated_client(researcher_url)
)

# Connect to the Judge (Localhost port 8002)
judge_url = os.environ.get("JUDGE_AGENT_CARD_URL", "http://localhost:8002/a2a/agent/.well-known/agent-card.json")
judge = RemoteA2aAgent(
    name="judge",
    agent_card=judge_url,
    description="Evaluates research.",
    after_agent_callback=create_save_output_callback("judge_feedback"),
    httpx_client=create_authenticated_client(judge_url)
)

# Content Builder (Localhost port 8003)
content_builder_url = os.environ.get("CONTENT_BUILDER_AGENT_CARD_URL", "http://localhost:8003/a2a/agent/.well-known/agent-card.json")
content_builder = RemoteA2aAgent(
    name="content_builder",
    agent_card=content_builder_url,
    description="Builds the course.",
    httpx_client=create_authenticated_client(content_builder_url)
)

8. 🛑 एस्केलेशन चेकर

लूप को रोकने का कोई तरीका होना चाहिए. अगर जज "पास" कहता है, तो हमें लूप से तुरंत बाहर निकलना है और कॉन्टेंट बिल्डर पर जाना है.

BaseAgent के साथ कस्टम लॉजिक

ज़्यादा जानकारी: सभी एजेंट, एलएलएम का इस्तेमाल नहीं करते. कभी-कभी आपको सामान्य Python लॉजिक की ज़रूरत होती है. BaseAgent की मदद से, सिर्फ़ कोड चलाने वाला एजेंट तय किया जा सकता है. इस मामले में, हम सेशन की स्थिति की जांच करते हैं और EventActions(escalate=True) को रोकने के लिए, EventActions(escalate=True) का इस्तेमाल करते हैं.LoopAgent

  1. अब भी agents/orchestrator/agent.py में है.
  2. नीचे दिए गए कोड में, जज के सुझावों की समीक्षा की जाती है. इसके बाद, अगले चरण पर जाया जाता है
    class EscalationChecker(BaseAgent):
    """Checks the judge's feedback and escalates (breaks the loop) if it passed."""

    async def _run_async_impl(
        self, ctx: InvocationContext
    ) -> AsyncGenerator[Event, None]:
        # Retrieve the feedback saved by the Judge
        feedback = ctx.session.state.get("judge_feedback")
        print(f"[EscalationChecker] Feedback: {feedback}")

        # Check for 'pass' status
        is_pass = False
        if isinstance(feedback, dict) and feedback.get("status") == "pass":
            is_pass = True
        # Handle string fallback if JSON parsing failed
        elif isinstance(feedback, str) and '"status": "pass"' in feedback:
            is_pass = True

        if is_pass:
            # 'escalate=True' tells the parent LoopAgent to stop looping
            yield Event(author=self.name, actions=EventActions(escalate=True))
        else:
            # Continue the loop
            yield Event(author=self.name)

escalation_checker = EscalationChecker(name="escalation_checker")

मुख्य कॉन्सेप्ट: इवेंट के ज़रिए कंट्रोल फ़्लो

एजेंट, सिर्फ़ टेक्स्ट से नहीं, बल्कि इवेंट से भी कम्यूनिकेट करते हैं. escalate=True के साथ इवेंट को यिल्ड करके, यह एजेंट अपने पैरंट (LoopAgent) को एक सिग्नल भेजता है. LoopAgent को इस सिग्नल को पकड़ने और लूप को खत्म करने के लिए प्रोग्राम किया गया है.

9. 🔁 रिसर्च लूप

रिसर्च लूप

हमें एक फ़ीडबैक लूप की ज़रूरत है: रिसर्च -> जज -> (फ़ेल) -> रिसर्च -> ...

  1. agents/orchestrator/agent.py में.
  2. यहां दिए गए कोड में, research_loop की परिभाषा के बारे में बताया गया है. इसे देखें.
    research_loop = LoopAgent(
    name="research_loop",
    description="Iteratively researches and judges until quality standards are met.",
    sub_agents=[researcher, judge, escalation_checker],
    max_iterations=3,
)

मुख्य कॉन्सेप्ट: LoopAgent

LoopAgent, अपने sub_agents को क्रम से दिखाता है.

  1. researcher: डेटा ढूंढता है.
  2. judge: डेटा का आकलन करता है.
  3. escalation_checker: यह तय करता है कि yield Event(escalate=True) है या नहीं. अगर escalate=True होता है, तो लूप जल्दी खत्म हो जाता है. अगर ऐसा नहीं होता है, तो यह रिसर्चर (max_iterations तक) के लिए फिर से शुरू हो जाता है.

10. 🔗 फ़ाइनल पाइपलाइन

फ़ाइनल पाइपलाइन

पूरी जानकारी को एक जगह इकट्ठा किया जा रहा है....

  1. agents/orchestrator/agent.py में.
  2. फ़ाइल के सबसे नीचे, root_agent की परिभाषा देखें.
    root_agent = SequentialAgent(
    name="course_creation_pipeline",
    description="A pipeline that researches a topic and then builds a course from it.",
    sub_agents=[research_loop, content_builder],
)

मुख्य कॉन्सेप्ट: हैरारकीकल कंपोज़िशन

ध्यान दें कि research_loop खुद एक एजेंट (LoopAgent) है. हम इसे SequentialAgent में मौजूद किसी अन्य सब-एजेंट की तरह ही मानते हैं. इस कंपोज़ेबिलिटी की मदद से, आसान पैटर्न (सीक्वेंस के अंदर लूप, राउटर के अंदर सीक्वेंस वगैरह) को नेस्ट करके, जटिल लॉजिक बनाया जा सकता है.

11. 🚀 Cloud Run पर डिप्लॉय करना

हम हर एजेंट को Cloud Run पर एक अलग सेवा के तौर पर डिप्लॉय करेंगे. इसमें कोर्स बनाने वाले व्यक्ति के यूज़र इंटरफ़ेस (यूआई) के लिए Cloud Run सेवा और Gemma मॉडल के लिए जीपीयू का इस्तेमाल करने वाली Cloud Run सेवा शामिल है.

डिप्लॉयमेंट कॉन्फ़िगरेशन के बारे में जानकारी

Cloud Run पर एजेंट डिप्लॉय करते समय, हम कई एनवायरमेंट वैरिएबल पास करते हैं. इनसे एजेंट के व्यवहार और कनेक्टिविटी को कॉन्फ़िगर किया जाता है:

  • GOOGLE_CLOUD_PROJECT: इससे यह पक्का किया जाता है कि एजेंट, लॉगिंग और Vertex AI कॉल के लिए सही Google Cloud प्रोजेक्ट का इस्तेमाल करे.
  • GOOGLE_GENAI_USE_VERTEXAI: यह एजेंट फ़्रेमवर्क (ADK) को बताता है कि मॉडल इन्फ़रेंस के लिए, Gemini API को सीधे तौर पर कॉल करने के बजाय Vertex AI का इस्तेमाल करें.
  • [AGENT]_AGENT_CARD_URL: यह Orchestrator के लिए ज़रूरी है. इससे Orchestrator को यह पता चलता है कि रिमोट एजेंट कहां मिलेंगे. इसे डिप्लॉय किए गए Cloud Run यूआरएल (खास तौर पर एजेंट कार्ड पाथ) पर सेट करके, हम Orchestrator को इंटरनेट पर Researcher, Judge, और Content Builder के साथ कम्यूनिकेट करने और उन्हें खोजने की अनुमति देते हैं.

सभी एजेंट को Cloud Run सेवाओं में डिप्लॉय करने के लिए, यह स्क्रिप्ट चलाएं.

सबसे पहले, पक्का करें कि स्क्रिप्ट को चलाया जा सकता हो.

chmod u+x ~/multi-agent-system/deploy.sh

ध्यान दें: हर सेवा को क्रम से डिप्लॉय किया जाता है. इसलिए, इसे पूरा होने में कई मिनट लगेंगे.

~/multi-agent-system/deploy.sh

12. कोई कोर्स बनाएं!

कोर्स क्रिएटर्स के लिए बनी वेबसाइट खोलें. Course Creator Cloud Run सेवा, स्क्रिप्ट से डिप्लॉय की गई आखिरी सेवा है. कोर्स बनाने वाले व्यक्ति के यूआरएल की पहचान https://course-creator-..run.app के तौर पर की जा सकती है. यह डिप्लॉयमेंट स्क्रिप्ट की फ़ाइनल आउटपुट लाइन होनी चाहिए.

इसके बाद, कोर्स का कोई आइडिया टाइप करें. उदाहरण के लिए, "लीनियर अलजेब्रा".

आपके एजेंट, आपके कोर्स पर काम करना शुरू कर देंगे.

फ़ाइनल पाइपलाइन

13. क्लीन अप करें

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

1. Cloud Run की सेवाएं मिटाना

क्लीन अप करने का सबसे असरदार तरीका यह है कि Cloud Run पर डिप्लॉय की गई सेवाओं को मिटा दिया जाए.

# Delete the main agent and app services
gcloud run services delete researcher content-builder judge orchestrator course-creator \
    --region $REGION --quiet

# Delete the GPU backend (Ollama)
gcloud run services delete ollama-gemma-gpu \
    --region $OLLAMA_REGION --quiet

2. Artifact Registry की इमेज मिटाना

--source फ़्लैग का इस्तेमाल करके डिप्लॉय करने पर, Google Cloud ने Artifact Registry में एक रिपॉज़िटरी बनाई थी. इसमें आपकी कंटेनर इमेज सेव की गई थीं. इन फ़ाइलों को हटाने और स्टोरेज का शुल्क बचाने के लिए, रिपॉज़िटरी मिटाएं:

gcloud artifacts repositories delete cloud-run-source-deploy --location us-east4 --quiet

3. लोकल फ़ाइलें और एनवायरमेंट हटाना

अपने Cloud Shell एनवायरमेंट को साफ़ रखने के लिए, प्रोजेक्ट फ़ोल्डर और किसी भी लोकल कॉन्फ़िगरेशन को हटाएं:

cd ~
rm -rf multi-agent-system

4. (ज़रूरी नहीं) प्रोजेक्ट मिटाना

अगर आपने यह प्रोजेक्ट सिर्फ़ इस कोडलैब के लिए बनाया है, तो संसाधन मैनेज करें पेज पर जाकर प्रोजेक्ट को बंद करें. इससे यह पक्का किया जा सकेगा कि आगे कोई बिलिंग न हो.

14. बधाई हो!

आपने प्रोडक्शन के लिए तैयार, डिस्ट्रिब्यूट किया गया मल्टी-एजेंट सिस्टम बना लिया है और उसे डिप्लॉय कर दिया है.

आपने क्या-क्या हासिल किया है

  • मुश्किल टास्क को छोटे-छोटे हिस्सों में बांटा गया: हमने एक बड़े प्रॉम्प्ट के बजाय, काम को अलग-अलग भूमिकाओं (रिसर्चर, जज, कॉन्टेंट बिल्डर) में बांटा.
  • क्वालिटी कंट्रोल लागू किया गया: हमने LoopAgent और स्ट्रक्चर्ड Judge का इस्तेमाल किया, ताकि यह पक्का किया जा सके कि फ़ाइनल चरण में सिर्फ़ अच्छी क्वालिटी की जानकारी पहुंचे.
  • प्रोडक्शन के लिए बनाया गया: हमने एजेंट-टू-एजेंट (A2A) प्रोटोकॉल और Cloud Run का इस्तेमाल करके एक ऐसा सिस्टम बनाया है जिसमें हर एजेंट एक स्वतंत्र और स्केल की जा सकने वाली माइक्रोसेवा है. यह एक ही Python स्क्रिप्ट में सब कुछ चलाने से ज़्यादा बेहतर है.
  • ऑर्केस्ट्रेशन: हमने कंट्रोल फ़्लो के पैटर्न को साफ़ तौर पर तय करने के लिए, SequentialAgent और LoopAgent का इस्तेमाल किया. *. Cloud Run के जीपीयू: Cloud Run के जीपीयू पर Gemma मॉडल डिप्लॉय किया गया