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

1. परिचय

खास जानकारी

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

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

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

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

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

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

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

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

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

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

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

हैरारकी के क्रम में एजेंट दिखाने वाली ट्री स्ट्रक्चर इमेज

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

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

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

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

Google खाता

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

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

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

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

Google Cloud के 500 रुपये के क्रेडिट रिडीम करें (ज़रूरी नहीं)

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

इस लिंक पर क्लिक करें और किसी निजी Google खाते से साइन इन करें.आपको कुछ ऐसा दिखेगा:
अपने क्रेडिट ऐक्सेस करने के लिए यहां क्लिक करें बटन पर क्लिक करें.इससे आपको बिलिंग प्रोफ़ाइल सेट अप करने वाले पेज पर ले जाया जाएगा
पुष्टि करें पर क्लिक करें

अब आपका खाता, Google Cloud Platform के मुफ़्त में आज़माए जाने वाले बिलिंग खाते से कनेक्ट हो गया है.

बिलिंग की खास जानकारी देने वाले पेज का स्क्रीनशॉट

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

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

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

ध्यान दें:

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

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

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

4. Cloud Shell Editor खोलें

सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
- देखें पर क्लिक करें
- टर्मिनल पर क्लिक करें
टर्मिनल में, इस कमांड का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
```
gcloud config set project [PROJECT_ID]
```
- उदाहरण:
```
gcloud config set project lab-project-id-example
```
- अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची देखी जा सकती है:
```
gcloud projects list
```
आपको यह मैसेज दिखेगा:
```
Updated property [core/project].
```
अगर आपको WARNING दिखता है और आपसे Do you want to continue (Y/n)? पूछा जाता है, तो हो सकता है कि आपने प्रोजेक्ट आईडी गलत डाला हो. n दबाएं, Enter दबाएं, और gcloud config set project निर्देश को फिर से चलाने की कोशिश करें.

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

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

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

Python के लिए Vertex AI SDK के बारे में जानकारी

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

Vertex AI SDK for Python के बारे में पूरी जानकारी देने वाला दस्तावेज़ यहां उपलब्ध है: Vertex AI SDK for Python के बारे में जानकारी | Google Cloud.

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

Repo का क्लोन बनाएं

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

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

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

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

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

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

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

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

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

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

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

Cloud Shell Editor में, adk_multiagent_systems/parent_and_subagents/agent.py खोलें. agent.py फ़ाइल में मौजूद तीन एजेंट देखें:
- root_agent (नाम steering): यह उपयोगकर्ता से एक सवाल पूछता है, ताकि यह तय किया जा सके कि उसे किस सब-एजेंट को ट्रांसफ़र करना है. शुरुआत में, यह सिर्फ़ अपने सब-एजेंट के description पर निर्भर करता है.
- travel_brainstormer: इससे उपयोगकर्ता को डेस्टिनेशन के बारे में सोचने में मदद मिलती है.
- attractions_planner: इससे उपयोगकर्ता को किसी देश में करने लायक चीज़ों की सूची बनाने में मदद मिलती है.
अहम जानकारी: बातचीत के फ़्लो के क्रम में agent.py फ़ाइल को पढ़ने के लिए, अक्सर सबसे आसान तरीका यह होता है कि आप सबसे नीचे मौजूद root_agent से पढ़ना शुरू करें और ऊपर की ओर बढ़ें. ऐसा इसलिए है, क्योंकि Python कोड के लिए ज़रूरी है कि हम किसी एजेंट में सब-एजेंट जोड़ने से पहले उन्हें तय करें.
travel_brainstormer और attractions_planner को root_agent का सब-एजेंट बनाएं. इसके लिए, root_agent बनाते समय यह लाइन जोड़ें:
```
    sub_agents=[travel_brainstormer, attractions_planner]
```
ध्यान दें: एजेंट के क्रम को सिर्फ़ पैरंट एजेंट की sub_agents सूची से तय किया जाता है. सब-एजेंट को parent पैरामीटर की ज़रूरत नहीं होती.
टर्मिनल में, अपने एजेंट से चैट करें:
```
cd ~/adk_multiagent_systems
adk run parent_and_subagents
```
टर्मिनल में [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?
```
अब टर्मिनल में एजेंट को यह निर्देश दें:
```
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 के आधार पर, कंट्रोल ट्रांसफ़र किया.
बातचीत खत्म करने के लिए, टर्मिनल में user: प्रॉम्प्ट पर, exit टाइप करें और ENTER दबाएं.

अब हम इस बारे में ज़्यादा जानकारी देते हैं. 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'.

टर्मिनल में, एजेंट को फिर से चलाएं:
```
adk run parent_and_subagents
```
टर्मिनल में [user]: प्रॉम्प्ट पर, यह टाइप करें:
```
hello
```
जवाब दें:
```
I would like to go to Japan.
```
आउटपुट का उदाहरण (आपका आउटपुट थोड़ा अलग हो सकता है):
```
[attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
```
Notice the transfer to attractions_planner, as guided by your new instructions.
अब इस जवाब के साथ जवाब दें:
```
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 का पीयर है. यह सुविधा डिफ़ॉल्ट रूप से चालू होती है.
अगर आपको ट्रांसफ़र की सुविधा बंद करनी है, तो attractions_planner एजेंट पर disallow_transfer_to_peers=True सेट करें.
उपयोगकर्ता के प्रॉम्प्ट पर, सेशन खत्म करने के लिए exit टाइप करें.

रीकैप

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

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

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

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

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

फ़ाइल adk_multiagent_systems/parent_and_subagents/agent.py पर वापस जाएं

# 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 करता है.

attractions_planner एजेंट में टूल जोड़ने के लिए, tools पैरामीटर जोड़ें:
```
    tools=[save_attractions_to_state]
```
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.
```
कर्ली ब्रेसिज़ में दिए गए सेक्शन पर ध्यान दें: { attractions? }. ADK की इस सुविधा, की टेंप्लेटिंग की मदद से, attractions कुंजी की वैल्यू को राज्य से एजेंट के प्रॉम्प्ट में डाला जाता है. ? इसे वैकल्पिक बनाता है. इससे, अगर कुंजी मौजूद नहीं है, तो गड़बड़ियां नहीं होती हैं.
टर्मिनल में यह कमांड डालकर, Agent Development Kit के वेब यूज़र इंटरफ़ेस को लॉन्च करें:
```
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)
```
ध्यान दें: अगर पोर्ट 8000 का इस्तेमाल किया जा रहा है, तो किसी दूसरे पोर्ट पर चलाया जा सकता है. उदाहरण के लिए: adk web --port 8001. अगले चरणों में, पोर्ट नंबर को अपडेट करना होगा, ताकि वह मैच हो सके.
Cloud Shell टर्मिनल में, नए टैब में वेब इंटरफ़ेस देखने के लिए, वेब प्रीव्यू बटन पर क्लिक करें और पोर्ट बदलें को चुनें.
पोर्ट नंबर 8000 डालें और बदलें और झलक देखें पर क्लिक करें. ADK Dev UI के साथ एक नया ब्राउज़र टैब खुलेगा.
बाईं ओर मौजूद कोई एजेंट चुनें ड्रॉपडाउन से, parent_and_subagents चुनें.
इनके साथ बातचीत शुरू करें: hello
जब एजेंट आपका अभिवादन करे, तो जवाब में यह लिखें:
```
I'd like to go to Egypt.
```
आपको attractions_planner पर रीडायरेक्ट किया जाएगा और वहां आपको देखने लायक जगहों की सूची मिलेगी.
कोई जगह चुनें. उदाहरण के लिए:
```
I'll go to the Sphinx
```
आपको इस तरह का जवाब मिलेगा: ठीक है, मैंने आपकी सूची में स्फ़िंक्स को सेव कर दिया है...
टूल के जवाब से बनाए गए इवेंट को देखने के लिए, जवाब वाले टूल बॉक्स (चेक मार्क के साथ दिखाया गया है) पर क्लिक करें.
ध्यान दें कि इसमें एक actions फ़ील्ड शामिल है. इसमें stateDelta शामिल है, जो स्थिति में हुए बदलावों के बारे में बताता है.
एजेंट की सूची में मौजूद किसी दूसरी जगह के बारे में जवाब दो.
बाईं ओर मौजूद नेविगेशन मेन्यू में, "X" पर क्लिक करके, उस इवेंट पर फ़ोकस करना बंद करें जिसकी आपने पहले जांच की थी.
बाईं ओर मौजूद साइडबार में, राज्य टैब पर क्लिक करें. अब आपको सेशन की स्थिति में attractions ऐरे दिखेगा. इसमें आपके चुने गए दोनों आइटम शामिल होने चाहिए.
इस मैसेज को एजेंट को भेजें:
```
What is on my list?
```
अब एजेंट को राज्य के हिसाब से जानकारी पढ़नी चाहिए और आपको सूची दिखानी चाहिए.
एजेंट के साथ एक्सपेरिमेंट करने के बाद, वेब ब्राउज़र टैब बंद करें. इसके बाद, सर्वर को रोकने के लिए 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 मल्टी-एजेंट सिस्टम का पहला चरण

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

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

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

सेक्शन रीकैप

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

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

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

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

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

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

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

adk_multiagent_systems/workflow_agents/agent.py में, exit_loop के लिए इंपोर्ट जोड़ें (अन्य google.adk इंपोर्ट के पास):
```
from google.adk.tools import exit_loop
```

नया 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]
)

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,
)
```
max_iterations=5 पैरामीटर को नोट करें. यह एक ज़रूरी सुरक्षा रेल है. इससे इनफ़िनिट लूप को रोकने में मदद मिलती है. भले ही, आपके पास एग्ज़िट की शर्त हो.
नए 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
    ],
)
```
ADK Dev UI टैब पर वापस जाएं और सबसे ऊपर दाईं ओर मौजूद, + नया सेशन पर क्लिक करें.
इनके साथ नई बातचीत शुरू करें: hello
जब आपसे पूछा जाए, तो एजेंट को इस बार कोई बड़ा विषय बताएं. यहां कुछ आइडिया दिए गए हैं:
- एक इंडस्ट्रियल डिज़ाइनर, जिसने आम लोगों के लिए प्रॉडक्ट बनाए
- कार्टोग्राफ़र (नक्शा बनाने वाला)
- उस व्यक्ति के बारे में बताओ जिसने फ़सलों से ज़्यादा खाना पैदा किया
अब एजेंट, लूप के ज़रिए काम करेगा. ADK Dev UI में, एजेंट के कई बार चलने पर आपको लॉग दिखेंगे. जैसे, "[researcher]", "[screenwriter]", "[critic]", "[researcher]", "[screenwriter]", "[critic]...").
लूप पूरा होने पर, एजेंट फ़ाइल लिखेगा. adk_multiagent_systems/movie_pitches डायरेक्ट्री में जनरेट की गई फ़ाइल की समीक्षा करें.
लूप स्ट्रक्चर देखने के लिए, Dev UI में इवेंट ग्राफ़ की जांच करें.

सेक्शन रीकैप

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

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

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

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

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

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

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

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

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

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
    ]
)

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
    ],
)
```

एजेंट के 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? }
    """,

ADK Dev UI टैब पर वापस जाएं और + नया सेशन पर क्लिक करें.
बातचीत शुरू करने के लिए, hello डालें.
जब आपसे कहा जाए, तब किरदार के लिए कोई नया आइडिया डालें. यहां कुछ आइडिया दिए गए हैं:
- उस ऐक्ट्रेस के बारे में जानकारी दो जिसने वाई-फ़ाई की टेक्नोलॉजी का आविष्कार किया था
- एक बेहतरीन शेफ़
- दुनिया के सबसे बड़े मेलों की प्रदर्शनी में अहम भूमिका निभाने वाले लोग
जब एजेंट अपना काम पूरा कर लेता है, तब 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 का सुझाव दिया गया है जो स्टैंडर्ड टेंप्लेट के हिसाब से नहीं हैं. ऐसा एजेंट बनाएं जो किसी खास शर्त के पूरा होने पर ही काम करे. उदाहरण के लिए, कोई एजेंट सिर्फ़ तब काम करे, जब सेशन की स्थिति में कोई खास कुंजी मौजूद हो.

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

1. परिचय

खास जानकारी

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

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

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

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

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

Google खाता

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

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

Google Cloud के 500 रुपये के क्रेडिट रिडीम करें (ज़रूरी नहीं)

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

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

4. Cloud Shell Editor खोलें

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

Python के लिए Vertex AI SDK के बारे में जानकारी

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

Repo का क्लोन बनाएं

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

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

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

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

रीकैप

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

सेक्शन रीकैप

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

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

सेक्शन रीकैप

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

सेक्शन रीकैप

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

सेक्शन रीकैप

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

14. बधाई हो!

रीकैप

लगातार एक्सपेरिमेंट करना