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

1. परिचय

खास जानकारी

इस लैब में, Google Agent Development Kit (Google ADK) का इस्तेमाल करके, कॉम्प्लेक्स मल्टी-एजेंट सिस्टम को व्यवस्थित करने का तरीका बताया गया है. इसमें आपको एजेंट की सामान्य हैरारकी से लेकर, ऑटोमेट किए गए और साथ मिलकर काम करने वाले वर्कफ़्लो बनाने तक की सुविधा मिलती है.

आपको क्या बनाना है

आपको दो अलग-अलग मल्टी-एजेंट सिस्टम बनाने होंगे:

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

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

  • पेरेंट और सब-एजेंट के बीच संबंध बनाने का तरीका.
  • किसी टूल से सेशन state में डेटा लिखने का तरीका.
  • की टेंप्लेटिंग (जैसे, {my_key?}) का इस्तेमाल करके, state से डेटा पढ़ने का तरीका.
  • चरण-दर-चरण वाले वर्कफ़्लो के लिए, SequentialAgent का इस्तेमाल कैसे करें.
  • LoopAgent का इस्तेमाल करके, बार-बार बेहतर नतीजे पाने के लिए साइकल बनाने का तरीका.
  • एक साथ कई टास्क चलाने के लिए, ParallelAgent का इस्तेमाल कैसे करें.

ज़रूरी शर्तें

  • Python और कमांड-लाइन इंटरफ़ेस के बारे में जानकारी होना.
  • बिलिंग की सुविधा वाले Google Cloud प्रोजेक्ट का ऐक्सेस.
  • इंस्टॉल किए गए सीएलआई टूल: gcloud, uv.

2. मल्टी-एजेंट सिस्टम

Agent Development Kit (ADK) की मदद से डेवलपर, जनरेटिव मॉडल से ज़्यादा भरोसेमंद, बेहतर, और कई चरणों वाले टास्क पूरे करा सकते हैं. ADK की मदद से, एक मुश्किल प्रॉम्प्ट के बजाय कई आसान एजेंट का फ़्लो बनाया जा सकता है. ये एजेंट, काम को बाँटकर किसी समस्या को हल करने के लिए साथ मिलकर काम करते हैं.

एक ही प्रॉम्प्ट का इस्तेमाल करने के बजाय, इस तरीके के कई फ़ायदे हैं:

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

हायरार्किकल एजेंट ट्री

पदानुक्रम वाले एजेंट दिखाने वाला ट्री स्ट्रक्चर

ADK में, एजेंटों को ट्री स्ट्रक्चर में व्यवस्थित किया जाता है. बातचीत के फ़्लो को कंट्रोल करने के लिए, यह क्रम ज़रूरी है. इससे यह तय होता है कि कौन सा एजेंट, बातचीत को किस दूसरे एजेंट को "पास" कर सकता है. इससे सिस्टम के व्यवहार का अनुमान लगाना आसान हो जाता है और डीबग करना भी आसान हो जाता है. इसके ये फ़ायदे हैं:

  • आसान डिज़ाइन: इस स्ट्रक्चर को असल दुनिया की टीमों से लिया गया है. इसलिए, इसके बारे में तर्क देना आसान है.
  • कंट्रोल फ़्लो: इस तरह के फ़्लो में, टास्क को सौंपने की प्रोसेस पर आपका पूरा कंट्रोल होता है. इससे डीबग करने में मदद मिलती है. उदाहरण के लिए, ट्री स्ट्रक्चर यह पक्का करता है कि रिपोर्ट लिखने वाले सही एजेंट को कॉल किया जाए. भले ही, आपके पास एक जैसी जानकारी वाले दो एजेंट हों.

पूरे स्ट्रक्चर की शुरुआत root_agent से होती है. यह एजेंट, पैरंट के तौर पर काम करता है. इसमें एक या उससे ज़्यादा सब-एजेंट हो सकते हैं. ये सब-एजेंट भी अपने सब-एजेंट के पैरंट हो सकते हैं. इस तरह, ट्री बनता है.

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

Google खाता

अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

Google Cloud Console में साइन इन करना

किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.

बिलिंग चालू करें

Google Cloud क्रेडिट रिडीम करना (ज़रूरी नहीं है)

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

निजी बिलिंग खाता सेट अप करना

अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ें.

निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.

ध्यान दें:

  • इस लैब को पूरा करने में, Cloud संसाधनों पर 1 डॉलर से कम का खर्च आना चाहिए.
  • ज़्यादा शुल्क से बचने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करके संसाधनों को मिटाया जा सकता है.
  • नए उपयोगकर्ताओं को 300 डॉलर का क्रेडिट मुफ़्त में आज़माने के लिए मिलता है.

प्रोजेक्ट बनाना (ज़रूरी नहीं)

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

4. Cloud Shell Editor खोलें

  1. Cloud Shell Editor पर सीधे जाने के लिए, इस लिंक पर क्लिक करें
  2. अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें. Cloud Shell को अनुमति देने के लिए क्लिक करें
  3. अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
    • देखें पर क्लिक करें
    • टर्मिनलCloud Shell Editor में नया टर्मिनल खोलें पर क्लिक करें
  4. टर्मिनल में, इस निर्देश का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
    gcloud config set project [PROJECT_ID]
    • उदाहरण:
      gcloud config set project lab-project-id-example
    • अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची बनाई जा सकती है:
      gcloud projects list
      Cloud Shell Editor के टर्मिनल में प्रोजेक्ट आईडी सेट करना
  5. आपको यह मैसेज दिखेगा:
    Updated property [core/project].

5. एपीआई चालू करें

Gemini Enterprise Agent Platform API का इस्तेमाल करने और Gemini मॉडल के साथ इंटरैक्ट करने के लिए, आपको अपने Google Cloud प्रोजेक्ट में एपीआई चालू करना होगा.

  1. टर्मिनल में, एपीआई चालू करें:
    gcloud services enable aiplatform.googleapis.com

Python के लिए Google GenAI SDK टूल के बारे में बुनियादी जानकारी

अपने Python ऐप्लिकेशन से Gemini Enterprise Agent Platform पर होस्ट किए गए मॉडल के साथ इंटरैक्ट करने के लिए, आपको Python के लिए Google GenAI SDK का इस्तेमाल करना होगा. यह SDK, प्रॉम्प्ट भेजने, मॉडल पैरामीटर तय करने, और जवाब पाने की प्रोसेस को आसान बनाता है. इसके लिए, आपको एपीआई कॉल की जटिलताओं को सीधे तौर पर हैंडल करने की ज़रूरत नहीं होती.

Python के लिए Google GenAI SDK का पूरा दस्तावेज़ यहां देखा जा सकता है: Google GenAI SDK का दस्तावेज़.

6. प्रोजेक्ट एनवायरमेंट सेट अप करना

रिपो का क्लोन बनाएं

  1. टर्मिनल में, स्टार्टर फ़ाइलें रखने वाली रिपॉज़िटरी को क्लोन करें.
    git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git devrel-demos-multiagent-lab
    --depth 1 फ़्लैग, सिर्फ़ नए वर्शन को क्लोन करता है. इससे प्रोसेस तेज़ी से पूरी होती है.
  2. टर्मिनल में, लैब से जुड़े फ़ोल्डर को अपनी होम डायरेक्ट्री में ले जाएं. इसके बाद, लैब के स्ट्रक्चर के हिसाब से उसका नाम बदलें.
    mv devrel-demos-multiagent-lab/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems ~
  3. टर्मिनल में, इस लैब (adk_multiagent_systems) के लिए सही वर्किंग डायरेक्ट्री पर जाएं.
    cd ~/adk_multiagent_systems

अपनी फ़ाइल के स्ट्रक्चर की समीक्षा करना

अब जब आपकी सभी फ़ाइलें बन गई हैं, तो पूरे स्ट्रक्चर को देखने के लिए एक्सप्लोरर में adk_multiagent_systems फ़ोल्डर खोलें.

  1. Cloud Shell Editor मेन्यू में, File > Open Folder... को चुनें.
    Cloud Shell Editor का फ़ाइल मेन्यू, जिसमें 'फ़ोल्डर खोलें' विकल्प चुना गया है
  2. पॉप-अप होने वाले बॉक्स में, अपने उपयोगकर्ता नाम के बाद फ़ोल्डर की यह जानकारी जोड़ें: adk_multiagent_systems/. ठीक है पर क्लिक करें.
    यह कुछ ऐसा दिखना चाहिए:
    प्रोजेक्ट के पाथ के साथ फ़ोल्डर का डायलॉग बॉक्स खोलें
  3. बाईं ओर मौजूद एक्सप्लोरर पैनल रीफ़्रेश हो जाएगा. अब आपको अपना पूरा प्रोजेक्ट स्ट्रक्चर दिखेगा. इसमें parent_and_subagents और workflow_agents सब-डायरेक्ट्री होंगी. अब अगले चरण पूरे किए जा सकते हैं.
    एक्सप्लोरर पैनल में, adk_multiagent_systems फ़ोल्डर खुला हुआ दिख रहा है

वर्चुअल एनवायरमेंट चालू करना

  1. टर्मिनल में, uv का इस्तेमाल करके वर्चुअल एनवायरमेंट बनाएं और उसे चालू करें. इससे यह पक्का किया जाता है कि आपके प्रोजेक्ट की डिपेंडेंसी, सिस्टम Python या अन्य प्रोजेक्ट के साथ काम करती हैं.
    uv venv
source .venv/bin/activate
  2. टर्मिनल में, requirements.txt फ़ाइल से google-adk और अन्य डिपेंडेंसी इंस्टॉल करें:
    uv pip install -r requirements.txt

एनवायरमेंट वैरिएबल सेट अप करना

  1. आप पहले से ही adk_multiagent_systems डायरेक्ट्री में शामिल हैं. अपने एनवायरमेंट वैरिएबल सेव करने के लिए, टर्मिनल में .env फ़ाइल बनाएं:
    cloudshell edit .env
  2. एडिटर में खुलने वाली .env फ़ाइल में, यह कोड चिपकाएं:
    GOOGLE_GENAI_USE_ENTERPRISE=true
GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
GOOGLE_CLOUD_LOCATION=global
MODEL="gemini-3.5-flash"
  3. [YOUR-PROJECT-ID] की जगह अपना असल Google Cloud प्रोजेक्ट आईडी डालें. (उदाहरण के लिए, PROJECT_ID = "google-cloud-labs")
    अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो अपने टर्मिनल में यह कमांड चलाएं. इससे आपको अपने सभी प्रोजेक्ट और उनके आईडी की सूची दिखेगी.
    gcloud projects list
  4. टर्मिनल में, इस .env फ़ाइल को सब-एजेंट डायरेक्ट्री में कॉपी करें, ताकि वे भी वैरिएबल को ऐक्सेस कर सकें:
    cp .env parent_and_subagents/.env
cp .env workflow_agents/.env
    फ़ाइल का स्ट्रक्चर अब ऐसा दिखना चाहिए:
    एक्सप्लोरर पैनल में, adk_multiagent_systems फ़ोल्डर खुला हुआ दिख रहा है

7. पैरंट, सब-एजेंट, और पीयर एजेंट के बीच ट्रांसफ़र करने के बारे में जानें

बातचीत हमेशा root_agent से शुरू होती है. डिफ़ॉल्ट रूप से, पैरंट एजेंट अपने सब-एजेंट के description का इस्तेमाल करके यह तय करता है कि बातचीत कब ट्रांसफ़र करनी है. माता-पिता के instruction में जाकर, सब-एजेंट के name का इस्तेमाल करके, इन ट्रांसफ़र के बारे में साफ़ तौर पर बताया जा सकता है.

आइए, इसे टेस्ट करते हैं.

  1. Cloud Shell Editor में, adk_multiagent_systems/parent_and_subagents/agent.py खोलें. agent.py फ़ाइल में मौजूद तीन एजेंट पर ध्यान दें:
    • root_agent (नाम steering): यह उपयोगकर्ता से एक सवाल पूछता है, ताकि यह तय किया जा सके कि किस सब-एजेंट को ट्रांसफ़र करना है. शुरुआत में, यह सिर्फ़ अपने सब-एजेंट के description पर निर्भर करता है.
    • travel_brainstormer: इससे उपयोगकर्ता को यात्रा के लिए जगहें चुनने में मदद मिलती है.
    • attractions_planner: इससे उपयोगकर्ता को किसी देश में क्या-क्या करें की सूची बनाने में मदद मिलती है.
  2. root_agent बनाते समय, इस लाइन को जोड़कर travel_brainstormer और attractions_planner को root_agent के सब-एजेंट के तौर पर सेट करें:
        sub_agents=[travel_brainstormer, attractions_planner]
  3. टर्मिनल में, अपने एजेंट से चैट करें:
    cd ~/adk_multiagent_systems
adk run parent_and_subagents
  4. टर्मिनल में [user]: प्रॉम्प्ट पर, यह टाइप करें:
    hello
    आउटपुट का उदाहरण (आपका आउटपुट थोड़ा अलग हो सकता है):
    [steering]: Hi there! Do you already have a country in mind for your trip, or would you like some help deciding where to go?
  5. अब टर्मिनल में एजेंट को यह बताएं:
    I could use some help deciding.
    आउटपुट का उदाहरण (आपका आउटपुट थोड़ा अलग हो सकता है):
    [travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
...
    [travel_brainstormer] टैग पर ध्यान दें. root_agent ने कंट्रोल ट्रांसफ़र सिर्फ़ सब-एजेंट के description के आधार पर किया.
  6. बातचीत खत्म करने के लिए, टर्मिनल में user: प्रॉम्प्ट पर, exit टाइप करें और ENTER दबाएं.
  7. अब हम इस बारे में ज़्यादा जानकारी देते हैं. agent.py में, root_agent के instruction में यह जोड़ें:
            If they need help deciding, send them to 'travel_brainstormer'.
        If they know what country they'd like to visit, send them to the 'attractions_planner'.
  8. टर्मिनल में, एजेंट को फिर से चलाएं:
    adk run parent_and_subagents
  9. टर्मिनल में [user]: प्रॉम्प्ट पर, यह टाइप करें:
    hello
  10. इनके साथ जवाब दें:
    I would like to go to Japan.
    आउटपुट का उदाहरण (आपका आउटपुट थोड़ा अलग हो सकता है):
    [attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
    नए निर्देशों के मुताबिक, attractions_planner पर ट्रांसफ़र करने के बारे में सूचना दें.
  11. अब इस जवाब के साथ जवाब दें:
    Actually I don't know what country to visit.
    आउटपुट का उदाहरण (आपका आउटपुट थोड़ा अलग हो सकता है):
    [travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
    ध्यान दें कि आपको travel_brainstormer पर ट्रांसफ़र कर दिया गया है. यह attractions_planner का मिलते-जुलते ऐप्लिकेशन है. यह सुविधा डिफ़ॉल्ट रूप से चालू होती है.
  12. उपयोगकर्ता के प्रॉम्प्ट पर, सेशन खत्म करने के लिए exit टाइप करें.

रीकैप

इस सेक्शन में, आपने एजेंट हैरारकी और बातचीत के फ़्लो के बारे में बुनियादी बातें सीखीं:

  • बातचीत हमेशा root_agent से शुरू होती है.
  • माता-पिता की सहायता करने वाला एजेंट, description के आधार पर, अपने-आप उप-एजेंट को ट्रांसफ़र कर सकता है.
  • माता-पिता को instruction देकर, इस फ़्लो को कंट्रोल किया जा सकता है. इससे माता-पिता, name के ज़रिए सब-एजेंट को ट्रांसफ़र कर सकते हैं.
  • डिफ़ॉल्ट रूप से, एजेंट अपने peer एजेंट (पदानुक्रम में भाई-बहन) को ट्रांसफ़र कर सकते हैं.

8. जानकारी को सेव करने और वापस पाने के लिए सेशन की स्थिति का इस्तेमाल करना

हर एडीके बातचीत में Session होता है. इसमें सेशन की स्थिति का डिक्शनरी शामिल होता है. इस स्थिति को सभी एजेंट ऐक्सेस कर सकते हैं. इसलिए, यह उनके बीच जानकारी शेयर करने या बातचीत के दौरान डेटा (जैसे, सूची) को बनाए रखने का सबसे सही तरीका है.

स्टेट में डेटा जोड़ने और उससे डेटा पढ़ने के बारे में जानने के लिए:

  1. फ़ाइल adk_multiagent_systems/parent_and_subagents/agent.py पर वापस जाएं
  2. # Tools हेडर के बाद, फ़ंक्शन की यह परिभाषा चिपकाएं:
    def save_attractions_to_state(
tool_context: ToolContext,
attractions: List[str]
) -> dict[str, str]:
    """Saves the list of attractions to state["attractions"].

    Args:
        attractions [str]: a list of strings to add to the list of attractions

    Returns:
        None
    """
    # Load existing attractions from state. If none exist, start an empty list
    existing_attractions = tool_context.state.get("attractions", [])

    # Update the 'attractions' key with a combo of old and new lists.
    # When the tool is run, ADK will create an event and make
    # corresponding updates in the session's state.
    tool_context.state["attractions"] = existing_attractions + attractions

    # A best practice for tools is to return a status message in a return dict
    return {"status": "success"}
    इस कोड में इन बातों का ध्यान रखें:
    • फ़ंक्शन को tool_context: ToolContext मिलता है. यह ऑब्जेक्ट, सेशन में शामिल होने का आपका गेटवे है.
    • लाइन tool_context.state["attractions"] = ..., सेशन की स्टेट डिक्शनरी से सीधे तौर पर डेटा पढ़ती है और उसमें डेटा लिखती है. बाकी काम ADK करता है.
  3. tools पैरामीटर जोड़कर, टूल को attractions_planner एजेंट में जोड़ें:
        tools=[save_attractions_to_state]
  4. attractions_planner एजेंट के मौजूदा instruction में, यहां दिए गए बुलेट पॉइंट जोड़ें:
            - When they reply, use your tool to save their selected attraction and then provide more possible attractions.
        - If they ask to view the list, provide a bulleted list of { attractions? } and then suggest some more.
  5. टर्मिनल में यह कमांड डालकर, एजेंट डेवलपमेंट किट के वेब यूज़र इंटरफ़ेस को लॉन्च करें:
    adk web
    आउटपुट
    INFO:     Started server process [2434]
INFO:     Waiting for application startup.
+-------------------------------------------------------+
| ADK Web Server started                                |
|                                                       |
| For local testing, access at http://localhost:8000.   |
+-------------------------------------------------------+

INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
  6. Cloud Shell टर्मिनल में, नए टैब में वेब इंटरफ़ेस देखने के लिए, वेब की झलक बटन पर क्लिक करें. इसके बाद, पोर्ट बदलें को चुनें.
    वेब प्रीव्यू मेन्यू
  7. पोर्ट नंबर 8000 डालें और बदलें और झलक देखें पर क्लिक करें. ADK Dev UI के साथ एक नया ब्राउज़र टैब खुलेगा.
    टेक्स्ट बॉक्स में 8000 डालकर, पोर्ट पॉप-अप बॉक्स को बदला गया
  8. बाईं ओर मौजूद कोई एजेंट चुनें ड्रॉपडाउन से, parent_and_subagents को चुनें.
  9. इनके साथ बातचीत शुरू करें: hello
  10. एजेंट के नमस्ते कहने के बाद, यह जवाब दें:
    I'd like to go to Egypt.
    आपको attractions_planner पर रीडायरेक्ट किया जाएगा. साथ ही, आपको देखने लायक जगहों की सूची दिखेगी.
  11. कोई जगह चुनें. उदाहरण के लिए:
    I'll go to the Sphinx
  12. आपको इस तरह का जवाब मिलेगा: ठीक है, मैंने स्फ़िंक्स को आपकी सूची में सेव कर दिया है...
  13. टूल से मिले जवाब से बनाए गए इवेंट को देखने के लिए, जवाब देने वाले टूल बॉक्स (चेक मार्क के साथ मार्क किया गया) पर क्लिक करें.
    ध्यान दें कि इसमें एक actions फ़ील्ड शामिल है. इसमें stateDelta शामिल है, जो स्थिति में हुए बदलावों के बारे में बताता है.
  14. एजेंट की सूची में मौजूद किसी अन्य जगह के बारे में जानकारी देकर जवाब दें.
  15. बाईं ओर मौजूद नेविगेशन मेन्यू में, "X" पर क्लिक करके, उस इवेंट पर फ़ोकस करना बंद करें जिसकी आपने पहले जांच की थी.
  16. बाईं ओर मौजूद साइडबार में, स्टेट टैब पर क्लिक करें. अब आपको सेशन की स्थिति में attractions ऐरे दिखेगा. इसमें आपके चुने गए दोनों आइटम शामिल होने चाहिए.वेब यूज़र इंटरफ़ेस (यूआई) में सेशन की स्थिति की झलक
  17. इस मैसेज को एजेंट को भेजें:
    What is on my list?
    अब एजेंट को राज्य के हिसाब से जानकारी देनी चाहिए और आपको सूची दिखानी चाहिए.
  18. एजेंट के साथ एक्सपेरिमेंट पूरा होने के बाद, वेब ब्राउज़र टैब बंद करें. इसके बाद, सर्वर को बंद करने के लिए, Cloud Shell टर्मिनल में CTRL + C दबाएं.

सेक्शन का रीकैप

इस सेक्शन में, आपने डेटा शेयर करने के लिए Session स्टेट का इस्तेमाल करने का तरीका सीखा:

  • स्टेट लिखने के लिए: टूल के अंदर से स्टेट डिक्शनरी में लिखने के लिए, tool_context.state ऑब्जेक्ट का इस्तेमाल करें. उदाहरण के लिए, tool_context.state["my_list"] = [...].
  • स्टेट को पढ़ने के लिए: स्टेट डेटा को सीधे तौर पर एजेंट के instruction में इंजेक्ट किया जाता है.इसके लिए, कुंजी टेंप्लेटिंग का इस्तेमाल किया जाता है. जैसे, Here is your list: {my_list?}.
  • स्टेट की जांच करने के लिए: ADK Dev UI में, स्टेट टैब का इस्तेमाल करके सेशन की स्थिति को लाइव मॉनिटर किया जा सकता है.

9. वर्कफ़्लो एजेंट

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

यह सुविधा, कई चरणों वाले ऐसे टास्क के लिए सबसे सही है जो अपने-आप पूरे होते हैं. जैसे, "प्लान बनाना और उसे लागू करना" या "ड्राफ़्ट बनाना और उसमें बदलाव करना" पाइपलाइन. ADK, इसे मैनेज करने के लिए तीन बिल्ट-इन वर्कफ़्लो एजेंट उपलब्ध कराता है:

  • SequentialAgent
  • LoopAgent
  • ParallelAgent

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

आपको एक ऐसा एजेंट बनाना है जो किसी ऐतिहासिक किरदार पर आधारित नई फ़िल्म के लिए पिच दस्तावेज़ तैयार करे. आपके एजेंट, रिसर्च, बार-बार लिखने, और रिपोर्ट जनरेट करने का काम करेंगे.

आखिर में, आपका सिस्टम ऐसा दिखेगा:

film_concept_team मल्टी-एजेंट सिस्टम का डायग्राम

इस सिस्टम को एक-एक करके बनाया जाएगा. इसकी शुरुआत सबसे आसान वर्कफ़्लो से होगी.

10. SequentialAgent की मदद से मल्टी-एजेंट सिस्टम बनाना

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

पहला वर्शन इस तरह से स्ट्रक्चर किया जाएगा:

Film_concept_team multi-agent system step 1

  • root_agent (greeter) उपयोगकर्ता का स्वागत करेगा और उससे फ़िल्म के बारे में पूछेगा.
  • इसके बाद, कॉल को film_concept_team नाम के SequentialAgent पर ट्रांसफ़र कर दिया जाएगा. इससे:
    1. विकिपीडिया से तथ्य पाने के लिए, researcher एजेंट चलाएं.
    2. प्लॉट लिखने के लिए, उन तथ्यों का इस्तेमाल करने के लिए screenwriter एजेंट चलाएं.
    3. फ़ाइल में फ़ाइनल प्लॉट सेव करने के लिए, file_writer एजेंट चलाएं.

चलिए, इसे चलाते हैं.

  1. Cloud Shell Editor में, adk_multiagent_systems/workflow_agents/agent.py खोलें.
    एजेंट की परिभाषा वाली इस फ़ाइल को पढ़ें. उप-एजेंट को पैरंट एजेंट को असाइन करने से पहले, उन्हें तय करना ज़रूरी है. बातचीत के फ़्लो के क्रम में फ़ाइल को पढ़ने के लिए, फ़ाइल में सबसे नीचे से लेकर सबसे ऊपर तक एजेंट पढ़े जा सकते हैं.
  2. append_to_state टूल पर ध्यान दें. इस हेल्पर फ़ंक्शन की मदद से एजेंट, सेशन की स्थिति में मौजूद सूची में डेटा जोड़ सकते हैं. researcher और screenwriter इसी तरह काम करेंगे.
  3. एजेंट को आज़माएं. टर्मिनल में, लाइव-रीलोडिंग की सुविधा चालू करके वेब इंटरफ़ेस लॉन्च करें:
    cd ~/adk_multiagent_systems
adk web --reload_agents
  4. Cloud Shell टर्मिनल में, नए टैब में वेब इंटरफ़ेस देखने के लिए, वेब की झलक बटन पर क्लिक करें. इसके बाद, पोर्ट बदलें को चुनें.
    वेब प्रीव्यू मेन्यू
  5. पोर्ट नंबर 8000 डालें और बदलें और झलक देखें पर क्लिक करें. ADK Dev UI के साथ एक नया ब्राउज़र टैब खुलेगा.
    टेक्स्ट बॉक्स में 8000 डालकर, पोर्ट पॉप-अप बॉक्स को बदला गया
  6. कोई एजेंट चुनें ड्रॉपडाउन से, workflow_agents चुनें.
  7. hello के साथ बातचीत शुरू करें. greeter एजेंट जवाब देगा.
  8. जब कहा जाए, तब किसी ऐतिहासिक हस्ती का नाम डालें. इनमें से किसी एक या अपने हिसाब से कोई प्रॉम्प्ट इस्तेमाल करें:
    • झांग झोंगजिंग
    • एडा लवलेस
    • मार्कस औरीलियस
  9. अब SequentialAgent की बारी है. आपको कोई भी इंटरमीडिएट मैसेज नहीं दिखेगा. researcher, screenwriter, और file_writer एक के बाद एक रन होंगे. पूरा क्रम पूरा होने के बाद ही एजेंट जवाब देगा.
    अगर ऐसा नहीं होता है, तो सबसे ऊपर दाईं ओर मौजूद + नया सेशन पर क्लिक करें और फिर से कोशिश करें.
  10. जब एजेंट पुष्टि कर दे कि फ़ाइल लिख दी गई है, तब आउटपुट देखने के लिए Cloud Shell Editor में movie_pitches डायरेक्ट्री में जाकर, नई .txt फ़ाइल ढूंढें और उसे खोलें.
  11. ADK Dev UI में, चैट के इतिहास में मौजूद आखिरी एजेंट के आइकॉन पर क्लिक करें. इससे इवेंट व्यू खुल जाएगा.
  12. इवेंट व्यू में, एजेंट ट्री का विज़ुअल ग्राफ़ दिखता है. यहां दिखाया गया है कि greeter ने film_concept_team को कॉल किया. इसके बाद, ने अपने हर सब-एजेंट को क्रम से कॉल किया.adk web graph
  13. ग्राफ़ में मौजूद किसी भी एजेंट के लिए, अनुरोध और जवाब टैब पर क्लिक करके, पास किए गए डेटा की जांच की जा सकती है. इसमें सेशन की स्थिति भी शामिल है.

सेक्शन का रीकैप

इस सेक्शन में, आपने वर्कफ़्लो एजेंट का इस्तेमाल करने का तरीका सीखा:

  • SequentialAgent अपने सब-एजेंट को एक-एक करके क्रम से लागू करता है. इसके लिए, वह चरणों के बीच उपयोगकर्ता के इनपुट का इंतज़ार नहीं करता.
  • यह एक "वर्कफ़्लो" है, क्योंकि उपयोगकर्ता root_agent से बात करता है. इसके बाद, SequentialAgent को काम सौंप देता है, ताकि वह उसे पूरा कर सके.
  • सीक्वेंस में मौजूद सब-एजेंट, पिछले एजेंट के काम को ऐक्सेस करने के लिए सेशन की स्थिति (जैसे, { PLOT_OUTLINE? }) का इस्तेमाल करते हैं.
  • एजेंट-टू-एजेंट वर्कफ़्लो को विज़ुअलाइज़ करने और डीबग करने के लिए, Dev UI में इवेंट ग्राफ़ का इस्तेमाल किया जा सकता है.

11. बार-बार किए जाने वाले काम के लिए, LoopAgent जोड़ना

LoopAgent एक वर्कफ़्लो एजेंट है. यह अपने सब-एजेंट को क्रम से चलाता है. इसके बाद, यह शुरू से फिर से शुरू होता है. यह "लूप" तब तक जारी रहता है, जब तक कोई शर्त पूरी नहीं हो जाती. जैसे, max_iterations की संख्या तक पहुंचना या सब-एजेंट का, exit_loop टूल को कॉल करना.

यह उन टास्क के लिए मददगार है जिनमें बार-बार सुधार करने की ज़रूरत होती है. आपको इस LoopAgent को जोड़ना होगा, ताकि फ़िल्म की पिच करने वाले एजेंट के लिए "लेखक का कमरा" बनाया जा सके. इससे researcher, screenwriter, और critic एजेंट को एक लूप में काम करने की अनुमति मिलती है. इससे हर पास के साथ प्लॉट बेहतर होता जाता है. ऐसा तब तक होता है, जब तक critic यह तय नहीं कर लेता कि प्लॉट तैयार है. इससे एजेंट को, उपयोगकर्ता के अस्पष्ट इनपुट (जैसे, "एक प्राचीन डॉक्टर") को हैंडल करने में भी मदद मिलती है. ऐसा इसलिए, क्योंकि इससे एजेंट को किसी आइडिया पर रिसर्च करने और उसे बेहतर बनाने का मौका मिलता है.

Film_concept_team मल्टी-एजेंट सिस्टम का दूसरा चरण

ये बदलाव करने के लिए:

  1. adk_multiagent_systems/workflow_agents/agent.py में, exit_loop के लिए इंपोर्ट जोड़ें (अन्य google.adk इंपोर्ट के पास):
    from google.adk.tools import exit_loop
  2. नया critic एजेंट जोड़ें. यह एजेंट, प्लॉट की समीक्षा करेगा. अगर यह सही है, तो यह exit_loop को कॉल करता है. अगर ऐसा नहीं होता है, तो यह अगले लूप के लिए स्थिति में सुझाव जोड़ता है.
    # Agents सेक्शन में, एजेंट की यह परिभाषा चिपकाएं:
    critic = Agent(
    name="critic",
    model=model_name,
    description="Reviews the outline so that it can be improved.",
    instruction="""
    INSTRUCTIONS:
    Consider these questions about the PLOT_OUTLINE:
    - Does it meet a satisfying three-act cinematic structure?
    - Do the characters' struggles seem engaging?
    - Does it feel grounded in a real time period in history?
    - Does it sufficiently incorporate historical details from the RESEARCH?

    If the PLOT_OUTLINE does a good job with these questions, exit the writing loop with your 'exit_loop' tool.
    If significant improvements can be made, use the 'append_to_state' tool to add your feedback to the field 'CRITICAL_FEEDBACK'.
    Explain your decision and briefly summarize the feedback you have provided.

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    RESEARCH:
    { research? }
    """,
    before_model_callback=log_query_to_model,
    after_model_callback=log_model_response,
    tools=[append_to_state, exit_loop]
)
  3. writers_room LoopAgent बनाएं. इसमें वे तीन एजेंट शामिल होंगे जो लूप में काम करेंगे.
    इस कोड को film_concept_team एजेंट की डेफ़िनिशन के ऊपर चिपकाएं:
    writers_room = LoopAgent(
    name="writers_room",
    description="Iterates through research and writing to improve a movie plot outline.",
    sub_agents=[
        researcher,
        screenwriter,
        critic
    ],
    max_iterations=5,
)
  4. नए writers_room लूप का इस्तेमाल करने के लिए, film_concept_team SequentialAgent को अपडेट करें. researcher और screenwriter को writers_room एजेंट से बदलें.अपनी मौजूदा film_concept_team परिभाषा को इससे बदलें:
    film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        file_writer
    ],
)
  5. ADK Dev UI टैब पर वापस जाएं. इसके बाद, सबसे ऊपर दाईं ओर मौजूद + नया सेशन पर क्लिक करें.
  6. इनके साथ नई बातचीत शुरू करें: hello
  7. जब आपसे कहा जाए, तब एजेंट को इस बार कोई बड़ा विषय दें. यहां कुछ आइडिया दिए गए हैं:
    • एक इंडस्ट्रियल डिज़ाइनर, जिसने आम लोगों के लिए प्रॉडक्ट बनाए
    • कार्टोग्राफ़र (नक्शा बनाने वाला)
    • उस व्यक्ति के बारे में बताओ जिसने फ़सलों से ज़्यादा खाना पैदा किया
    अब एजेंट, लूप के ज़रिए काम करेगा. ADK Dev UI में, आपको एजेंट के कई बार चलने के लॉग दिखेंगे. जैसे, "[researcher]", "[screenwriter]", "[critic]", "[researcher]", "[screenwriter]", "[critic]...".
  8. लूप पूरा होने पर, एजेंट फ़ाइल लिखेगा. adk_multiagent_systems/movie_pitches डायरेक्ट्री में जनरेट की गई फ़ाइल की समीक्षा करें.
  9. लूप स्ट्रक्चर देखने के लिए, Dev UI में इवेंट ग्राफ़ की जांच करें.

सेक्शन का रीकैप

इस सेक्शन में, आपने LoopAgent का इस्तेमाल करने का तरीका सीखा:

  • LoopAgent एक वर्कफ़्लो एजेंट होता है. यह अपने सब-एजेंट के क्रम को दोहराता है. इससे, बार-बार किए जाने वाले टास्क के लिए "इनर लूप" बनता है.
  • लूप में शामिल एजेंट, सेशन की स्थिति का इस्तेमाल करके, एक-दूसरे को काम (जैसे, PLOT_OUTLINE) और सुझाव/राय (जैसे, CRITICAL_FEEDBACK) देते हैं.
  • लूप को max_iterations सीमा तक पहुंचने पर रोका जा सकता है. इसके अलावा, एजेंट exit_loop टूल को कॉल करके भी इसे रोका जा सकता है.

12. "फ़ैन आउट और इकट्ठा करें" के लिए, ParallelAgent का इस्तेमाल करना

ParallelAgent एक वर्कफ़्लो एजेंट है. यह अपने सभी सब-एजेंट को एक साथ (एक ही समय में) एक्ज़ीक्यूट करता है. यह उन टास्क के लिए फ़ायदेमंद है जिन्हें अलग-अलग सब-टास्क में बांटा जा सकता है. जैसे, दो अलग-अलग रिसर्च जॉब चलाना.

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

Film_concept_team मल्टी-एजेंट सिस्टम का तीसरा चरण

आपका फ़ाइनल एजेंट फ़्लो यह होगा:

  1. greeter (रूट) चैट शुरू करता है.
  2. यह film_concept_team (SequentialAgent) पर ट्रांसफ़र हो जाता है, जो
      को चलता है
    • प्लॉट बनाने के लिए writers_room (LoopAgent).
    • बॉक्स ऑफ़िस और कास्टिंग के बारे में एक ही समय पर रिसर्च करने के लिए, नया preproduction_team (ParallelAgent).
    • file_writer, सभी नतीजे इकट्ठा करने और फ़ाइल सेव करने के लिए.

ये बदलाव करने के लिए:

  1. adk_multiagent_systems/workflow_agents/agent.py में, # Agents हेडर के नीचे नया ParallelAgent और उसके सब-एजेंट चिपकाएं.
    box_office_researcher = Agent(
    name="box_office_researcher",
    model=model_name,
    description="Considers the box office potential of this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Write a report on the box office potential of a movie like that described in PLOT_OUTLINE based on the reported box office performance of other recent films.
    """,
    output_key="box_office_report"
)

casting_agent = Agent(
    name="casting_agent",
    model=model_name,
    description="Generates casting ideas for this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Generate ideas for casting for the characters described in PLOT_OUTLINE
    by suggesting actors who have received positive feedback from critics and/or
    fans when they have played similar roles.
    """,
    output_key="casting_report"
)

preproduction_team = ParallelAgent(
    name="preproduction_team",
    sub_agents=[
        box_office_researcher,
        casting_agent
    ]
)
  2. film_concept_team SequentialAgent की sub_agents सूची को अपडेट करें, ताकि इसमें नया preproduction_team (writers_room और file_writer के बीच) शामिल किया जा सके. film_concept_team की मौजूदा परिभाषा को इससे बदलें:
    film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        preproduction_team,
        file_writer
    ],
)
  3. file_writer एजेंट के instruction को अपडेट करें, ताकि वह राज्य से नई रिपोर्ट "इकट्ठा" कर सके और उन्हें फ़ाइल में जोड़ सके.
    file_writer के लिए, instruction स्ट्रिंग को इससे बदलें:
        instruction="""
    INSTRUCTIONS:
    - Create a marketable, contemporary movie title suggestion for the movie described in the PLOT_OUTLINE.
    If a title has been suggested in PLOT_OUTLINE, you can use it, or replace it with a better one.
    - Use your 'write_file' tool to create a new txt file with the following arguments:
    - for a filename, use the movie title
    - Write to the 'movie_pitches' directory.
    - For the 'content' to write, include:
    - The PLOT_OUTLINE
    - The BOX_OFFICE_REPORT
    - The CASTING_REPORT

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    BOX_OFFICE_REPORT:
    { box_office_report? }

    CASTING_REPORT:
    { casting_report? }
    """,
  4. ADK Dev UI टैब पर वापस जाएं और + नया सेशन पर क्लिक करें.
  5. बातचीत शुरू करने के लिए, hello डालें.
  6. जब आपसे कहा जाए, तब किरदार के लिए कोई नया आइडिया डालें. यहां कुछ आइडिया दिए गए हैं:
    • उस ऐक्ट्रेस का नाम बताओ जिसने वाई-फ़ाई की टेक्नोलॉजी का आविष्कार किया था
    • एक बेहतरीन शेफ़
    • दुनिया के मेले और प्रदर्शनियों में मुख्य भूमिका निभाने वाले लोग
  7. जब एजेंट अपना काम पूरा कर ले, तब adk_multiagent_systems/movie_pitches डायरेक्ट्री में जाकर, फ़ाइनल फ़ाइल की जांच करें. अब इसमें प्लॉट, बॉक्स ऑफ़िस रिपोर्ट, और कास्टिंग रिपोर्ट, सभी एक ही दस्तावेज़ में शामिल होनी चाहिए.

सेक्शन का रीकैप

इस सेक्शन में, आपने ParallelAgent का इस्तेमाल करने का तरीका सीखा:

  • ParallelAgent "फ़ैन आउट" वर्कफ़्लो, अपने सभी सब-एजेंट को एक क्रम में चलाने के बजाय, एक साथ चलाता है.
  • यह उन कामों के लिए बहुत कारगर है जो एक-दूसरे पर निर्भर नहीं होते. जैसे, दो अलग-अलग विषयों पर रिसर्च करना.
  • पैरलल एजेंट के नतीजों को बाद में आने वाला एजेंट "इकट्ठा" करता है. इसके लिए, पैरलल एजेंट अपने काम को सेशन की स्थिति में सेव करते हैं (output_key का इस्तेमाल करके). इसके बाद, फ़ाइनल एजेंट (जैसे कि file_writer) उन कुंजियों को पढ़ता है.

13. कस्टम वर्कफ़्लो एजेंट

अगर SequentialAgent, LoopAgent, और ParallelAgent के पहले से तय किए गए वर्कफ़्लो एजेंट आपकी ज़रूरतों को पूरा नहीं करते हैं, तो CustomAgent की मदद से, वर्कफ़्लो के नए लॉजिक को लागू किया जा सकता है.

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

CustomAgent बनाना इस लैब के दायरे से बाहर है. हालांकि, अगर आपको इसकी ज़रूरत है, तो यह आपके लिए मददगार हो सकता है!

14. बधाई हो!

आपने Google Agent Development Kit (ADK) का इस्तेमाल करके, बेहतर मल्टी-एजेंट सिस्टम बना लिया है. आपने पैरंट-चाइल्ड एजेंट के बीच के सामान्य संबंध से लेकर, जटिल और ऑटोमेटेड वर्कफ़्लो को व्यवस्थित करने तक का सफ़र तय किया है. ये वर्कफ़्लो, क्रिएटिव प्रोजेक्ट के लिए रिसर्च कर सकते हैं, लिख सकते हैं, और उसे बेहतर बना सकते हैं.

रीकैप

इस लैब में, आपने ये काम किए:

  • पैरंट और सब-एजेंट के संबंधों के साथ, क्रमिक ट्री में व्यवस्थित एजेंट.
  • एजेंट से एजेंट को कॉल ट्रांसफ़र करने की सुविधा को कंट्रोल किया जाता है. यह सुविधा, अपने-आप (description का इस्तेमाल करके) और साफ़ तौर पर (instruction का इस्तेमाल करके), दोनों तरह से काम करती है.
  • tool_context.state डिक्शनरी में डेटा लिखने के लिए, टूल का इस्तेमाल किया गया.
  • इस कुकी का इस्तेमाल, सेशन की मौजूदा स्थिति से जानकारी पाने और एजेंट के प्रॉम्प्ट को गाइड करने के लिए, कुंजी टेंप्लेट (जैसे, { PLOT_OUTLINE? }) का इस्तेमाल किया जाता है.
  • आसान और सिलसिलेवार वर्कफ़्लो (रिसर्च -> लिखना -> सेव करना) बनाने के लिए, SequentialAgent लागू किया गया.
  • इटरेशन रिफ़ाइनमेंट साइकल बनाने के लिए, critic एजेंट और exit_loop टूल के साथ LoopAgent का इस्तेमाल किया गया.
  • एक साथ कई टास्क (जैसे कि कास्टिंग और बॉक्स ऑफ़िस रिसर्च) पूरे करने के लिए, ParallelAgent का इस्तेमाल किया गया.

एक्सपेरिमेंट जारी रखना

आपने जो कुछ भी सीखा है उसे आगे बढ़ाने के कई तरीके हैं. यहां कुछ आइडिया दिए गए हैं:

  • ज़्यादा एजेंट जोड़ें: अपने preproduction_team ParallelAgent में कोई नया एजेंट जोड़ें. उदाहरण के लिए, marketing_agent बनाया जा सकता है, जो PLOT_OUTLINE के आधार पर फ़िल्म के लिए टैगलाइन लिखता है.
  • ज़्यादा टूल जोड़ें: अपने researcher एजेंट को ज़्यादा टूल दें. ऐसा टूल बनाया जा सकता है जो Google Search API का इस्तेमाल करके, ऐसी जानकारी ढूंढता हो जो Wikipedia पर मौजूद नहीं है.
  • एक्सप्लोर करें CustomAgent: लैब में, उन वर्कफ़्लो के लिए CustomAgent का सुझाव दिया गया है जो स्टैंडर्ड टेंप्लेट के मुताबिक नहीं हैं. ऐसा एजेंट बनाएं जो किसी शर्त के हिसाब से काम करे. उदाहरण के लिए, कोई एजेंट सिर्फ़ तब काम करे, जब सेशन की स्थिति में कोई खास कुंजी मौजूद हो.