🤖 Graph RAG, ADK, और Memory Bank की मदद से मल्टीमॉडल एआई एजेंट बनाना

1. परिचय

1. चुनौती

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

1. 🗄️ ग्राफ़ डेटाबेस (Spanner): सर्वाइवर, कौशल, और संसाधनों के बीच जटिल संबंधों को सेव करना
2. 🔍 एआई की मदद से खोज: एम्बेडिंग का इस्तेमाल करके, सिमैंटिक और कीवर्ड हाइब्रिड सर्च
3. 📸 मल्टीमॉडल प्रोसेसिंग: इमेज, टेक्स्ट, और वीडियो से स्ट्रक्चर्ड डेटा निकालना
4. 🤖 मल्टी-एजेंट ऑर्केस्ट्रेशन: मुश्किल वर्कफ़्लो के लिए, खास एजेंटों के साथ मिलकर काम करना
5. 🧠 लॉन्ग-टर्म मेमोरी: Vertex AI Memory Bank की मदद से, लोगों की दिलचस्पी के हिसाब से जानकारी देना

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

सर्वाइवर नेटवर्क ग्राफ़ डेटाबेस, जिसमें ये शामिल हैं:

• 🗺️ सर्वाइवर के संबंधों का 3D इंटरैक्टिव ग्राफ़ विज़ुअलाइज़ेशन
• 🔍 इंटेलिजेंट सर्च (कीवर्ड, सिमैंटिक, और हाइब्रिड)
• 📸 मल्टीमॉडल अपलोड पाइपलाइन (इमेज/वीडियो से इकाइयां निकालना)
• 🤖 मुश्किल टास्क को व्यवस्थित करने के लिए, मल्टी-एजेंट सिस्टम
• 🧠 मेमोरी बैंक इंटिग्रेशन की मदद से, अपनी पसंद के मुताबिक इंटरैक्शन करें

3. मुख्य टेक्नोलॉजी

कॉम्पोनेंट	टेक्नोलॉजी	मकसद
डेटाबेस	Cloud Spanner Graph	नोड (सर्वाइवर, स्किल) और एज (रिश्ते) सेव करता है
एआई की मदद से खोज करने की सुविधा	Gemini + Embeddings	सिमैंटिक अंडरस्टैंडिंग + मिलते-जुलते कॉन्टेंट की खोज
एजेंट फ़्रेमवर्क	ADK (एजेंट डेवलपमेंट किट)	एआई वर्कफ़्लो को व्यवस्थित करना
मेमोरी	Vertex AI Memory Bank	उपयोगकर्ता की प्राथमिकता को लंबे समय तक सेव करना
Frontend	React + Three.js	इंटरैक्टिव 3D ग्राफ़ विज़ुअलाइज़ेशन

2. एनवायरमेंट तैयार करना (अगर आपने वर्कशॉप में हिस्सा लिया है, तो इसे छोड़ दें)

अगर आपने Google WayBackHome Workshop में हिस्सा लिया है और लेवल 0 और लेवल 1 पहले ही पूरा कर लिया है, तो कृपया इस सेशन को छोड़ दें!

पहला हिस्सा: बिलिंग खाता चालू करना

• पांच डॉलर के क्रेडिट के साथ बिलिंग खाते पर दावा करें. आपको इसकी ज़रूरत डिप्लॉयमेंट के लिए पड़ेगी. पक्का करें कि आपने अपने gmail खाते से साइन इन किया हो.

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

दूसरा हिस्सा: ओपन एनवायरमेंट

1. 👉 सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
2. 👉 अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
3. 👉 अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
   • देखें पर क्लिक करें
   • टर्मिनल पर क्लिक करें
4. 👉💻 टर्मिनल में, पुष्टि करें कि आपने पहले ही पुष्टि कर ली है और प्रोजेक्ट को अपने प्रोजेक्ट आईडी पर सेट किया गया है. इसके लिए, यह कमांड इस्तेमाल करें:

   gcloud auth list
   

5. 👉💻 GitHub से बूटस्ट्रैप प्रोजेक्ट का क्लोन बनाएं:

   git clone https://github.com/google-americas/way-back-home.git
   

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

1. शुरू करें

अगर Cloud Shell Editor टर्मिनल में, स्क्रीन के सबसे नीचे टर्मिनल नहीं दिखता है, तो इसे खोलें:

• देखें पर क्लिक करें
• टर्मिनल पर क्लिक करें

अगर आप वर्कशॉप में हैं और आपको पता चलता है कि आप (.venv) में हैं, तो आगे बढ़ने से पहले deactivate ज़रूर करें.

👉💻 टर्मिनल में, init स्क्रिप्ट को एक्ज़ीक्यूटेबल बनाएं और उसे चलाएं:

cd ~/way-back-home/level_2
./init.sh

⚠️ प्रोजेक्ट आईडी के बारे में जानकारी: स्क्रिप्ट आपको नया Google Cloud प्रोजेक्ट बनाने के लिए कहेगी. आपके पास, डिफ़ॉल्ट रूप से रैंडम तरीके से जनरेट हुए प्रोजेक्ट आईडी को स्वीकार करने या अपना प्रोजेक्ट आईडी डालने का विकल्प होता है.

2. प्रोजेक्ट कॉन्फ़िगर करना

👉💻 अपना प्रोजेक्ट आईडी सेट करें:

gcloud config set project $(cat ~/project_id.txt) --quiet

👉💻 ज़रूरी एपीआई चालू करें. इसमें करीब दो से तीन मिनट लगते हैं:

gcloud services enable compute.googleapis.com \
                       aiplatform.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       spanner.googleapis.com \
                       storage.googleapis.com

3. सेटअप स्क्रिप्ट चलाना

👉💻 सेटअप स्क्रिप्ट को लागू करें:

cd ~/way-back-home/level_2
./setup.sh

इससे आपके लिए .env बन जाएगा. अपने Cloud Shell में, way_back_homeproject खोलें. level_2 फ़ोल्डर में, आपको .env फ़ाइल दिखेगी. अगर आपको यह विकल्प नहीं मिलता है, तो इसे देखने के लिए View -> Toggle Hidden File पर क्लिक करें.

4. सैंपल डेटा लोड करें

👉💻 बैकएंड पर जाएं और डिपेंडेंसी इंस्टॉल करें:

cd ~/way-back-home/level_2/backend
uv sync

👉💻 सर्वाइवर का शुरुआती डेटा लोड करें:

uv run python ~/way-back-home/level_2/backend/setup_data.py

इससे ये जनरेट होते हैं:

• Spanner इंस्टेंस (survivor-network)
• डेटाबेस (graph-db)
• सभी नोड और एज टेबल
• क्वेरी करने के लिए प्रॉपर्टी ग्राफ़ अनुमानित आउटपुट:

============================================================
SUCCESS! Database setup complete.
============================================================

Instance:  survivor-network
Database:  graph-db
Graph:     SurvivorGraph

Access your database at:
https://console.cloud.google.com/spanner/instances/survivor-network/databases/graph-db?project=waybackhome

आउटपुट में Access your database at के बाद दिए गए लिंक पर क्लिक करके, Google Cloud Console Spanner खोला जा सकता है.

इसके बाद, आपको Google Cloud Console में Spanner दिखेगा!

4. Spanner Studio में ग्राफ़ डेटा को विज़ुअलाइज़ करना

इस गाइड की मदद से, Spanner Studio का इस्तेमाल करके, Google Cloud Console में सीधे तौर पर सर्वाइवर नेटवर्क के ग्राफ़ डेटा को विज़ुअलाइज़ किया जा सकता है और उसके साथ इंटरैक्ट किया जा सकता है. यह आपके डेटा की पुष्टि करने और एआई एजेंट बनाने से पहले, ग्राफ़ के स्ट्रक्चर को समझने का शानदार तरीका है.

1. Spanner Studio को ऐक्सेस करना

1. आखिरी चरण में, पक्का करें कि आपने लिंक पर क्लिक करके Spanner Studio खोला हो.

2. ग्राफ़ के स्ट्रक्चर को समझना ("बड़ी तस्वीर")

Survivor Network के डेटासेट को लॉजिक पज़ल या गेम की स्थिति के तौर पर समझें:

इकाई	सिस्टम में भूमिका	उपमा
Survivors	एजेंट/खिलाड़ी	खिलाड़ी
बायोम	वे कहां मौजूद हैं	मैप ज़ोन
स्किल	वे क्या-क्या कर सकते हैं	क्षमताएं
ज़रूरी है	उनमें क्या कमी है (संकट)	क्वेस्ट/मिशन
संसाधन	दुनिया भर में मिले आइटम	लूट

लक्ष्य: एआई एजेंट का काम, बायोम (जगह की पाबंदियां) को ध्यान में रखते हुए, ज़रूरतों (समस्याओं) को स्किल (समाधान) से जोड़ना है.

🔗 एज (संबंध):

• SurvivorInBiome: जगह की जानकारी ट्रैक करना
• SurvivorHasSkill: क्षमताओं की इन्वेंट्री
• SurvivorHasNeed: चालू समस्याओं की सूची
• SurvivorFoundResource: आइटम की इन्वेंट्री
• SurvivorCanHelp: अनुमानित संबंध (एआई इसका हिसाब लगाता है!)

3. ग्राफ़ से क्वेरी करना

आइए, कुछ क्वेरी चलाकर डेटा में "स्टोरी" देखते हैं.

Spanner Graph, GQL (ग्राफ़ क्वेरी लैंग्वेज) का इस्तेमाल करता है. क्वेरी चलाने के लिए, GRAPH SurvivorNetwork का इस्तेमाल करें. इसके बाद, मैच पैटर्न डालें.

👉 पहली क्वेरी: ग्लोबल रोस्टर (कौन कहां है?) यह आपकी बुनियादी जानकारी है. बचाव के लिए जगह की जानकारी को समझना ज़रूरी है.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[:SurvivorInBiome]->(b:Biomes)
RETURN TO_JSON(result) AS json_result

आपको इस तरह का नतीजा दिखेगा:

यह ज़रूरी क्यों है:

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

👉 दूसरी क्वेरी: स्किल मैट्रिक्स (क्षमताएं) अब आपको पता चल गया है कि हर व्यक्ति कहां है. अब यह पता लगाएं कि वह क्या कर सकता है.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasSkill]->(k:Skills)
RETURN TO_JSON(result) AS json_result

आपको इस तरह का नतीजा दिखेगा:

यह ज़रूरी क्यों है:

• डिस्पैचर के लिए: एक नज़र में अपने डॉक्टर, इंजीनियर, और नेविगेटर की पहचान करें.
• एआई एजेंट के लिए: जब कोई व्यक्ति "प्राथमिक चिकित्सा के बारे में कौन जानता है?" पूछता है, तो यह क्वेरी उसे ढूंढती है.
• एक्सपर्ट लेवल: ध्यान दें कि h में proficiency प्रॉपर्टी (एक्सपर्ट/प्रोफ़ेशनल/बेसिक) है. ग्राफ़ में संबंध का मेटाडेटा सेव होता है!

👉 तीसरी क्वेरी: संकट में कौन है? (The "Mission Board") देखें कि किन लोगों को मदद की ज़रूरत है और उन्हें किस तरह की मदद चाहिए.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasNeed]->(n:Needs)
RETURN TO_JSON(result) AS json_result

आपको इस तरह का नतीजा दिखेगा:

यह ज़रूरी क्यों है:

• डिसपैचर के लिए: ज़रूरी होने के हिसाब से बचाव मिशन को प्राथमिकता दें.
• एआई एजेंट के लिए: यह "कामों की सूची" है. इसमें वे समस्याएं शामिल हैं जिन्हें हल किया जाना है.

🔎 ऐडवांस: मैचमेकिंग - कौन किसकी मदद कर सकता है?

ग्राफ़ का इस्तेमाल करने से, आपको यहां काफ़ी फ़ायदा मिल सकता है! इस क्वेरी से, ऐसे सर्वाइवर का पता चलता है जिनके पास ऐसी स्किल हैं जिनसे वे दूसरे सर्वाइवर की ज़रूरतों को पूरा कर सकते हैं.

GRAPH SurvivorNetwork
MATCH result = (helper:Survivors)-[:SurvivorHasSkill]->(skill:Skills)-[:SkillTreatsNeed]->(need:Needs)<-[:SurvivorHasNeed]-(helpee:Survivors)
RETURN TO_JSON(result) AS json_result

आपको इस तरह का नतीजा दिखेगा:

aside positive इस क्वेरी से क्या होता है:

सिर्फ़ "फ़र्स्ट एड से जलने का इलाज किया जाता है" (जो स्कीमा से साफ़ तौर पर पता चलता है) दिखाने के बजाय, यह क्वेरी यह जानकारी ढूंढती है:

• डॉक्टर एलीना फ़्रॉस्ट (जिन्होंने मेडिकल ट्रेनिंग ली है) → इलाज कर सकती हैं → कैप्टन Tanaka (जिन्हें जलने की समस्या है)
• डेविड चेन (जिसके पास प्राथमिक चिकित्सा का सामान है) → इलाज कर सकता है → लेफ़्टिनेंट पार्क (जिसके टखने में मोच आई है)

यह तरीका क्यों कारगर है:

ग्राफ़ का फ़ायदा: यह चार हॉप ट्रैवर्सल है:

1. किसी हेल्पर (सर्वाइवर) से शुरुआत करना
2. उनकी स्किल ढूंढना
3. उन हुनर को उन ज़रूरतों से मैच करें जिनके लिए वे काम करते हैं
4. ऐसे सर्वाइवर ढूंढें जिनकी ये ज़रूरतें हैं

ग्राफ़ के बिना, आपको ये काम करने होंगे:

• SurvivorHasSkill टेबल से क्वेरी करें → स्किल पाएं
• Query SkillTreatsNeed table → find which needs match
• SurvivorHasNeed टेबल से क्वेरी करना → पता लगाना कि किन लोगों को उन ज़रूरतों की ज़रूरत है
• ऐप्लिकेशन कोड में सभी नतीजों को शामिल करें

Spanner Graph की मदद से, यह एक ही क्वेरी होती है, जिसे डेटाबेस आपके लिए ऑप्टिमाइज़ करता है.

एआई एजेंट क्या करेगा:

जब कोई उपयोगकर्ता "जले हुए घावों का इलाज कौन कर सकता है?" पूछता है, तो एजेंट:

1. मिलती-जुलती ग्राफ़ क्वेरी चलाना
2. जवाब: "डॉक्टर फ़्रॉस्ट के पास मेडिकल ट्रेनिंग है और वे कैप्टन Tanaka की मदद कर सकते हैं"
3. उपयोगकर्ता को इंटरमीडिएट टेबल या रिलेशनशिप के बारे में जानने की ज़रूरत नहीं है!

5. Spanner में एआई की मदद से जनरेट किए गए एम्बेडिंग

1. एंबेडिंग क्यों ज़रूरी हैं? (कोई कार्रवाई नहीं, सिर्फ़ पढ़ने के लिए)

सर्वाइवल के मामले में, समय बहुत अहम होता है. जब कोई पीड़ित व्यक्ति I need someone who can treat burns या Looking for a medic जैसी आपातकालीन स्थिति की शिकायत करता है, तो वह डेटाबेस में मौजूद कौशल के सटीक नाम का अनुमान लगाने में समय बर्बाद नहीं कर सकता.

पारंपरिक खोज से जुड़ी समस्या:

• एग्ज़ैक्ट मैचिंग: "डॉक्टर" के लिए की गई कीवर्ड खोज में, "मेडिकल ट्रेनिंग" या "प्राथमिक चिकित्सा" नहीं मिलेगा
• शब्दावली का मेल न खाना: यौन शोषण के शिकार लोग "डॉक्टर", "हीलर", "पैरामेडिक" जैसे शब्दों का इस्तेमाल कर सकते हैं, लेकिन डेटाबेस में कौशल के औपचारिक नाम सेव किए जाते हैं
• संदर्भ की जानकारी का न होना: "जले हुए घावों का इलाज" के लिए, "मेडिकल ट्रेनिंग" और "प्राथमिक चिकित्सा" दोनों को ढूंढना चाहिए. हालांकि, सामान्य टेक्स्ट खोज से सिमैंटिक संबंध समझ में नहीं आएगा

समाधान: एम्बेड किए जा रहे डेटा के साथ सिमैंटिक सर्च: एम्बेड किए जा रहे डेटा से टेक्स्ट को 768 डाइमेंशनल वेक्टर में बदला जाता है. इससे सिर्फ़ स्पेलिंग ही नहीं, बल्कि मतलब भी पता चलता है. वेक्टर स्पेस में मिलते-जुलते कॉन्सेप्ट एक साथ क्लस्टर होते हैं. इसलिए, "medic" के लिए "Medical Training" अपने-आप मिल जाता है, भले ही दोनों में कोई शब्द एक जैसा न हो.

असल स्थिति: सर्वाइवर: Captain Tanaka has burns—we need medical help NOW!

"डॉक्टर" के लिए, कीवर्ड के हिसाब से खोज करने पर → 0 नतीजे मिले ❌

एम्बेडिंग के साथ सिमैंटिक सर्च → "मेडिकल ट्रेनिंग" और "प्राथमिक चिकित्सा" का पता लगाता है ✅

एजेंट को ठीक इसी तरह की इंटेलिजेंट, इंसानों जैसी खोज की ज़रूरत होती है. यह खोज, सिर्फ़ कीवर्ड को नहीं, बल्कि इंटेंट को भी समझती है.

Spanner का इस्तेमाल क्यों करें?: डेटा को Python में एक्सपोर्ट करने, बाहरी तौर पर एम्बेडिंग जनरेट करने, और उन्हें फिर से इंपोर्ट करने (धीमी प्रोसेस, गड़बड़ी होने की आशंका) के बजाय, Spanner के ML.PREDICT फ़ंक्शन का इस्तेमाल करके ये काम किए जा सकते हैं:

• Vertex AI मॉडल का इस्तेमाल करके, एसक्यूएल में सीधे तौर पर एम्बेडिंग जनरेट करना
• वेक्टर को ग्राफ़ डेटा के साथ स्टोर करें (कोई अलग वेक्टर डेटाबेस नहीं)
• ग्राफ़ ट्रैवर्सल के दौरान, रीयल-टाइम में सिमैंटिक सर्च क्वेरी करना

इससे एक बेहतर Graph RAG सिस्टम बनता है: ग्राफ़ रिलेशनशिप (किसके पास कौनसी स्किल है) + सिमैंटिक सर्च (मतलब के हिसाब से स्किल ढूंढना) = इंटेलिजेंट एजेंट क्वेरी.

2. एम्बेडिंग मॉडल बनाना

ML.PREDICT क्या है?

ML.PREDICT, Spanner का एक बिल्ट-इन फ़ंक्शन है. इसकी मदद से, मशीन लर्निंग मॉडल को सीधे तौर पर SQL से कॉल किया जा सकता है. इसके लिए, Python, एक्सपोर्ट/इंपोर्ट या अलग-अलग सेवाओं की ज़रूरत नहीं होती. इसे रीयल-टाइम में अपने डेटाबेस और Vertex AI को जोड़ने के तौर पर समझें.

यह सुविधा कैसे काम करती है:

1. Spanner में वर्चुअल मॉडल बनाया जाता है. यह सिर्फ़ एक रेफ़रंस होता है. मॉडल के वेट को स्थानीय तौर पर सेव नहीं किया जाता
2. किसी क्वेरी में ML.PREDICT(model, data) का इस्तेमाल करने पर, Spanner आपके डेटा को एपीआई के ज़रिए Vertex AI को भेजता है
3. Vertex AI इसे प्रोसेस करता है और SQL क्वेरी के नतीजे में कॉलम के तौर पर नतीजे दिखाता है

यह तरीका असरदार क्यों है:

• ✅ ज़ीरो-ईटीएल: डेटा को प्रोसेस करने के लिए, उसे Python स्क्रिप्ट में एक्सपोर्ट करने की ज़रूरत नहीं होती
• ✅ रीयल-टाइम: क्वेरी के दौरान, एम्बेडिंग या एलएलएम के जवाब तुरंत जनरेट करें
• ✅ स्केल करने लायक: Spanner, ऑर्केस्ट्रेशन को मैनेज करता है और Vertex AI, कंप्यूट को मैनेज करता है

अब हम एक ऐसा मॉडल बनाते हैं जो Google के text-embedding-004 का इस्तेमाल करके, टेक्स्ट को एम्बेडिंग में बदलता है.

👉 Spanner Studio में, इस एसक्यूएल को चलाएं ($YOUR_PROJECT_ID की जगह अपना असल प्रोजेक्ट आईडी डालें):

$YOUR_PROJECT_ID को बदलना न भूलें. आपको .env फ़ाइल में अपना असल प्रोजेक्ट आईडी मिल सकता है

‼️ पूरे प्रोजेक्ट को देखने के लिए, Cloud Shell एडिटर में File -> Open Folder -> way-back-home/level_2 खोलें.

👉 इस क्वेरी को Spanner Studio में चलाने के लिए, यहां दी गई क्वेरी को कॉपी करके चिपकाएं. इसके बाद, 'चलाएं' बटन पर क्लिक करें:

CREATE MODEL TextEmbeddings
INPUT(content STRING(MAX))
OUTPUT(embeddings STRUCT<values ARRAY<FLOAT32>>)
REMOTE OPTIONS (
    endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004'
);

अगर आपने $YOUR_PROJECT_ID को बदलना भूल गए हैं और आपने पहले ही इसे चला लिया है, तो दोबारा कोशिश करने से पहले DROP MODEL TextEmbeddings; को बदल लें.

यह क्या करता है:

• Spanner में वर्चुअल मॉडल बनाता है. इसमें मॉडल के वेट को लोकल तौर पर सेव नहीं किया जाता
• Vertex AI पर Google के text-embedding-004 पर ले जाता है
• कॉन्ट्रैक्ट तय करता है: इनपुट टेक्स्ट होता है और आउटपुट 768 डाइमेंशन वाला फ़्लोट ऐरे होता है

"REMOTE OPTIONS" का इस्तेमाल क्यों करना चाहिए?

• Spanner, मॉडल को खुद नहीं चलाता है
• ML.PREDICT का इस्तेमाल करने पर, यह एपीआई के ज़रिए Vertex AI को कॉल करता है
• ज़ीरो-ईटीएल: डेटा को Python में एक्सपोर्ट करने, प्रोसेस करने, और फिर से इंपोर्ट करने की ज़रूरत नहीं होती

सर्टिफ़िकेट जनरेट होने के बाद, Run बटन पर क्लिक करें. इसके बाद, आपको नीचे दिया गया नतीजा दिखेगा:

इससे एक "वर्चुअल मॉडल" बनता है, जो Vertex AI के text-embedding-004 को रेफ़रंस करता है. Spanner से कोई डेटा बाहर नहीं जाता. इसे एपीआई के ज़रिए कॉल किया जाता है.

3. Embedding Column जोड़ें

👉 एम्बेडिंग सेव करने के लिए कॉलम जोड़ें:

ALTER TABLE Skills ADD COLUMN skill_embedding ARRAY<FLOAT32>;

सर्टिफ़िकेट जनरेट होने के बाद, Run बटन पर क्लिक करें. इसके बाद, आपको नीचे दिया गया नतीजा दिखेगा:

4. एम्बेडिंग जनरेट करना

👉 हर स्किल के लिए वेक्टर एम्बेडिंग बनाने के लिए, एआई का इस्तेमाल करें:

UPDATE Skills
SET skill_embedding = (
    SELECT embeddings.values
    FROM ML.PREDICT(
        MODEL TextEmbeddings,
        (SELECT name AS content)
    )
)
WHERE skill_embedding IS NULL;

सर्टिफ़िकेट जनरेट होने के बाद, Run बटन पर क्लिक करें. इसके बाद, आपको नीचे दिया गया नतीजा दिखेगा:

अगर आपको अनुमति से जुड़ी गड़बड़ी दिखती है, तो कृपया दूसरा चरण एम्बेडिंग मॉडल बनाएं फिर से करें. पक्का करें कि आपने इसे फिर से आज़माने से पहले DROP MODEL TextEmbeddings; कर लिया हो.

क्या होता है: हर स्किल का नाम (जैसे, "प्राथमिक चिकित्सा") को 768 डाइमेंशन वाले वेक्टर में बदल दिया जाता है. यह वेक्टर, इसके सिमैंटिक मतलब को दिखाता है.

5. एम्बेड किए गए कॉन्टेंट की पुष्टि करना

👉 पुष्टि करें कि एम्बेड किए गए हैं या नहीं:

SELECT 
    skill_id,
    name,
    ARRAY_LENGTH(skill_embedding) AS embedding_dimensions
FROM Skills
LIMIT 5;

अनुमानित आउटपुट:

6. सिमैंटिक सर्च की सुविधा आज़माना

अब हम अपने उदाहरण के हिसाब से, इस्तेमाल के सटीक मामले की जांच करते हैं: "मेडिक" शब्द का इस्तेमाल करके, चिकित्सा से जुड़ी स्किल ढूंढना.

👉 "डॉक्टर" से मिलती-जुलती स्किल ढूंढें:

WITH query_embedding AS (
    SELECT embeddings.values AS val
    FROM ML.PREDICT(MODEL TextEmbeddings, (SELECT "medic" AS content))
)
SELECT
    s.name AS skill_name,
    s.category,
    COSINE_DISTANCE(s.skill_embedding, (SELECT val FROM query_embedding)) AS distance
FROM Skills AS s
WHERE s.skill_embedding IS NOT NULL
ORDER BY distance ASC
LIMIT 10;

• यह कुकी, उपयोगकर्ता के खोज शब्द "medic" को एम्बेडिंग में बदलती है
• इसे query_embedding अस्थायी टेबल में सेव करता है

अनुमानित नतीजे (कम दूरी = ज़्यादा मिलते-जुलते):

7. विश्लेषण के लिए Gemini मॉडल बनाना

👉 जनरेटिव एआई मॉडल का रेफ़रंस बनाएं ($YOUR_PROJECT_ID को अपने प्रोजेक्ट आईडी से बदलें):

$YOUR_PROJECT_ID को बदलना न भूलें. आपको .env फ़ाइल में अपना असल प्रोजेक्ट आईडी मिल सकता है

CREATE MODEL GeminiPro
INPUT(prompt STRING(MAX))
OUTPUT(content STRING(MAX))
REMOTE OPTIONS (
    endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/gemini-2.5-pro',
    default_batch_size = 1
);

अगर आपने $YOUR_PROJECT_ID को बदलना भूल गए हैं और आपने पहले ही इसे चला लिया है, तो > पक्का करें कि आपने इसे फिर से चलाने से पहले DROP MODEL GeminiPro; कर लिया हो.

एम्बेड किए जा रहे मॉडल से अंतर:

• एम्बेड करना: टेक्स्ट → वेक्टर (समानता खोजने के लिए)
• Gemini: टेक्स्ट → जनरेट किया गया टेक्स्ट (तर्क/विश्लेषण के लिए)

8. Gemini का इस्तेमाल करके, कंपैटिबिलिटी का विश्लेषण करना

👉 मिशन के साथ काम करने वाले सर्वाइवर के जोड़े का विश्लेषण करें:

WITH PairData AS (
    SELECT
        s1.name AS Name_A,
        s2.name AS Name_B,
        CONCAT(
            "Assess compatibility of these two survivors for a resource-gathering mission. ",
            "Survivor 1: ", s1.name, ". ",
            "Survivor 2: ", s2.name, ". ",
            "Give a score from 1-10 and a 1-sentence reason."
        ) AS prompt
    FROM Survivors s1
    JOIN Survivors s2 ON s1.survivor_id < s2.survivor_id
    LIMIT 1
)
SELECT
    Name_A,
    Name_B,
    content AS ai_assessment
FROM ML.PREDICT(
    MODEL GeminiPro,
    (SELECT Name_A, Name_B, prompt FROM PairData)
);

अनुमानित आउटपुट:

Name_A          | Name_B            | ai_assessment
----------------|-------------------|----------------
"David Chen"    | "Dr. Elena Frost" | "**Score: 9/10** Their compatibility is extremely high as David's practical, hands-on scavenging skills are perfectly complemented by Dr. Frost's specialized knowledge to identify critical medical supplies and avoid biological hazards."

यह सुविधा कैसे काम करती है:

1. डेटा के आधार पर प्रॉम्प्ट बनाना:

CONCAT("Assess compatibility...", "Survivor 1: ", s1.name, ...)

नतीजा: "Assess compatibility of these two survivors for a resource-gathering mission. Survivor 1: David Chen. Survivor 2: Dr. Elena Frost. Give a score from 1-10 and a 1-sentence reason."

2. Gemini को भेजें:

ML.PREDICT(MODEL GeminiPro, (SELECT prompt FROM PairData))

Spanner, Gemini API को प्रॉम्प्ट भेजता है.

3. Gemini से जवाब जनरेट करना:

"**Score: 9/10** Their compatibility is extremely high as David's practical, 
hands-on scavenging skills are perfectly complemented by Dr. Frost's specialized 
knowledge to identify critical medical supplies and avoid biological hazards."

4. कॉलम के तौर पर दिखाएं: जनरेट किया गया टेक्स्ट, content कॉलम के तौर पर दिखाया जाता है.

डेटाबेस में मौजूद एलएलएम को कॉल क्यों करें?

• डेटा को Python में एक्सपोर्ट करने की ज़रूरत नहीं है
• डेटा को उसी जगह प्रोसेस करें जहां वह मौजूद है
• लाखों लाइनों को प्रोसेस किया जा सकता है (बैच प्रोसेसिंग)

6. हाइब्रिड सर्च की मदद से, अपना Graph RAG एजेंट बनाना

1. सिस्टम आर्किटेक्चर की खास जानकारी

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

तीन लेयर क्यों?

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

इस सेक्शन में, आपको मुख्य रूप से सिमेंटिक सर्च (आरएजी) लागू करनी होगी. इसका मतलब है कि आपको सिर्फ़ कीवर्ड के आधार पर नहीं, बल्कि मतलब के आधार पर नतीजे ढूंढने होंगे. इसके बाद, हम बताएंगे कि हाइब्रिड सर्च में कई तरीकों को कैसे मर्ज किया जाता है.

2. RAG सेवा लागू करना

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/services/hybrid_search_service.py

टिप्पणी ढूंढना # TODO: REPLACE_SQL

इस पूरी लाइन की जगह यह कोड डालें:

        # This is your working query from the successful run!
        sql = """
            WITH query_embedding AS (
                SELECT embeddings.values AS val
                FROM ML.PREDICT(
                    MODEL TextEmbeddings,
                    (SELECT @query AS content)
                )
            )
            SELECT
                s.survivor_id,
                s.name AS survivor_name,
                s.biome,
                sk.skill_id,
                sk.name AS skill_name,
                sk.category,
                COSINE_DISTANCE(
                    sk.skill_embedding, 
                    (SELECT val FROM query_embedding)
                ) AS distance
            FROM Survivors s
            JOIN SurvivorHasSkill shs ON s.survivor_id = shs.survivor_id
            JOIN Skills sk ON shs.skill_id = sk.skill_id
            WHERE sk.skill_embedding IS NOT NULL
            ORDER BY distance ASC
            LIMIT @limit
        """

इस क्वेरी से क्या होता है:

यह Graph RAG क्वेरी है, जिसमें दो बेहतरीन तकनीकों का इस्तेमाल किया गया है:

1. ग्राफ़ रिलेशनशिप (Spanner की ग्राफ़ टेबल पर SQL JOIN के ज़रिए)
2. सिमैंटिक सर्च (एम्बेडिंग और COSINE_DISTANCE के ज़रिए)

क्या यह सिर्फ़ एसक्यूएल है?

हां! Spanner Graph की मदद से, JOIN स्टेटमेंट के साथ स्टैंडर्ड एसक्यूएल का इस्तेमाल करके, ग्राफ़ के संबंधों के बारे में क्वेरी की जा सकती है. ग्राफ़ स्ट्रक्चर (सर्वाइवर → SurvivorHasSkill एज के ज़रिए स्किल) को रिलेशनल टेबल में सेव किया जाता है. इन टेबल को एक साथ जोड़ा जा सकता है. यह पारंपरिक ग्राफ़ डेटाबेस से अलग है. इसके लिए, Cypher या Gremlin जैसी खास क्वेरी भाषाओं की ज़रूरत होती है.

इसे "ग्राफ़ आरएजी" क्यों कहा जाता है:

• ग्राफ़: हम ग्राफ़ स्ट्रक्चर में सेव किए गए संबंधों (सर्वाइवर → स्किल) को ट्रैवर्स कर रहे हैं
• RAG: हम एम्बेडिंग का इस्तेमाल करके, अर्थ के हिसाब से मिलता-जुलता कॉन्टेंट (रिट्रीवल ऑगमेंटेड जनरेशन) वापस पा रहे हैं
• नतीजा: ग्राफ़ कनेक्शन के हिसाब से, पीड़ितों की उन क्षमताओं के मतलब के आधार पर उन्हें खोजें

उदाहरण: "medic" के लिए क्वेरी → "मेडिकल ट्रेनिंग" या "प्राथमिक चिकित्सा" के कौशल वाले लोगों को ढूंढता है. भले ही, डेटाबेस में "medic" शब्द मौजूद न हो.

3. सिमैंटिक सर्च टूल के बारे में जानकारी

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/agent/tools/hybrid_search_tools.py

hybrid_search_tools.py में, टिप्पणी # TODO: REPLACE_SEMANTIC_SEARCH_TOOL ढूंढें

👉इस पूरी लाइन की जगह यह कोड डालें:

async def semantic_search(query: str, limit: int = 10) -> str:
    """
    Force semantic (RAG) search using embeddings.
    
    Use this when you specifically want to find things by MEANING,
    not just matching keywords. Great for:
    - Finding conceptually similar items
    - Handling vague or abstract queries
    - When exact terms are unknown
    
    Example: "healing abilities" will find "first aid", "surgery", 
    "herbalism" even though no keywords match exactly.
    
    Args:
        query: What you're looking for (describe the concept)
        limit: Maximum results
        
    Returns:
        Semantically similar results ranked by relevance
    """
    try:
        service = _get_service()
        result = service.smart_search(
            query, 
            force_method=SearchMethod.RAG,
            limit=limit
        )
        
        return _format_results(
            result["results"],
            result["analysis"],
            show_analysis=True
        )
        
    except Exception as e:
        return f"Error in semantic search: {str(e)}"

एजेंट इसका इस्तेमाल कब करता है:

• मिलती-जुलती चीज़ें ढूंढने के लिए की गई क्वेरी ("X से मिलती-जुलती चीज़ें ढूंढो")
• कॉन्सेप्ट से जुड़ी क्वेरी ("ठीक करने की क्षमता")
• जब मतलब समझना ज़रूरी हो

4. एजेंट के लिए फ़ैसले लेने से जुड़ी गाइड (निर्देश)

एजेंट की परिभाषा में, सिमैंटिक सर्च से जुड़े हिस्से को कॉपी करके निर्देश में चिपकाएं.

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

एजेंट, सही टूल चुनने के लिए इस निर्देश का इस्तेमाल करता है:

👉agent.py फ़ाइल में, # TODO: REPLACE_SEARCH_LOGIC टिप्पणी ढूंढें और इस पूरी लाइन को बदलें. इसके लिए, यह कोड इस्तेमाल करें:

- `semantic_search`: Force RAG/embedding search
  Use for: "Find similar to X", conceptual queries, unknown terminology
  Example: "Find skills related to healing"

👉# TODO: ADD_SEARCH_TOOLReplace this whole line वाली टिप्पणी ढूंढें और उसकी जगह यह कोड डालें:

    semantic_search,         # Force RAG

5. हाइब्रिड सर्च के काम करने का तरीका समझना (सिर्फ़ पढ़ने के लिए, कोई कार्रवाई ज़रूरी नहीं है)

दूसरे से चौथे चरण में, आपने सिमेंटिक सर्च (आरएजी) लागू की. यह खोज का मुख्य तरीका है. इससे मतलब के हिसाब से नतीजे मिलते हैं. हालांकि, आपने शायद यह देखा हो कि इस सिस्टम को "हाइब्रिड सर्च" कहा जाता है. यहां बताया गया है कि यह कैसे काम करता है:

खोज के तीन तरीके उपलब्ध हैं:

1. सिमैंटिक सर्च (आरएजी) - अभी लागू की गई सुविधा

• COSINE_DISTANCE + एम्बेड करने की सुविधा का इस्तेमाल करता है
• इनके लिए सबसे सही: कॉन्सेप्ट से जुड़ी क्वेरी, "X जैसा" कॉन्टेंट ढूंढना
• उदाहरण: "healing abilities" खोजने पर, "प्राथमिक चिकित्सा", "सर्जरी", "जड़ी-बूटियों से इलाज" मिलते हैं

2. कीवर्ड से खोजें - एसक्यूएल फ़िल्टर करने का पारंपरिक तरीका

• LIKE क्लॉज़ और कैटगरी के सटीक मिलान का इस्तेमाल करता है
• इनके लिए सबसे सही: बायोम, कैटगरी जैसे खास फ़िल्टर
• उदाहरण: "जंगल में चिकित्सा कौशल" क्वेरी, कैटगरी और जगह के हिसाब से फ़िल्टर करती है

3. हाइब्रिड सर्च - इसमें दोनों तरीकों का इस्तेमाल किया जाता है

• यह दोनों तरह की खोज करता है और वज़न के हिसाब से स्कोर के साथ नतीजों को मर्ज करता है
• इनके लिए सबसे सही: कॉन्सेप्ट और फ़िल्टर, दोनों के साथ मुश्किल क्वेरी
• उदाहरण: "पहाड़ों पर चोट ठीक करने में कौन मदद कर सकता है?"

हाइब्रिड मर्ज की सुविधा कैसे काम करती है:

फ़ाइल way-back-home/level_2/backend/services/hybrid_search_service.py में, hybrid_search() को कॉल करने पर, सेवा दोनों खोजें चलाती है और नतीजों को मर्ज करती है:

# Location: backend/services/hybrid_search_service.py

    rank_kw = keyword_ranks.get(surv_id, float('inf'))
    rank_rag = rag_ranks.get(surv_id, float('inf'))

    rrf_score = 0.0
    if rank_kw != float('inf'):
        rrf_score += 1.0 / (K + rank_kw)
    if rank_rag != float('inf'):
        rrf_score += 1.0 / (K + rank_rag)

    combined_score = rrf_score

hybrid_search() को कॉल करने पर, सेवा दोनों खोजों को चलाती है और Reciprocal Rank Fusion (RRF) का इस्तेमाल करके नतीजों को मर्ज करती है.

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

हर तरीके का इस्तेमाल कब किया जाता है?

एजेंट (backend/agent/agent.py) क्वेरी के आधार पर यह तय करता है:

क्वेरी प्रकार	एजेंट चुनता है	क्यों
"जंगल में बचे हुए लोगों को ढूँढो"	keyword_search	आसान फ़िल्टर, सिमैंटिक की ज़रूरत नहीं है
"चोटों को कौन ठीक कर सकता है?"	semantic_search	कॉन्सेप्चुअल, इसका मतलब बताना ज़रूरी है
"पहाड़ों पर चिकित्सा सहायता"	hybrid_search	इसमें कॉन्सेप्ट और फ़िल्टर, दोनों मौजूद हैं

इस कोडलैब के लिए, आपने सिमेंटिक सर्च कॉम्पोनेंट (आरएजी) लागू किया है, जो बुनियादी कॉम्पोनेंट है. कीवर्ड और हाइब्रिड तरीके, सेवा में पहले से ही लागू किए जा चुके हैं. आपका एजेंट इन तीनों तरीकों का इस्तेमाल कर सकता है!

बधाई हो! आपने हाइब्रिड सर्च की सुविधा के साथ Graph RAG एजेंट को सेट अप कर लिया है!

7. ADK Web की मदद से एजेंट को टेस्ट करना

अपने एजेंट को टेस्ट करने का सबसे आसान तरीका, adk web कमांड का इस्तेमाल करना है. इससे, चैट इंटरफ़ेस के साथ आपका एजेंट लॉन्च हो जाता है.

1. एजेंट को चलाना

👉💻 बैकएंड डायरेक्ट्री (जहां आपका एजेंट तय किया गया है) पर जाएं और वेब इंटरफ़ेस लॉन्च करें::

cd ~/way-back-home/level_2/backend
uv run adk web

इस कमांड से,

agent/agent.py

और इससे टेस्टिंग के लिए वेब इंटरफ़ेस खुलता है.

👉 यह यूआरएल खोलें:

इस कमांड से, एक लोकल यूआरएल (आम तौर पर http://127.0.0.1:8000 या इसी तरह का कोई यूआरएल) आउटपुट होगा. इसे अपने ब्राउज़र में खोलें.

यूआरएल पर क्लिक करने के बाद, आपको ADK का वेब यूज़र इंटरफ़ेस (यूआई) दिखेगा. पक्का करें कि आपने सबसे ऊपर बाएं कोने से "एजेंट" चुना हो.

2. खोज की सुविधाओं की जांच करना

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

🧬 A. ग्राफ़ आरएजी (सिमैंटिक सर्च)

कीवर्ड के मेल न खाने पर भी, मतलब और कॉन्सेप्ट के आधार पर आइटम ढूंढता है.

टेस्ट क्वेरी: (इनमें से कोई भी चुनें)

Who can help with injuries?

What abilities are related to survival?

इन बातों का ध्यान रखें:

• जवाब में, सिमैंटिक या आरएजी खोज का ज़िक्र होना चाहिए.
• आपको ऐसे नतीजे दिखेंगे जो कॉन्सेप्ट के हिसाब से मिलते-जुलते हों. जैसे, "प्राथमिक चिकित्सा" के बारे में पूछते समय "सर्जरी" के बारे में जानकारी न दें).
• नतीजों में 🧬 आइकॉन दिखेगा.

🔀 B. हाइब्रिड सर्च

यह मुश्किल क्वेरी के लिए, कीवर्ड फ़िल्टर को सिमैंटिक अंडरस्टैंडिंग के साथ जोड़ता है.

टेस्ट क्वेरी:(इनमें से कोई भी चुनें)

Find someone who can ply a plane in the volcanic area

Who has healing abilities in the FOSSILIZED?

Who has healing abilities in the mountains?

इन बातों का ध्यान रखें:

• वजह में हाइब्रिड खोज का ज़िक्र होना चाहिए.
• नतीजे, दोनों शर्तों (कॉन्सेप्ट + जगह/कैटेगरी) से मेल खाने चाहिए.
• दोनों तरीकों से मिले नतीजों में 🔀 आइकॉन होगा और उन्हें सबसे ऊपर रैंक किया जाएगा.

👉💻 टेस्टिंग पूरी होने के बाद, कमांड लाइन में Ctrl+C दबाकर प्रोसेस खत्म करें.

8. पूरा ऐप्लिकेशन चलाना

फ़ुल स्टैक आर्किटेक्चर के बारे में खास जानकारी

SessionService और Runner जोड़ें

👉💻 टर्मिनल में, Cloud Shell Editor में chat.py फ़ाइल खोलें. इसके लिए, यह कमांड चलाएं. आगे बढ़ने से पहले, पक्का करें कि आपने पिछली प्रोसेस को खत्म करने के लिए "ctrl+C" दबाया हो:

cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py

👉chat.py फ़ाइल में, # TODO: REPLACE_INMEMORY_SERVICES टिप्पणी ढूंढें और इस पूरी लाइन को बदलें. इसके लिए, यह कोड इस्तेमाल करें:

    session_service = InMemorySessionService()
    memory_service = InMemoryMemoryService()

👉chat.py फ़ाइल में, # TODO: REPLACE_RUNNER टिप्पणी ढूंढें और इस पूरी लाइन को बदलें. इसके लिए, यह कोड इस्तेमाल करें:

runner = Runner(
    agent=root_agent, 
    session_service=session_service,
    memory_service=memory_service,
    app_name="survivor-network"
)

1. आवेदन शुरू करें

अगर पिछला टर्मिनल अब भी चल रहा है, तो Ctrl+C दबाकर उसे बंद करें.

👉💻 ऐप्लिकेशन शुरू करें:

cd ~/way-back-home/level_2/
./start_app.sh

बैकएंड में प्रोसेस शुरू होने पर, आपको Local: http://localhost:5173/" इस तरह दिखेगा:

👉 टर्मिनल में जाकर, Local: http://localhost:5173/ पर क्लिक करें.

2. सिमैंटिक सर्च की सुविधा आज़माना

क्वेरी:

Find skills similar to healing

इससे क्या होता है:

• एजेंट, मिलते-जुलते अनुरोध को पहचानता है
• "healing" के लिए एम्बेडिंग जनरेट करता है
• यह शब्दार्थ के हिसाब से मिलती-जुलती स्किल खोजने के लिए, कोसाइन दूरी का इस्तेमाल करता है
• जवाब: प्राथमिक चिकित्सा (भले ही, नाम "ठीक होना" से मेल न खाते हों)

3. हाइब्रिड सर्च की जांच करना

क्वेरी:

Find medical skills in the mountains

इससे क्या होता है:

1. कीवर्ड कॉम्पोनेंट: category='medical' के लिए फ़िल्टर
2. सिमेंटिक कॉम्पोनेंट: "मेडिकल" को एम्बेड करें और समानता के आधार पर रैंक करें
3. मर्ज करें: दोनों तरीकों से मिले नतीजों को एक साथ मिलाएं. साथ ही, उन नतीजों को प्राथमिकता दें जो दोनों तरीकों से मिले हैं 🔀

क्वेरी(ज़रूरी नहीं):

Who is good at survival and in the forest?

इससे क्या होता है:

• कीवर्ड के लिए सुझाव: biome='forest'
• सेमैटिक ने ये स्किल ढूंढकर निकाली हैं: "जीवन बचाना" से मिलती-जुलती स्किल
• हाइब्रिड, दोनों को मिलाकर बेहतर नतीजे देता है

👉💻 जांच पूरी होने के बाद, टर्मिनल में Ctrl+C दबाकर इसे बंद करें.

9. मल्टीमॉडल पाइपलाइन — टूलिंग लेयर

हमें मल्टीमॉडल पाइपलाइन की ज़रूरत क्यों होती है?

सर्वाइवल नेटवर्क में सिर्फ़ टेक्स्ट नहीं होता. पीड़ित, चैट के ज़रिए सीधे तौर पर अनस्ट्रक्चर्ड डेटा भेजते हैं:

• 📸 इमेज: संसाधनों, खतरों या उपकरणों की फ़ोटो
• 🎥 वीडियो: स्थिति की जानकारी देने वाली रिपोर्ट या एसओएस ब्रॉडकास्ट
• 📄 टेक्स्ट: फ़ील्ड नोट या लॉग

चुनौती: इस डेटा को खोजने लायक बनाने के लिए ("पानी कहां है?"), हमें इन फ़ाइलों से स्ट्रक्चर्ड एंटिटी एक्सट्रैक्ट (व्यक्ति, संसाधन, जगह) करनी होंगी और उन्हें ग्राफ़ में सेव करना होगा.

असल ज़िंदगी से जुड़ा उदाहरण:

कोई उपयोगकर्ता चैट में मेडिकल किट की फ़ोटो अपलोड करता है.

सिस्टम में ये सुविधाएं होनी चाहिए:

1. फ़ाइल को GCS पर अपलोड करें
2. मेडिकल किट को "देखने" के लिए Gemini का इस्तेमाल करना
3. Spanner में "संसाधन" नोड सेव करना
4. उपयोगकर्ता से पुष्टि करें: "मैंने मेडिकल किट को डेटाबेस में सेव कर दिया है."

हम कौनसी फ़ाइलें प्रोसेस करते हैं?

पिछले चरण में, हमने मौजूदा डेटा खोजा था. हालांकि, यहां हम उपयोगकर्ता की ओर से अपलोड की गई फ़ाइलों को प्रोसेस करते हैं. chat.py इंटरफ़ेस, फ़ाइल अटैचमेंट को डाइनैमिक तौर पर हैंडल करता है:

स्रोत	सामग्री	लक्ष्य
उपयोगकर्ता अटैचमेंट	इमेज/वीडियो/टेक्स्ट	ग्राफ़ में जोड़ने के लिए जानकारी
चैट का कॉन्टेक्स्ट	"यहां सामान की फ़ोटो दी गई है"	इरादा और अन्य जानकारी

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

हम सीक्वेंशियल एजेंट (multimedia_agent.py) का इस्तेमाल करते हैं. यह खास एजेंट को एक साथ जोड़ता है:

इसे backend/agent/multimedia_agent.py में SequentialAgent के तौर पर तय किया गया है.

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

1. Tools फ़ाइल खोलें

👉💻 नया टर्मिनल खोलें. टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलें:

cloudshell edit ~/way-back-home/level_2/backend/agent/tools/extraction_tools.py

2. upload_media टूल लागू करना

यह टूल, लोकल फ़ाइल को Google Cloud Storage पर अपलोड करता है.

👉 extraction_tools.py में, टिप्पणी pass # TODO: REPLACE_UPLOAD_MEDIA_FUNCTION ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

    """
    Upload media file to GCS and detect its type.
    
    Args:
        file_path: Path to the local file
        survivor_id: Optional survivor ID to associate with upload
        
    Returns:
        Dict with gcs_uri, media_type, and status
    """
    try:
        if not file_path:
            return {"status": "error", "error": "No file path provided"}
        
        # Strip quotes if present
        file_path = file_path.strip().strip("'").strip('"')
        
        if not os.path.exists(file_path):
            return {"status": "error", "error": f"File not found: {file_path}"}
        
        gcs_uri, media_type, signed_url = gcs_service.upload_file(file_path, survivor_id)
        
        return {
            "status": "success",
            "gcs_uri": gcs_uri,
            "signed_url": signed_url,
            "media_type": media_type.value,
            "file_name": os.path.basename(file_path),
            "survivor_id": survivor_id
        }
    except Exception as e:
        logger.error(f"Upload failed: {e}")
        return {"status": "error", "error": str(e)}

3. extract_from_media टूल लागू करना

यह टूल एक राउटर है. यह media_type की जांच करता है और सही एक्सट्रैक्टर (टेक्स्ट, इमेज या वीडियो) को भेजता है.

👉extraction_tools.py में, टिप्पणी pass # TODO: REPLACE_EXTRACT_FROM_MEDIA ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

    """
    Extract entities and relationships from uploaded media.
    
    Args:
        gcs_uri: GCS URI of the uploaded file
        media_type: Type of media (text/image/video)
        signed_url: Optional signed URL for public/temporary access
        
    Returns:
        Dict with extraction results
    """
    try:
        if not gcs_uri:
             return {"status": "error", "error": "No GCS URI provided"}

        # Select appropriate extractor
        if media_type == MediaType.TEXT.value or media_type == "text":
            result = await text_extractor.extract(gcs_uri)
        elif media_type == MediaType.IMAGE.value or media_type == "image":
            result = await image_extractor.extract(gcs_uri)
        elif media_type == MediaType.VIDEO.value or media_type == "video":
            result = await video_extractor.extract(gcs_uri)
        else:
            return {"status": "error", "error": f"Unsupported media type: {media_type}"}
            
        # Inject signed URL into broadcast info if present
        if signed_url:
            if not result.broadcast_info:
                result.broadcast_info = {}
            result.broadcast_info['thumbnail_url'] = signed_url
        
        return {
            "status": "success",
            "extraction_result": result.to_dict(), # Return valid JSON dict instead of object
            "summary": result.summary,
            "entities_count": len(result.entities),
            "relationships_count": len(result.relationships),
            "entities": [e.to_dict() for e in result.entities],
            "relationships": [r.to_dict() for r in result.relationships]
        }
    except Exception as e:
        logger.error(f"Extraction failed: {e}")
        return {"status": "error", "error": str(e)}

लागू करने से जुड़ी मुख्य जानकारी:

• टेक्स्ट, इमेज, और वीडियो वगैरह का इस्तेमाल करके इनपुट देना: हम generate_content को टेक्स्ट प्रॉम्प्ट (_get_extraction_prompt()) और इमेज ऑब्जेक्ट, दोनों पास करते हैं.
• स्ट्रक्चर्ड आउटपुट: response_mime_type="application/json" यह पक्का करता है कि एलएलएम, मान्य JSON फ़ॉर्मैट में जवाब दे. यह पाइपलाइन के लिए ज़रूरी है.
• विज़ुअल एंटिटी लिंकिंग: प्रॉम्प्ट में जानी-पहचानी एंटिटी शामिल होती हैं, ताकि Gemini खास वर्णों को पहचान सके.

4. save_to_spanner टूल लागू करना

यह टूल, निकाली गई इकाइयों और संबंधों को Spanner Graph DB में सेव करता है.

👉extraction_tools.py में, टिप्पणी pass # TODO: REPLACE_SPANNER_AGENT ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

    """
    Save extracted entities and relationships to Spanner Graph DB.
    
    Args:
        extraction_result: ExtractionResult object (or dict from previous step if passed as dict)
        survivor_id: Optional survivor ID to associate with the broadcast
        
    Returns:
        Dict with save statistics
    """
    try:
        # Handle if extraction_result is passed as the wrapper dict from extract_from_media
        result_obj = extraction_result
        if isinstance(extraction_result, dict) and 'extraction_result' in extraction_result:
             result_obj = extraction_result['extraction_result']
        
        # If result_obj is a dict (from to_dict()), reconstruct it
        if isinstance(result_obj, dict):
            from extractors.base_extractor import ExtractionResult
            result_obj = ExtractionResult.from_dict(result_obj)
        
        if not result_obj:
            return {"status": "error", "error": "No extraction result provided"}
            
        stats = spanner_service.save_extraction_result(result_obj, survivor_id)
        
        return {
            "status": "success",
            "entities_created": stats['entities_created'],
            "entities_existing": stats['entities_found_existing'],
            "relationships_created": stats['relationships_created'],
            "broadcast_id": stats['broadcast_id'],
            "errors": stats['errors'] if stats['errors'] else None
        }
    except Exception as e:
        logger.error(f"Spanner save failed: {e}")
        return {"status": "error", "error": str(e)}

एजेंट को बेहतर टूल उपलब्ध कराकर, हम डेटा की सुरक्षा को पक्का करते हैं. साथ ही, एजेंट की तर्क करने की क्षमताओं का इस्तेमाल करते हैं.

5. GCS सेवा अपडेट करें

GCSService, Google Cloud Storage में फ़ाइल अपलोड करने का काम करता है.

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलें:

cloudshell edit ~/way-back-home/level_2/backend/services/gcs_service.py

👉 फ़ाइल gcs_service.py में, upload_file फ़ंक्शन के अंदर मौजूद टिप्पणी # TODO: REPLACE_SAVE_TO_GCS ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

        blob = self.bucket.blob(blob_name)
        blob.upload_from_filename(file_path)

इस जानकारी को सेवा में शामिल करने से, एजेंट को GCS बकेट, blob के नाम या हस्ताक्षर किए गए यूआरएल जनरेट करने के बारे में जानने की ज़रूरत नहीं होती. इसमें सिर्फ़ "अपलोड करें" का विकल्प होता है.

6. (सिर्फ़ पढ़ने के लिए) एजेंटिक वर्कफ़्लो > पारंपरिक तरीके क्यों?

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

❌ पहला तरीका: बैच डेटा पाइपलाइन (आसान, लेकिन कमज़ोर)

फ़ाइलों को क्रम से प्रोसेस करने वाली सामान्य बैच स्क्रिप्ट:

# Traditional batch pipeline
for file in ["broadcast_1.txt", "broadcast_2.png", "broadcast_3.mp4"]:
   gcs_uri = upload_to_gcs(file)        # Fails if file corrupted → CRASH
   entities = extract_entities(gcs_uri) # No error handling
   save_to_db(entities)                 # Saves even if extraction empty → WASTE
   # How do you tell the user progress? Print to console?

समस्याएं:

• ❌ अनुकूलन की सुविधा नहीं है: अगर कोई फ़ाइल काम नहीं करती है, तो पूरी स्क्रिप्ट क्रैश हो जाती है
• ❌ कोई संदर्भ नहीं दिया गया है: उपयोगकर्ता के मकसद के आधार पर व्यवहार को अडजस्ट नहीं किया जा सकता ("यह ज़रूरी है!")
• ❌ साइलेंट फ़ेलियर: लॉग में छिपी हुई गड़बड़ियां. उपयोगकर्ता को पता नहीं चलता कि क्या हुआ
• ❌ उपयोगकर्ता से कोई सुझाव/राय नहीं ली जाती: स्क्रिप्ट बैकग्राउंड में चलती है और उपयोगकर्ता को इंतज़ार करना पड़ता है

❌ दूसरा तरीका: इवेंट-ड्रिवन आर्किटेक्चर (क्लाउड-नेटिव, लेकिन मुश्किल)

क्लाउड का पारंपरिक सेटअप:

1. उपयोगकर्ता, GCS (जीसीएस) पर अपलोड करता है
2. GCS इवेंट, Cloud फ़ंक्शन को ट्रिगर करता है
3. Vision API को फ़ंक्शन कॉल करता है
4. फ़ंक्शन, डेटाबेस में लिखता है
5. ...हम उपयोगकर्ता को यह कैसे बताएं कि प्रोसेस पूरी हो गई है? (WebSockets/Polling की ज़रूरत है)

समस्याएं:

• ❌ ज़्यादा मुश्किल: पांच या उससे ज़्यादा सेवाओं (GCS, Eventarc, Cloud Functions, Pub/Sub...) को मैनेज करना
• ❌ डिकपल्ड स्टेट: इवेंट हैंडलर के बीच डेटा पास करना मुश्किल होता है
• ❌ डीबग करने में मुश्किल: लॉग कई सेवाओं में बिखरे हुए हैं
• ❌ उपयोगकर्ता से डिसकनेक्ट किया गया: इवेंट बैकग्राउंड में चलते हैं, बातचीत का कोई कॉन्टेक्स्ट नहीं होता

✅ हमारा तरीका: एजेंटिक सीक्वेंशियल पाइपलाइन

multimedia_agent.py, SequentialAgent का इस्तेमाल करता है. यह पाइपलाइन को बेहतर तरीके से व्यवस्थित करता है:

# Agentic pipeline (simplified conceptual view)
Agent: "I'll upload your file..."
Tool: upload_media → Success ✅
Agent: "Great! Now extracting entities..."
Tool: extract_from_media → Found 3 survivors, 2 resources ✅
Agent: "Perfect! Saving to database..."
Tool: save_to_spanner → Saved as broadcast #456 ✅
Agent: "Done! I found 3 survivors and 2 resources in your image. Saved to the graph."

एजेंटिक एआई के फ़ायदे:

सुविधा	बैच पाइपलाइन	इवेंट-ड्रिवन	एजेंटिक वर्कफ़्लो
जटिलता	कम (एक स्क्रिप्ट)	ज़्यादा (पांच या उससे ज़्यादा सेवाएं)	कम (1 Python फ़ाइल: multimedia_agent.py)
स्टेट मैनेजमेंट	ग्लोबल वैरिएबल	हार्ड (डीकपल्ड)	यूनिफ़ाइड (एजेंट की स्थिति)
गड़बड़ी ठीक करना	क्रैश	साइलेंट लॉग	इंटरैक्टिव ("मुझे वह फ़ाइल नहीं मिली")
उपयोगकर्ता के सुझाव/राय या शिकायत	कंसोल प्रिंट	पोलिंग की ज़रूरत है	तुरंत (चैट का हिस्सा)
बदलावों के हिसाब से ढलने की क्षमता	तय किया गया लॉजिक	रिजिड फ़ंक्शन	इंटेलिजेंट (एलएलएम तय करता है कि अगला चरण क्या होगा)
कॉन्टेक्स्ट अवेयरनेस	कोई नहीं	कोई नहीं	पूरी जानकारी (उपयोगकर्ता के मकसद के बारे में जानकारी होती है)

असल दुनिया से जुड़ा उदाहरण:

बैच स्क्रिप्ट:

Processing file 1... Done.
Processing file 2... ERROR: Corrupted image
[CRASH - User has to restart entire batch]

एजेंटिक वर्कफ़्लो:

User: "Here are 3 images of our supply cache"
Agent: "Processing image 1... Found medical supplies ✅"
Agent: "Processing image 2... This file seems corrupted. Skipping. ⚠️"
Agent: "Processing image 3... Found food supplies ✅"
Agent: "Summary: I successfully processed 2 of 3 images. Would you like to re-upload image 2?"

यह क्यों ज़रूरी है: multimedia_agent.py (चार सब-एजेंट वाला SequentialAgent: अपलोड करें → निकालें → सेव करें → खास जानकारी) का इस्तेमाल करके, हम जटिल इंफ़्रास्ट्रक्चर और कमज़ोर स्क्रिप्ट को इंटेलिजेंट, बातचीत वाले ऐप्लिकेशन लॉजिक से बदल देते हैं.

10. मल्टीमॉडल पाइपलाइन — एजेंट लेयर

एजेंट लेयर, इंटेलिजेंस तय करती है. इसमें ऐसे एजेंट शामिल होते हैं जो टास्क पूरे करने के लिए टूल का इस्तेमाल करते हैं. हर एजेंट की एक खास भूमिका होती है और वह अगले एजेंट को कॉन्टेक्स्ट पास करता है. यहां मल्टीएजेंट सिस्टम का आर्किटेक्चर डायग्राम दिया गया है.

1. एजेंट फ़ाइल खोलें

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलें:

cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py

2. अपलोड एजेंट तय करना

यह एजेंट, उपयोगकर्ता के मैसेज से फ़ाइल पाथ निकालता है और उसे GCS पर अपलोड करता है.

👉फ़ाइल multimedia_agent.py में, टिप्पणी # TODO: REPLACE_UPLOAD_AGENT ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

upload_agent = LlmAgent(
    name="UploadAgent",
    model="gemini-2.5-flash",
    instruction="""Extract the file path from the user's message and upload it.

Use `upload_media(file_path, survivor_id)` to upload the file.
The survivor_id is optional - include it if the user mentions a specific survivor (e.g., "survivor Sarah" -> "Sarah").
If the user provides a path like "/path/to/file", use that.

Return the upload result with gcs_uri and media_type.""",
    tools=[upload_media],
    output_key="upload_result"
)

3. डेटा निकालने वाले एजेंट को तय करना

यह एजेंट, अपलोड किए गए मीडिया को "देखता" है और Gemini Vision का इस्तेमाल करके स्ट्रक्चर्ड डेटा निकालता है.

👉फ़ाइल multimedia_agent.py में, टिप्पणी # TODO: REPLACE_EXTRACT_AGENT ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

extraction_agent = LlmAgent(
    name="ExtractionAgent", 
    model="gemini-2.5-flash",
    instruction="""Extract information from the uploaded media.

Previous step result: {upload_result}

Use `extract_from_media(gcs_uri, media_type, signed_url)` with the values from the upload result.
The gcs_uri is in upload_result['gcs_uri'], media_type in upload_result['media_type'], and signed_url in upload_result['signed_url'].

Return the extraction results including entities and relationships found.""",
    tools=[extract_from_media],
    output_key="extraction_result"
)

ध्यान दें कि instruction रेफ़रंस {upload_result} कैसे दिए जाते हैं — ADK में एजेंट के बीच स्टेट को इस तरह पास किया जाता है.

4. Spanner एजेंट को तय करना

यह एजेंट, निकाली गई इकाइयों और उनके बीच के संबंधों को ग्राफ़ डेटाबेस में सेव करता है.

👉फ़ाइल multimedia_agent.py में, टिप्पणी # TODO: REPLACE_SPANNER_AGENT ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

spanner_agent = LlmAgent(
    name="SpannerAgent",
    model="gemini-2.5-flash", 
    instruction="""Save the extracted information to the database.

Upload result: {upload_result}
Extraction result: {extraction_result}

Use `save_to_spanner(extraction_result, survivor_id)` to save to Spanner.
Pass the WHOLE `extraction_result` object/dict from the previous step.
Include survivor_id if it was provided in the upload step.

Return the save statistics.""",
    tools=[save_to_spanner],
    output_key="spanner_result"
)

इस एजेंट को पिछले दोनों चरणों (upload_result और extraction_result) से कॉन्टेक्स्ट मिलता है.

5. खास जानकारी देने वाले एजेंट को तय करना

यह एजेंट, पिछले सभी चरणों के नतीजों को मिलाकर, उपयोगकर्ता के लिए आसान जवाब तैयार करता है.

👉फ़ाइल multimedia_agent.py में, टिप्पणी summary_instruction="" # TODO: REPLACE_SUMMARY_AGENT_PROMPT ढूंढें.

इस पूरी लाइन की जगह यह कोड डालें:

USE_MEMORY_BANK = os.getenv("USE_MEMORY_BANK", "false").lower() == "true"
save_msg = "6. Mention that the data is also being synced to the memory bank." if USE_MEMORY_BANK else ""

summary_instruction = f"""Provide a user-friendly summary of the media processing.

Upload: {{upload_result}}
Extraction: {{extraction_result}}
Database: {{spanner_result}}

Summarize:
1. What file was processed (name and type)
2. Key information extracted (survivors, skills, needs, resources found) - list names and counts
3. Relationships identified
4. What was saved to the database (broadcast ID, number of entities)
5. Any issues encountered
{save_msg}

Be concise but informative."""

इस एजेंट को टूल की ज़रूरत नहीं होती. यह सिर्फ़ शेयर किए गए कॉन्टेक्स्ट को पढ़ता है और उपयोगकर्ता के लिए साफ़ तौर पर जानकारी देता है.

🧠 आर्किटेक्चर की खास जानकारी

परत	फ़ाइल	ज़िम्मेदारी
टूलिंग	extraction_tools.py + gcs_service.py	कैसे — अपलोड करें, एक्सट्रैक्ट करें, सेव करें
Agent	multimedia_agent.py	क्या — पाइपलाइन को व्यवस्थित करना

11. मल्टीमॉडल डेटा पाइपलाइन — ऑर्केस्ट्रेशन

हमारे नए सिस्टम का मुख्य हिस्सा, MultimediaExtractionPipeline है. इसके बारे में backend/agent/multimedia_agent.py में बताया गया है. यह ADK (एजेंट डेवलपमेंट किट) से सीक्वेंशियल एजेंट पैटर्न का इस्तेमाल करता है.

1. सीक्वेंशियल टारगेटिंग क्यों?

अपलोड की गई फ़ाइल को प्रोसेस करने के लिए, इन चरणों को क्रम से पूरा करना ज़रूरी है:

1. जब तक आपके पास फ़ाइल (अपलोड) नहीं होती, तब तक डेटा नहीं निकाला जा सकता.
2. डेटा को एक्सट्रैक्ट करने के बाद ही उसे सेव किया जा सकता है.
3. नतीजे सेव करने के बाद ही, खास जानकारी जनरेट की जा सकती है.

इसके लिए, SequentialAgent सबसे सही है. यह एक एजेंट के आउटपुट को दूसरे एजेंट के लिए कॉन्टेक्स्ट/इनपुट के तौर पर पास करता है.

2. एजेंट की जानकारी

आइए, देखें कि multimedia_agent.py में पाइपलाइन को कैसे असेंबल किया जाता है: 👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए, यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py

इसे पिछले दोनों चरणों से इनपुट मिलते हैं. टिप्पणी # TODO: REPLACE_ORCHESTRATION ढूंढें. इस पूरी लाइन की जगह यह कोड डालें:

    sub_agents=[upload_agent, extraction_agent, spanner_agent, summary_agent]

3. रूट एजेंट से कनेक्ट करें

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

टिप्पणी # TODO: REPLACE_ADD_SUBAGENT ढूंढें. इस पूरी लाइन की जगह यह कोड डालें:

    sub_agents=[multimedia_agent],

इस एक ऑब्जेक्ट में, चार "विशेषज्ञों" को एक कॉल करने लायक इकाई में बंडल किया गया है.

4. एजेंट के बीच डेटा फ़्लो

हर एजेंट, अपने आउटपुट को शेयर किए गए कॉन्टेक्स्ट में सेव करता है. इसके बाद, अन्य एजेंट इस कॉन्टेक्स्ट को ऐक्सेस कर सकते हैं:

5. ऐप्लिकेशन खोलें (अगर ऐप्लिकेशन अब भी चल रहा है, तो इस चरण को छोड़ दें)

अगर आपके ऐप्लिकेशन की पिछली प्रोसेस अब भी चालू है, तो इस चरण को छोड़ा जा सकता है.

👉💻 ऐप्लिकेशन शुरू करें:

cd ~/way-back-home/level_2/
./start_app.sh

👉 टर्मिनल में जाकर, Local: http://localhost:5173/ पर क्लिक करें.

6. टेस्ट इमेज अपलोड करें

👉 चैट इंटरफ़ेस में, यहां दी गई कोई भी फ़ोटो चुनें और उसे यूज़र इंटरफ़ेस (यूआई) पर अपलोड करें:

• test_photo1,
• test_photo2,
• test_photo3,
• test_photo4

चैट इंटरफ़ेस में, एजेंट को अपने खास संदर्भ के बारे में बताएं:

Here is the survivor note

इसके बाद, यहां इमेज अटैच करें.

👉💻 टर्मिनल में, टेस्टिंग पूरी होने के बाद, प्रोसेस को खत्म करने के लिए "Ctrl+C" दबाएं.

बिहाइंड द सीन क्या होता है:

1. UploadAgent:

• Google Cloud Storage में फ़ाइल अपलोड करता है
• यह कुकी, मीडिया टाइप (इमेज/टेक्स्ट/वीडियो) का पता लगाती है
• यह कुकी, ऐक्सेस के लिए साइन किया गया यूआरएल जनरेट करती है

2. ExtractionAgent:

• GCS से इमेज डाउनलोड करता है
• यह Gemini Vision को डेटा निकालने का प्रॉम्प्ट भेजता है
• एआई, इमेज का विश्लेषण इन चीज़ों के लिए करता है:
  • ज़िंदा बचे लोग (नाम, स्थितियां, भूमिकाएं)
  • संसाधन (मेडिकल सप्लाई, टूल)
  • जगहें (बायोम, कोऑर्डिनेट)
  • रिश्ते (किसके पास क्या है, कौन कहां है)

3. SpannerAgent:

• यह Spanner में नई इकाई नोड बनाता है
• रिलेशनशिप एज बनाता है
• यह थंबनेल के साथ ब्रॉडकास्ट रिकॉर्ड बनाता है

4. SummaryAgent:

• उपयोगकर्ता के हिसाब से आसान भाषा में खास जानकारी तैयार करता है
• स्ट्रक्चर्ड रिपोर्ट दिखाता है

6. GCS बकेट में मल्टीमॉडल अपलोड करने की सुविधा की पुष्टि करना

• Google Cloud Console Storage खोलें.
• Cloud Storage में "बकेट" चुनें

• अपना बकेट चुनें और media पर क्लिक करें.

• अपलोड की गई इमेज यहां देखें.

7. Spanner में मल्टीमॉडल अपलोड करने की सुविधा की पुष्टि करना (ज़रूरी नहीं)

यहां test_photo1 के लिए, यूज़र इंटरफ़ेस (यूआई) में आउटपुट का उदाहरण दिया गया है.

आपने नोट Here is the survivor note के साथ test_photo1 अपलोड किया है. आपको मैसेज दिखेगा

**Summary:** A field report written on a clipboard details the discovery of an 'Energy Crystal' by David Chen in a 'Bioluminescent Forest', with the status marked as 'Critical'. The scene also includes a lit lantern, a pen, and a compass.

**Entities Found:**
*   **David Chen** (Survivor): The agent who filed this field report. His known role is Engineer.
*   **Engineer** (Skill): David Chen's known role or skill.
*   **Energy Crystal** (Resource): A newly discovered resource, depicted as a glowing blue crystal in a sketch on the report. Its purpose is implied to be energy-related.
*   **Bioluminescent Forest** (Biome): The location where the energy crystal was found. This matches the known biome description of a dark forest with glowing purple/neon plants and mushrooms.
*   **Critical Situation** (Need): The overall status of the situation is critical, indicating an urgent need for attention, response, or resource allocation.

**Relationships Found:**
*   **David Chen** (Survivor) found **Energy Crystal** (Resource).
*   **David Chen** (Survivor) is in **Bioluminescent Forest** (Biome).
*   **David Chen** (Survivor) has the skill **Engineer**.I have successfully saved the extracted information to the Spanner database.

Here are the save statistics:
*   **Broadcast ID:** `5892fb58-a120-46ca-80c2-0e04da7d6ea7`
*   **Entities Created:** 4
*   **Existing Entities:** 1
*   **Relationships Created:** 3
*   **Status:** successHere's a summary of the media processing:

इस मामले में, हमें यह पुष्टि करनी होगी कि स्पैनर ने इनकी जानकारी को अपडेट कर दिया है:

*   **David Chen** (Survivor) found **Energy Crystal** (Resource).
*   **David Chen** (Survivor) is in **Bioluminescent Forest** (Biome).
*   **David Chen** (Survivor) has the skill **Engineer**.I have 

• Google Cloud Console Spanner खोलें.
• अपना इंस्टेंस चुनें: Survivor Network
• अपना डेटाबेस चुनें: graph-db
• बाईं ओर मौजूद साइडबार में, Spanner Studio पर क्लिक करें

👉 Spanner Studio में, नए डेटा के लिए क्वेरी करें:

SELECT 
  s.name AS Survivor,
  s.role AS Role,
  b.name AS Biome,
  r.name AS FoundResource,
  s.created_at
FROM Survivors s
LEFT JOIN SurvivorInBiome sib ON s.survivor_id = sib.survivor_id
LEFT JOIN Biomes b ON sib.biome_id = b.biome_id
LEFT JOIN SurvivorFoundResource sfr ON s.survivor_id = sfr.survivor_id
LEFT JOIN Resources r ON sfr.resource_id = r.resource_id
ORDER BY s.created_at DESC;

हम इसकी पुष्टि यहां दिए गए नतीजे से कर सकते हैं:

12. एजेंट इंजन के साथ मेमोरी बैंक

1. मेमोरी कैसे काम करती है

यह सिस्टम, दो तरह की मेमोरी का इस्तेमाल करता है. इससे, यह तुरंत कॉन्टेक्स्ट को समझ पाता है और लंबे समय तक सीखी गई जानकारी को याद रख पाता है.

2. यादें बनाने के लिए विषय क्या होते हैं?

याद रखने लायक विषय, जानकारी की उन कैटगरी को तय करते हैं जिन्हें एजेंट को सभी बातचीत में याद रखना चाहिए. इन्हें अलग-अलग तरह के उपयोगकर्ताओं की प्राथमिकताओं के लिए फ़ाइलिंग कैबिनेट के तौर पर समझें.

सिर्फ़ एक बड़ी याद क्यों नहीं?

• ❌ सामान्य जानकारी: "उपयोगकर्ता ने खोज के बारे में कुछ कहा... और उसे... और बायोम... के बारे में जानकारी चाहिए"
• ✅ व्यवस्थित किए गए विषय: खोज के व्यवहार और ज़रूरी मॉनिटरिंग के बीच अंतर को साफ़ तौर पर दिखाया गया है

हमारे दो विषय:

1. search_preferences: उपयोगकर्ता को किस तरह से खोजना पसंद है
   • क्या वे कीवर्ड या सिमैंटिक सर्च को प्राथमिकता देते हैं?
   • वे अक्सर कौनसी स्किल/बायोम खोजते हैं?
   • याददाश्त का उदाहरण: "उपयोगकर्ता को चिकित्सा से जुड़ी जानकारी के लिए, सिमैंटिक सर्च का इस्तेमाल करना पसंद है"
2. urgent_needs_context: वे किन संकटों को ट्रैक कर रहे हैं
   • वे किन संसाधनों की निगरानी कर रहे हैं?
   • उन्हें किन पीड़ितों की चिंता है?
   • मेमोरी का उदाहरण: "उपयोगकर्ता, उत्तरी कैंप में दवा की कमी को ट्रैक कर रहा है"

दो विषयों को क्यों चुना गया है?

• सटीकता: एलएलएम, तथ्यों को सही कैटगरी में निकाल सकता है
• जानकारी वापस पाना: जब उपयोगकर्ता "चिकित्सा कौशल वाले लोगों का पता लगाओ" पूछता है, तो एजेंट search_preferences से जानकारी वापस पाता है. वह ऐसी जानकारी वापस नहीं पाता है जो ज़रूरी ज़रूरतों से जुड़ी न हो
• स्केलेबिलिटी: बाद में और विषय जोड़े जा सकते हैं. उदाहरण के लिए, favorite_survivors, alliance_tracking)

यह सुविधा कैसे काम करती है: एजेंट से चैट करने के दौरान, Memory Bank अपने-आप उन तथ्यों को निकाल लेता है जो विषय के ब्यौरे से मेल खाते हैं. साथ ही, उन्हें सेव कर लेता है. अगली बार नया सेशन शुरू करने पर, एजेंट जवाबों को ज़्यादा बेहतर बनाने के लिए, पिछली बातचीत से जुड़ी जानकारी को फिर से हासिल करता है.

3. पुरानी तस्वीरों के विषय सेट अप करना

कस्टम मेमोरी के विषयों से यह तय होता है कि एजेंट को क्या याद रखना चाहिए. इन्हें एजेंट इंजन को डिप्लॉय करते समय कॉन्फ़िगर किया जाता है.

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/deploy_agent.py

इससे आपके एडिटर में ~/way-back-home/level_2/backend/deploy_agent.py खुल जाता है.

हम स्ट्रक्चर MemoryTopic ऑब्जेक्ट तय करते हैं, ताकि एलएलएम को यह पता चल सके कि कौनसी जानकारी निकालनी है और सेव करनी है.

👉फ़ाइल deploy_agent.py में, # TODO: SET_UP_TOPIC की जगह यह डालें:

# backend/deploy_agent.py

    custom_topics = [
        # Topic 1: Survivor Search Preferences
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="search_preferences",
                description="""Extract the user's preferences for how they search for survivors. Include:
                - Preferred search methods (keyword, semantic, direct lookup)
                - Common filters used (biome, role, status)
                - Specific skills they value or frequently look for
                - Geographic areas of interest (e.g., "forest biome", "mountain outpost")
                
                Example: "User prefers semantic search for finding similar skills."
                Example: "User frequently checks for survivors in the Swamp Biome."
                """,
            )
        ),
        # Topic 2: Urgent Needs Context
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="urgent_needs_context",
                description="""Track the user's focus on urgent needs and resource shortages. Include:
                - Specific resources they are monitoring (food, medicine, ammo)
                - Critical situations they are tracking
                - Survivors they are particularly concerned about
                
                Example: "User is monitoring the medicine shortage in the Northern Camp."
                Example: "User is looking for a doctor for the injured survivors."
                """,
            )
        )
    ]

4. एजेंट इंटिग्रेशन

जानकारी को सेव करने और वापस पाने के लिए, एजेंट कोड को मेमोरी बैंक के बारे में पता होना चाहिए.

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल खोलने के लिए यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

इससे आपके एडिटर में ~/way-back-home/level_2/backend/agent/agent.py खुल जाता है.

एजेंट बनाना

एजेंट बनाते समय, हम after_agent_callback को पास करते हैं. इससे यह पक्का किया जाता है कि बातचीत के बाद सेशन मेमोरी में सेव हो जाएं. add_session_to_memory फ़ंक्शन, चैट के जवाब को धीमा होने से बचाने के लिए एसिंक्रोनस तरीके से काम करता है.

👉फ़ाइल agent.py में, टिप्पणी # TODO: REPLACE_ADD_SESSION_MEMORY ढूंढें. इसके बाद, इस पूरी लाइन को बदलें और इसकी जगह यह कोड डालें:

async def add_session_to_memory(
        callback_context: CallbackContext
) -> Optional[types.Content]:
    """Automatically save completed sessions to memory bank in the background"""
    if hasattr(callback_context, "_invocation_context"):
        invocation_context = callback_context._invocation_context
        if invocation_context.memory_service:
            # Use create_task to run this in the background without blocking the response
            asyncio.create_task(
                invocation_context.memory_service.add_session_to_memory(
                    invocation_context.session
                )
            )
            logger.info("Scheduled session save to memory bank in background")

बैकग्राउंड में सेव करने की सुविधा

👉फ़ाइल agent.py में, टिप्पणी # TODO: REPLACE_ADD_MEMORY_BANK_TOOL ढूंढें. इसके बाद, इस पूरी लाइन को बदलें और इसकी जगह यह कोड डालें:

if USE_MEMORY_BANK:
    agent_tools.append(PreloadMemoryTool())

👉फ़ाइल agent.py में, टिप्पणी # TODO: REPLACE_ADD_CALLBACK ढूंढें. इसके बाद, इस पूरी लाइन को बदलें और इसकी जगह यह कोड डालें:

    after_agent_callback=add_session_to_memory if USE_MEMORY_BANK else None

Vertex AI Session Service सेट अप करना

👉💻 टर्मिनल में, Cloud Shell Editor में फ़ाइल chat.py खोलने के लिए, यह कमांड चलाएं:

cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py

👉chat.py फ़ाइल में, # TODO: REPLACE_VERTEXAI_SERVICES टिप्पणी ढूंढें और इस पूरी लाइन को बदलें. इसके लिए, यह कोड इस्तेमाल करें:

    session_service = VertexAiSessionService(
        project=project_id,
        location=location,
        agent_engine_id=agent_engine_id
    )
    memory_service = VertexAiMemoryBankService(
        project=project_id,
        location=location,
        agent_engine_id=agent_engine_id
    )

4. सेटअप और डिप्लॉयमेंट

मेमोरी की सुविधाओं को आज़माने से पहले, आपको एजेंट को मेमोरी के नए विषयों के साथ डिप्लॉय करना होगा. साथ ही, यह पक्का करना होगा कि आपका एनवायरमेंट सही तरीके से कॉन्फ़िगर किया गया हो.

हमने इस प्रोसेस को मैनेज करने के लिए, एक सुविधा स्क्रिप्ट उपलब्ध कराई है.

डिप्लॉयमेंट स्क्रिप्ट चलाना

👉💻 टर्मिनल में, डिप्लॉयमेंट स्क्रिप्ट चलाएं:

cd ~/way-back-home/level_2
./deploy_and_update_env.sh

यह स्क्रिप्ट ये कार्रवाइयां करती है:

• यह backend/deploy_agent.py को चलाता है, ताकि एजेंट और मेमोरी के विषयों को Vertex AI के साथ रजिस्टर किया जा सके.
• यह कुकी, नए Agent Engine आईडी को कैप्चर करती है.
• .env फ़ाइल में AGENT_ENGINE_ID की जानकारी अपने-आप अपडेट हो जाती है.
• यह कुकी पक्का करती है कि आपकी .env फ़ाइल में USE_MEMORY_BANK=TRUE सेट हो.

[!IMPORTANT] अगर आपने deploy_agent.py में custom_topics में बदलाव किया है, तो एजेंट इंजन को अपडेट करने के लिए, आपको इस स्क्रिप्ट को फिर से चलाना होगा.

13. मल्टीमॉडल डेटा की मदद से मेमोरी बैंक की पुष्टि करना

यह पुष्टि की जा सकती है कि मेमोरी बैंक काम कर रहा है या नहीं. इसके लिए, एजेंट को कोई प्राथमिकता सिखाएं और देखें कि वह सभी सेशन में बनी रहती है या नहीं.

1. ऐप्लिकेशन खोलें (अगर आपका ऐप्लिकेशन पहले से चल रहा है, तो यह चरण छोड़ दें)

नीचे दिए गए निर्देशों का पालन करके, ऐप्लिकेशन को फिर से खोलें: अगर पिछला टर्मिनल अब भी चल रहा है, तो Ctrls+C दबाकर उसे बंद करें.

👉💻 ऐप्लिकेशन शुरू करें:

cd ~/way-back-home/level_2/
./start_app.sh

👉 टर्मिनल में जाकर, Local: http://localhost:5173/ पर क्लिक करें.

2. टेक्स्ट के साथ मेमोरी बैंक की टेस्टिंग

चैट इंटरफ़ेस में, एजेंट को अपने खास संदर्भ के बारे में बताएं:

"I'm planning a medical rescue mission in the mountains. I need survivors with first aid and climbing skills."

👉 लगभग 30 सेकंड तक इंतज़ार करें, ताकि मेमोरी बैकग्राउंड में प्रोसेस हो सके.

2. नया सेशन शुरू करना

मौजूदा बातचीत के इतिहास (शॉर्ट-टर्म मेमोरी) को मिटाने के लिए, पेज को रीफ़्रेश करें.

ऐसा सवाल पूछें जो आपके पहले दिए गए कॉन्टेक्स्ट पर आधारित हो:

"What kind of missions am I interested in?"

अनुमानित जवाब:

"आपकी पिछली बातचीत के आधार पर, हमें पता चला है कि आपकी दिलचस्पी इन विषयों में है:

• मेडिकल रेस्क्यू मिशन
• पहाड़ी/ऊंचाई वाले इलाकों में ऑपरेशन
• ज़रूरी स्किल: प्राथमिक इलाज, चढ़ाई

क्या आपको इन शर्तों के हिसाब से सर्वाइवर ढूँढने हैं?"

3. इमेज अपलोड करके टेस्ट करना

कोई इमेज अपलोड करें और पूछें:

remember this

यहां दी गई किसी फ़ोटो को चुना जा सकता है या अपनी कोई फ़ोटो चुनी जा सकती है. इसके बाद, उसे यूज़र इंटरफ़ेस (यूआई) पर अपलोड किया जा सकता है:

• test_photo1,
• test_photo2,
• test_photo3,
• test_photo4

4. Vertex AI Agent Engine में पुष्टि करना

Google Cloud Console Agent Engine पर जाएं

1. पक्का करें कि आपने सबसे ऊपर बाईं ओर मौजूद प्रोजेक्ट सिलेक्टर से प्रोजेक्ट चुना हो:
2. आपने पिछली कमांड से जो एजेंट इंजन अभी डिप्लॉय किया है उसकी पुष्टि करें use_memory_bank.sh:आपने अभी जो एजेंट इंजन बनाया है उस पर क्लिक करें.
3. डिप्लॉय किए गए इस एजेंट में, Memories टैब पर क्लिक करें. यहां आपको सभी यादें दिखेंगी.

👉💻 टेस्टिंग पूरी होने के बाद, प्रोसेस बंद करने के लिए टर्मिनल में "Ctrl + C" पर क्लिक करें.

🎉 बधाई हो! आपने अभी-अभी मेमोरी बैंक को अपने एजेंट से जोड़ा है!

14. Cloud Run पर डिप्लॉय करें

1. डिप्लॉयमेंट स्क्रिप्ट चलाना

👉💻 डिप्लॉयमेंट स्क्रिप्ट चलाएं:

cd ~/way-back-home/level_2
./deploy_cloud_run.sh

डिप्लॉयमेंट पूरा होने के बाद, आपको यूआरएल मिलेगा. यह आपके लिए डिप्लॉय किया गया यूआरएल है!

👉💻 यूआरएल पाने से पहले, यह कमांड चलाकर अनुमति दें:

source .env && gcloud run services add-iam-policy-binding survivor-frontend --region $REGION --member=allUsers --role=roles/run.invoker && gcloud run services add-iam-policy-binding survivor-backend --region $REGION --member=allUsers --role=roles/run.invoker

डिप्लॉय किए गए यूआरएल पर जाएं. आपको अपना ऐप्लिकेशन लाइव दिखेगा!

2. बिल्ड पाइपलाइन के बारे में जानकारी

cloudbuild.yaml फ़ाइल में, क्रम से इन चरणों के बारे में बताया गया है:

1. Backend Build: backend/Dockerfile से Docker इमेज बनाता है.
2. बैकएंड डिप्लॉय करें: इससे बैकएंड कंटेनर को Cloud Run पर डिप्लॉय किया जाता है.
3. यूआरएल कैप्चर करें: इससे नया बैकएंड यूआरएल मिलता है.
4. फ़्रंटएंड बिल्ड:
   • डिपेंडेंसी इंस्टॉल करता है.
   • यह React ऐप्लिकेशन बनाता है और उसमें VITE_API_URL= को इंजेक्ट करता है.
5. फ़्रंटएंड इमेज: यह frontend/Dockerfile से Docker इमेज बनाता है (स्टैटिक ऐसेट को पैकेज करता है).
6. फ़्रंटएंड डिप्लॉय करें: इससे फ़्रंटएंड कंटेनर डिप्लॉय होता है.

3. डिप्लॉयमेंट की पुष्टि करना

बिल्ड पूरा होने के बाद (स्क्रिप्ट से मिले लॉग लिंक देखें), पुष्टि की जा सकती है:

1. Cloud Run Console पर जाएं.
2. survivor-frontend सेवा ढूंढें.
3. ऐप्लिकेशन खोलने के लिए, यूआरएल पर क्लिक करें.
4. खोज क्वेरी चलाएं, ताकि यह पक्का किया जा सके कि फ़्रंटएंड, बैकएंड से कम्यूनिकेट कर सकता है.

4. (!सिर्फ़ वर्कशॉप में हिस्सा लेने वाले लोगों के लिए) अपनी जगह की जानकारी अपडेट करना

👉💻 स्क्रिप्ट पूरी होने पर चलने वाली स्क्रिप्ट को चलाएं:

cd ~/way-back-home/level_2
./set_level_2.sh

अगर आपने वर्कशॉप में हिस्सा नहीं लिया है और लेवल 0 पूरा नहीं किया है, तो आपको गड़बड़ी का मैसेज दिखेगा.

अब waybackhome.dev खोलें. आपको दिखेगा कि आपकी जगह की जानकारी अपडेट हो गई है. लेवल 2 पूरा करने के लिए बधाई!

(ज़रूरी नहीं) 5. मैन्युअल डिप्लॉयमेंट

अगर आपको मैन्युअल तरीके से कमांड चलाने हैं या प्रोसेस को बेहतर तरीके से समझना है, तो cloudbuild.yaml का इस्तेमाल करने का तरीका यहां दिया गया है.

cloudbuild.yaml लिखा जा रहा है

cloudbuild.yaml फ़ाइल से, Google Cloud Build को यह पता चलता है कि कौनसे चरण पूरे करने हैं.

• steps: क्रम से की जाने वाली कार्रवाइयों की सूची. हर चरण, एक कंटेनर में चलता है. जैसे, docker, gcloud, node, bash).
• substitutions: ऐसे वैरिएबल जिन्हें बिल्ड टाइम पर पास किया जा सकता है. उदाहरण के लिए, $_REGION).
• workspace: यह एक शेयर की गई डायरेक्ट्री होती है. इसमें चरण, फ़ाइलें शेयर कर सकते हैं. जैसे, हम backend_url.txt शेयर करते हैं.

डिप्लॉयमेंट चलाना

स्क्रिप्ट के बिना मैन्युअल तरीके से डिप्लॉय करने के लिए, gcloud builds submit कमांड का इस्तेमाल करें. आपको ज़रूरी वैरिएबल की वैल्यू पास करनी होगी.

# Load your env vars first or replace these values manually
export PROJECT_ID=your-project-id
export REGION=us-central1

gcloud builds submit --config cloudbuild.yaml \
    --project "$PROJECT_ID" \
    --substitutions _REGION="us-central1",_GOOGLE_API_KEY="",_AGENT_ENGINE_ID="your-agent-id",_USE_MEMORY_BANK="TRUE",_GOOGLE_GENAI_USE_VERTEXAI="TRUE"

15. नतीजा

1. आपने क्या बनाया है

✅ ग्राफ़ डेटाबेस: नोड (सर्वाइवर, कौशल) और किनारों (संबंध) के साथ Spanner
✅ एआई की मदद से खोज करने की सुविधा: कीवर्ड, सिमैंटिक, और हाइब्रिड सर्च के साथ एम्बेडिंग
✅ मल्टीमॉडल पाइपलाइन: Gemini की मदद से इमेज/वीडियो से इकाइयां निकालना
✅ मल्टी-एजेंट सिस्टम: ADK के साथ कोऑर्डिनेट किया गया वर्कफ़्लो
✅ मेमोरी बैंक: Vertex AI की मदद से लंबे समय तक निजीकरण करना
✅ प्रोडक्शन डिप्लॉयमेंट: Cloud Run + Agent Engine

2. आर्किटेक्चर की खास जानकारी

3. मुख्य बातें

1. ग्राफ़ आरएजी: यह ग्राफ़ डेटाबेस स्ट्रक्चर को सिमैंटिक एम्बेडिंग के साथ जोड़ता है, ताकि बेहतर तरीके से खोज की जा सके
2. मल्टी-एजेंट पैटर्न: जटिल और कई चरणों वाले वर्कफ़्लो के लिए सीक्वेंशियल पाइपलाइन
3. मल्टीमॉडल एआई: अनस्ट्रक्चर्ड मीडिया (इमेज/वीडियो) से स्ट्रक्चर्ड डेटा निकालना
4. स्टेटफ़ुल एजेंट: Memory Bank की मदद से, सभी सेशन में उपयोगकर्ता के हिसाब से अनुभव को बेहतर बनाया जा सकता है

4. वर्कशॉप का कॉन्टेंट

• Level0: अपनी पहचान की पुष्टि करें
• Level1: Pinpoint Location
• Level2 This One: Graph RAG, ADK, और Memory Bank की मदद से मल्टीमॉडल एआई एजेंट बनाना
• Level3: Building an ADK Bi-Directional Streaming Agent
• Level4: लाइव बाइ-डायरेक्शनल मल्टी-एजेंट सिस्टम
• Level5: Google ADK, A2A, और Kafka के साथ इवेंट-ड्रिवन आर्किटेक्चर

5. संसाधन

• ADK से जुड़े दस्तावेज़
• Spanner Graph
• Memory Bank Guide
• GitHub रिपॉज़िटरी

बधाई हो! आपने प्रोडक्शन-ग्रेड एआई एजेंट सिस्टम बनाया है. इसमें ग्राफ़ डेटाबेस, आरएजी खोज, मल्टीमॉडल प्रोसेसिंग, और लॉन्ग-टर्म मेमोरी की सुविधा है. ये पैटर्न, ऐसे किसी भी डोमेन पर लागू होते हैं जहां डेटा को बेहतर तरीके से मैनेज करने की ज़रूरत होती है. जैसे, लॉजिस्टिक्स, स्वास्थ्य सेवा, और ग्राहक सेवा.