ADK, AlloyDB, और Vertex AI Memory Bank की मदद से, Supply Chain Orchestrator बनाना

1. खास जानकारी

इस कोडलैब में, आपको सप्लाई चेन ऑर्केस्ट्रेटर एजेंट बनाने का तरीका बताया गया है. इस ऐप्लिकेशन की मदद से, उपयोगकर्ता आम भाषा में इन्वेंट्री का विश्लेषण कर सकते हैं. साथ ही, लॉजिस्टिक्स को ट्रैक कर सकते हैं और सप्लाई चेन से जुड़े जोखिमों को मैनेज कर सकते हैं.

हम Google के एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, मल्टी-एजेंट आर्किटेक्चर बनाएंगे. यह आर्किटेक्चर, कॉन्टेक्स्ट को बनाए रखता है. साथ ही, Vertex AI Memory Bank के ज़रिए उपयोगकर्ता की प्राथमिकताओं को याद रखता है. इसके अलावा, यह MCP टूलबॉक्स के ज़रिए AlloyDB में सेव किए गए बड़े डेटासेट के साथ इंटरैक्ट करता है.

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

91e8e53556ac1966.jpeg

Python Flask ऐप्लिकेशन, जिसमें ये शामिल हैं:

ग्लोबल ऑर्केस्ट्रेटर एजेंट: यह रूट एजेंट होता है. यह बातचीत के फ़्लो और डेलिगेशन को मैनेज करता है.

विशेषज्ञ एजेंट: डोमेन से जुड़े टास्क के लिए, "InventorySpecialist" और "LogisticsManager".

मेमोरी इंटिग्रेशन: इसमें Vertex AI Memory Bank का इस्तेमाल करके, सेशन के दौरान की गई बातचीत को सेव किया जाता है. साथ ही, लंबे समय तक सेव रहने वाली मेमोरी का इस्तेमाल किया जाता है.

नैरेटिव यूज़र इंटरफ़ेस (यूआई): यह एक वेब इंटरफ़ेस है. यह एजेंट के तर्क देने की प्रोसेस (ट्रेस कॉन्टेक्स्ट) को दिखाता है.

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

  • खास एजेंट और सब-एजेंट बनाने के लिए, Google ADK का इस्तेमाल करने का तरीका.
  • एजेंट की लंबे समय तक चलने वाली मेमोरी के लिए, Vertex AI Memory Bank को इंटिग्रेट करने का तरीका.
  • एजेंट को AlloyDB के डेटा टूल से कनेक्ट करने के लिए, MCP टूलबॉक्स का इस्तेमाल कैसे करें.
  • एजेंट के जवाब देने की वजह का पता लगाने और उसे विज़ुअलाइज़ करने के लिए, ADK कॉल बैक को लागू करने का तरीका.
  • Cloud Run का इस्तेमाल करके समाधान को डिप्लॉय करने या इसे स्थानीय तौर पर चलाने का तरीका.

आर्किटेक्चर

टेक्नोलॉजी स्टैक

  1. AlloyDB for PostgreSQL: यह एक बेहतरीन परफ़ॉर्मेंस वाला ऑपरेशनल डेटाबेस है. इसमें सप्लाई चेन के 50,000 से ज़्यादा रिकॉर्ड सेव किए जाते हैं. यह वेक्टर सर्च और जानकारी वापस पाने की सुविधा देता है.
  2. डेटाबेस के लिए एमसीपी टूलबॉक्स: यह "ऑर्केस्ट्रेशन मेस्ट्रो" के तौर पर काम करता है. यह AlloyDB के डेटा को ऐसे टूल के तौर पर दिखाता है जिन्हें एजेंट कॉल कर सकते हैं.
  3. एजेंट डेवलपमेंट किट (एडीके): यह एक फ़्रेमवर्क है. इसका इस्तेमाल एजेंट, निर्देश, और टूल तय करने के लिए किया जाता है.
  4. Vertex AI Memory Bank: यह सुविधा, लंबे समय तक जानकारी सेव करके रखती है. इससे एजेंट को अलग-अलग सेशन में, उपयोगकर्ता की प्राथमिकताओं और पिछली बातचीत को याद रखने में मदद मिलती है.
  5. Vertex AI Session Service: यह कम समय के लिए बातचीत के कॉन्टेक्स्ट को मैनेज करती है.

The Flow

  1. उपयोगकर्ता की क्वेरी: उपयोगकर्ता कोई सवाल पूछता है. उदाहरण के लिए, "प्रीमियम आइसक्रीम का स्टॉक देखें".
  2. मेमोरी की जांच: Orchestrator, मेमोरी बैंक में मौजूद पिछली जानकारी की जांच करता है. जैसे, "उपयोगकर्ता EMEA का रीजनल मैनेजर है".
  3. टास्क सौंपना: Orchestrator, InventorySpecialist को टास्क सौंपता है.
  4. टूल का इस्तेमाल: स्पेशलिस्ट, AlloyDB से क्वेरी करने के लिए, MCP टूलबॉक्स में दिए गए टूल का इस्तेमाल करता है.
  5. जवाब: एजेंट, डेटा को प्रोसेस करता है और मार्कडाउन फ़ॉर्मैट में टेबल दिखाता है.
  6. मेमोरी स्टोरेज: अहम इंटरैक्शन को मेमोरी बैंक में वापस सेव किया जाता है.

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

  • कोई ब्राउज़र, जैसे कि Chrome या Firefox.
  • बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट.
  • एसक्यूएल और Python की बुनियादी जानकारी.

2. शुरू करने से पहले

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

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

Cloud Shell बटन की इमेज चालू करें

  1. Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट किया गया है, इस कमांड का इस्तेमाल करें:
gcloud auth list
  1. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं.
gcloud config list project
  1. अगर आपका प्रोजेक्ट सेट नहीं है, तो इसे सेट करने के लिए इस निर्देश का इस्तेमाल करें:
gcloud config set project <YOUR_PROJECT_ID>
  1. ज़रूरी एपीआई चालू करें: लिंक पर जाएं और एपीआई चालू करें.

इसके अलावा, इसके लिए gcloud कमांड का इस्तेमाल किया जा सकता है. gcloud कमांड और उनके इस्तेमाल के बारे में जानने के लिए, दस्तावेज़ देखें.

समस्याएं और उन्हें हल करने का तरीका

"घोस्ट प्रोजेक्ट" सिंड्रोम

आपने gcloud config set project चलाया है, लेकिन Console के यूज़र इंटरफ़ेस (यूआई) में कोई दूसरा प्रोजेक्ट देखा जा रहा है. सबसे ऊपर बाईं ओर मौजूद ड्रॉपडाउन में प्रोजेक्ट आईडी देखें!

बिलिंग बैरिकेड

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

एपीआई के डेटा को अपडेट होने में लगने वाला समय

आपने "एपीआई चालू करें" पर क्लिक किया है, लेकिन कमांड लाइन में अब भी Service Not Enabled दिख रहा है. इसे 60 सेकंड तक दबाकर रखें. क्लाउड को अपने न्यूरॉन को चालू करने में कुछ समय लगता है.

कोटा Quags

अगर आपने नया ट्रायल खाता इस्तेमाल किया है, तो हो सकता है कि आपने AlloyDB इंस्टेंस के लिए क्षेत्र के हिसाब से तय किया गया कोटा पूरा कर लिया हो. अगर us-central1 काम नहीं करता है, तो us-east1 आज़माएं.

"छिपा हुआ" सर्विस एजेंट

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

3. डेटाबेस सेटअप करना

हमारे ऐप्लिकेशन के लिए, AlloyDB for PostgreSQL सबसे अहम है. हमने इसकी बेहतर वेक्टर क्षमताओं का इस्तेमाल किया. साथ ही, 50,000 से ज़्यादा एससीएम रिकॉर्ड के लिए एम्बेडिंग जनरेट करने के लिए, कॉलम वाले इंजन को इंटिग्रेट किया. इससे, वेक्टर का विश्लेषण करीब-करीब रीयल-टाइम में किया जा सकता है. इससे हमारे एजेंट, बड़े डेटासेट में इन्वेंट्री की गड़बड़ियों या लॉजिस्टिक्स से जुड़े जोखिमों की पहचान कुछ ही मिलीसेकंड में कर पाते हैं.

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

आइए, एक AlloyDB क्लस्टर, इंस्टेंस, और टेबल बनाएं. इसमें टेस्ट डेटासेट लोड किया जाएगा.

  1. उस ब्राउज़र में नीचे दिए गए बटन पर क्लिक करें या लिंक को कॉपी करें जिसमें Google Cloud Console का उपयोगकर्ता लॉग इन है.

इसके अलावा, उस प्रोजेक्ट से Cloud Shell टर्मिनल पर जाएं जहां आपने बिलिंग खाता रिडीम किया है. इसके बाद, GitHub repo को क्लोन करें और नीचे दिए गए निर्देशों का इस्तेमाल करके प्रोजेक्ट पर जाएं:

git clone https://github.com/AbiramiSukumaran/easy-alloydb-setup

cd easy-alloydb-setup
  1. यह चरण पूरा होने के बाद, repo को आपके लोकल क्लाउड शेल एडिटर में क्लोन कर दिया जाएगा. इसके बाद, प्रोजेक्ट फ़ोल्डर में जाकर नीचे दिए गए कमांड को चलाया जा सकेगा. यह पक्का करना ज़रूरी है कि आप प्रोजेक्ट डायरेक्ट्री में हों:
sh run.sh
  1. अब यूज़र इंटरफ़ेस (टर्मिनल में लिंक पर क्लिक करके या टर्मिनल में "वेब पर झलक देखें" लिंक पर क्लिक करके) का इस्तेमाल करें.
  2. शुरू करने के लिए, प्रोजेक्ट आईडी, क्लस्टर, और इंस्टेंस के नाम डालें.
  3. जब तक लॉग स्क्रोल होते हैं, तब तक जाकर कॉफ़ी ले आएं. यहां यह भी बताया गया है कि पर्दे के पीछे यह कैसे काम करता है.

समस्याएं और उन्हें हल करने का तरीका

"धैर्य" की समस्या

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

क्षेत्र की जानकारी मेल न खाना

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

ज़ॉम्बी क्लस्टर

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

Cloud Shell का टाइम आउट होना

अगर आपका कॉफ़ी ब्रेक 30 मिनट का है, तो Cloud Shell स्लीप मोड में जा सकता है और sh run.sh की प्रोसेस बंद हो सकती है. टैब को चालू रखें!

4. स्कीमा प्रोविज़निंग

AlloyDB क्लस्टर और इंस्टेंस चालू होने के बाद, AlloyDB Studio के एसक्यूएल एडिटर पर जाएं. यहां एआई एक्सटेंशन चालू करें और स्कीमा उपलब्ध कराएं.

1e3ac974b18a8113.png

आपको इंस्टेंस बनने तक इंतज़ार करना पड़ सकता है. इसके बाद, क्लस्टर बनाते समय बनाए गए क्रेडेंशियल का इस्तेमाल करके, AlloyDB में साइन इन करें. PostgreSQL में पुष्टि करने के लिए, इस डेटा का इस्तेमाल करें:

  • उपयोगकर्ता नाम : "postgres"
  • डेटाबेस : "postgres"
  • पासवर्ड : "alloydb" (या क्रिएशन के समय सेट किया गया कोई भी पासवर्ड)

AlloyDB Studio में पुष्टि हो जाने के बाद, SQL कमांड को एडिटर में डाला जाता है. आखिरी विंडो के दाईं ओर मौजूद प्लस आइकॉन का इस्तेमाल करके, एक से ज़्यादा एडिटर विंडो जोड़ी जा सकती हैं.

28cb9a8b6aa0789f.png

एडिटर विंडो में, AlloyDB के लिए कमांड डाली जाती हैं. इसके लिए, ज़रूरत के हिसाब से 'चलाएं', 'फ़ॉर्मैट करें', और 'मिटाएं' विकल्पों का इस्तेमाल किया जाता है.

एक्सटेंशन चालू करना

इस ऐप्लिकेशन को बनाने के लिए, हम pgvector और google_ml_integration एक्सटेंशन का इस्तेमाल करेंगे. pgvector एक्सटेंशन की मदद से, वेक्टर एम्बेडिंग को सेव किया जा सकता है और उन्हें खोजा जा सकता है. google_ml_integration एक्सटेंशन, ऐसे फ़ंक्शन उपलब्ध कराता है जिनका इस्तेमाल करके, Vertex AI के अनुमान लगाने वाले एंडपॉइंट को ऐक्सेस किया जा सकता है. इससे एसक्यूएल में अनुमान मिलते हैं. इन एक्सटेंशन को चालू करें. इसके लिए, ये DDL चलाएं:

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

टेबल बनाना

AlloyDB Studio में, नीचे दिए गए डीडीएल स्टेटमेंट का इस्तेमाल करके टेबल बनाई जा सकती है:

DROP TABLE IF EXISTS shipments;
DROP TABLE IF EXISTS products;

-- 1. Product Inventory Table

CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(255) NOT NULL,
category VARCHAR(100),
stock_level INTEGER,
distribution_center VARCHAR(100),
region VARCHAR(50),
embedding vector(768),
last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 2. Logistics & Shipments
CREATE TABLE shipments (
shipment_id SERIAL PRIMARY KEY,
product_id INTEGER REFERENCES products(id),
status VARCHAR(50), -- 'In Transit', 'Delayed', 'Delivered', 'Pending'
estimated_arrival TIMESTAMP,
route_efficiency_score DECIMAL(3, 2)
);

embedding कॉलम में, कुछ टेक्स्ट फ़ील्ड की वेक्टर वैल्यू सेव की जा सकेंगी.

डेटा डालना

प्रॉडक्ट टेबल में एक साथ 50,000 रिकॉर्ड डालने के लिए, एसक्यूएल स्टेटमेंट का यह सेट चलाएं:

-- We use a CROSS JOIN pattern with realistic naming segments to create meaningful variety
DO $$
DECLARE
brand_names TEXT[] := ARRAY['Artisan', 'Nature', 'Elite', 'Pure', 'Global', 'Eco', 'Velocity', 'Heritage', 'Aura', 'Summit'];
product_types TEXT[] := ARRAY['Ice Cream', 'Body Wash', 'Laundry Detergent', 'Shampoo', 'Mayonnaise', 'Deodorant', 'Tea', 'Soup', 'Face Cream', 'Soap'];
variants TEXT[] := ARRAY['Classic', 'Gold', 'Premium', 'Eco-Friendly', 'Organic', 'Night-Repair', 'Extra-Fresh', 'Zero-Sugar', 'Sensitive', 'Maximum-Strength'];
regions TEXT[] := ARRAY['EMEA', 'APAC', 'LATAM', 'NAMER'];
dcs TEXT[] := ARRAY['London-Hub', 'Mumbai-Central', 'Sao-Paulo-Logistics', 'Singapore-Port', 'Rotterdam-Gate', 'New-York-DC'];
BEGIN
INSERT INTO products (name, category, stock_level, distribution_center, region)
SELECT
b || ' ' || v || ' ' || t as name,
CASE
WHEN t IN ('Ice Cream', 'Mayonnaise', 'Tea', 'Soup') THEN 'Food & Refreshment'
WHEN t IN ('Body Wash', 'Shampoo', 'Deodorant', 'Face Cream', 'Soap') THEN 'Personal Care'
ELSE 'Home Care'
END as category,
floor(random() * 20000 + 100)::int as stock_level,
dcs[floor(random() * 6 + 1)] as distribution_center,
regions[floor(random() * 4 + 1)] as region
FROM
unnest(brand_names) b,
unnest(variants) v,
unnest(product_types) t,
generate_series(1, 50); -- 10 * 10 * 10 * 50 = 50,000 records
END $$;

आइए, डेमो के लिए कुछ खास रिकॉर्ड डालें, ताकि एक्ज़ीक्यूटिव स्टाइल के सवालों के अनुमानित जवाब मिल सकें

-- These ensure you have predictable answers for specific "Executive" questions
INSERT INTO products (name, category, stock_level, distribution_center, region) VALUES
('Magnum Ultra Gold Limited Edition', 'Food & Refreshment', 45, 'Rotterdam-Gate', 'EMEA'),
('Dove Pro-Health Deep Moisture', 'Personal Care', 12000, 'Mumbai-Central', 'APAC'),
('Hellmanns Real Organic Mayonnaise', 'Food & Refreshment', 8000, 'London-Hub', 'EMEA');

शिपमेंट का डेटा डालना

-- Shipments Generation (More shipments than products)
INSERT INTO shipments (product_id, status, estimated_arrival, route_efficiency_score)
SELECT
id,
CASE
WHEN random() > 0.8 THEN 'Delayed'
WHEN random() > 0.4 THEN 'In Transit'
ELSE 'Delivered'
END,
NOW() + (random() * 10 || ' days')::interval,
(random() * 0.5 + 0.5)::decimal(3,2)
FROM products
WHERE random() > 0.3; -- Create shipments for ~70% of products


-- Add duplicate shipments for some products to show complex logistics
INSERT INTO shipments (product_id, status, estimated_arrival, route_efficiency_score)
SELECT id, 'In Transit', NOW() + INTERVAL '12 days', 0.88
FROM products
LIMIT 5000;

अनुमति दें

"embedding" फ़ंक्शन को लागू करने की अनुमति देने के लिए, नीचे दिए गए स्टेटमेंट को चलाएं:

GRANT EXECUTE ON FUNCTION embedding TO postgres;

AlloyDB सेवा खाते को Vertex AI User की भूमिका असाइन करना

Google Cloud IAM Console में जाकर, AlloyDB सेवा खाते को "Vertex AI User" की भूमिका का ऐक्सेस दें. यह सेवा खाता इस तरह दिखता है: service-<<PROJECT_NUMBER >>@gcp-sa-alloydb.iam.gserviceaccount.com. PROJECT_NUMBER में आपका प्रोजेक्ट नंबर होगा.

इसके अलावा, Cloud Shell टर्मिनल से नीचे दिया गया कमांड भी चलाया जा सकता है:

PROJECT_ID=$(gcloud config get-value project)


gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

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

इसके बाद, कुछ खास टेक्स्ट फ़ील्ड के लिए वेक्टर एम्बेडिंग जनरेट करते हैं:

WITH
 rows_to_update AS (
 SELECT
   id
 FROM
   products
 WHERE
   embedding IS NULL
 LIMIT
   5000 )
UPDATE
 products
SET
 embedding = ai.embedding('text-embedding-005', name || ' ' || category || ' ' || distribution_center || ' ' || region)::vector
FROM
 rows_to_update
WHERE
 products.id = rows_to_update.id
 AND embedding IS null;

ऊपर दिए गए स्टेटमेंट में, हमने सीमा को 5,000 पर सेट किया है. इसलिए, इसे तब तक बार-बार चलाएं, जब तक टेबल में कोई ऐसी पंक्ति न हो जिसमें कॉलम एम्बेडिंग NULL के तौर पर हो.

समस्याएं और उन्हें हल करने का तरीका

"पासवर्ड भूल जाना" लूप

अगर आपने "एक क्लिक" सेटअप का इस्तेमाल किया है और आपको अपना पासवर्ड याद नहीं है, तो कंसोल में इंस्टेंस की बुनियादी जानकारी वाले पेज पर जाएं. इसके बाद, postgres पासवर्ड रीसेट करने के लिए, "बदलें" पर क्लिक करें.

"एक्सटेंशन नहीं मिला" गड़बड़ी

अगर CREATE EXTENSION की जांच पूरी नहीं होती है, तो इसकी वजह यह हो सकती है कि इंस्टेंस अब भी शुरुआती प्रोविज़निंग के दौरान "रखरखाव" या "अपडेट किया जा रहा है" स्थिति में है. देखें कि इंस्टेंस बनाने का चरण पूरा हो गया है या नहीं. अगर ज़रूरी हो, तो कुछ सेकंड इंतज़ार करें.

IAM के लागू होने में लगने वाला समय

आपने gcloud IAM कमांड चलाई, लेकिन SQL CALL में अब भी अनुमति से जुड़ी गड़बड़ी आ रही है. IAM में किए गए बदलावों को Google के बैकबोन नेटवर्क पर लागू होने में थोड़ा समय लग सकता है. साँस लें.

वेक्टर डाइमेंशन का मेल न खाना

items टेबल को VECTOR(768) पर सेट किया गया है. अगर बाद में किसी दूसरे मॉडल (जैसे कि 1536-डिम मॉडल) का इस्तेमाल किया जाता है, तो आपके इंसर्ट बहुत ज़्यादा हो जाएंगे. text-embedding-005 पर बने रहें.

प्रोजेक्ट आईडी में टाइपिंग से जुड़ी गड़बड़ी

create_model कॉल में, अगर आपने ब्रैकेट « » छोड़ दिए हैं या प्रोजेक्ट आईडी गलत टाइप किया है, तो मॉडल रजिस्ट्रेशन सफल दिखेगा. हालांकि, पहली क्वेरी के दौरान यह काम नहीं करेगा. अपनी स्ट्रिंग की दोबारा जांच करें!

5. टूल और टूलबॉक्स सेटअप

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

हम डेटाबेस के लिए मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) टूलबॉक्स का इस्तेमाल "कंडक्टर" के तौर पर करते हैं. यह हमारे एजेंट और AlloyDB के बीच स्टैंडर्ड मिडलवेयर के तौर पर काम करता है. tools.yaml कॉन्फ़िगरेशन तय करके, टूलबॉक्स अपने-आप डेटाबेस की मुश्किल कार्रवाइयों को साफ़ तौर पर लागू होने वाले टूल के तौर पर दिखाता है. जैसे, search_products_by_context या check_inventory_levels. इससे एजेंट लॉजिक में, मैन्युअल कनेक्शन पूलिंग या बॉयलरप्लेट एसक्यूएल की ज़रूरत नहीं पड़ती.

Toolbox सर्वर इंस्टॉल करना

Cloud Shell टर्मिनल में, अपने नए टूल की YAML फ़ाइल और टूलबॉक्स बाइनरी को सेव करने के लिए एक फ़ोल्डर बनाएं:

mkdir scm-agent-toolbox

cd scm-agent-toolbox

उस नए फ़ोल्डर में जाकर, यह कमांड चलाएं:

# see releases page for other versions
export VERSION=0.27.0
curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

इसके बाद, Cloud Shell Editor में जाकर उस नए फ़ोल्डर में tools.yaml फ़ाइल बनाएं. साथ ही, इस repo फ़ाइल के कॉन्टेंट को tools.yaml फ़ाइल में कॉपी करें.

sources:
    supply_chain_db:
        kind: "alloydb-postgres"
        project: "YOUR_PROJECT_ID"
        region: "us-central1"
        cluster: "YOUR_CLUSTER"
        instance: "YOUR_INSTANCE"
        database: "postgres"
        user: "postgres"
        password: "YOUR_PASSWORD"

tools:
  search_products_by_context:
    kind: postgres-sql
    source: supply_chain_db
    description: Find products in the inventory using natural language search and vector embeddings.
    parameters:
      - name: search_text
        type: string
        description: Description of the product or category the user is looking for.
    statement: |
     SELECT name, category, stock_level, distribution_center, region
      FROM products
      ORDER BY embedding <=> ai.embedding('text-embedding-005', $1)::vector
      LIMIT 5;

  check_inventory_levels:
    kind: postgres-sql
    source: supply_chain_db
    description: Get precise stock levels for a specific product name.
    parameters:
      - name: product_name
        type: string
        description: The exact or partial name of the product.
    statement: |
     SELECT name, stock_level, distribution_center, last_updated
      FROM products
      WHERE name ILIKE '%' || $1 || '%'
      ORDER BY stock_level DESC;

  track_shipment_status:
    kind: postgres-sql
    source: supply_chain_db
    description: Retrieve real-time logistics and shipping status for a specific region or product.
    parameters:
      - name: region
        type: string
        description: The geographical region to filter shipments (e.g., EMEA, APAC).
    statement: |
     SELECT p.name, s.status, s.estimated_arrival, s.route_efficiency_score
      FROM shipments s
      JOIN products p ON s.product_id = p.id
      WHERE p.region = $1
      ORDER BY s.estimated_arrival ASC;

  analyze_supply_chain_risk:
    kind: postgres-sql
    source: supply_chain_db
    description: Rerank and filter shipments based on risk profiles and efficiency scores using Google ML reranker.
    parameters:
      - name: risk_context
        type: string
        description: The business context for risk analysis (e.g., 'heatwave impact' or 'port strike').
    statement: |
     WITH initial_ranking AS (
      SELECT s.shipment_id, p.name, s.status, p.distribution_center,
      ROW_NUMBER() OVER () AS ref_number
      FROM shipments s
      JOIN products p ON s.product_id = p.id
      WHERE s.status != 'Delivered'
      LIMIT 10
      ),
      reranked_results AS (
      SELECT index, score FROM
      ai.rank(
      model_id => 'semantic-ranker-default-003',
      search_string => $1,
      documents => (SELECT ARRAY_AGG(name || ' at ' || distribution_center ORDER BY ref_number) FROM initial_ranking)
      )
      )
      SELECT i.name, i.status, i.distribution_center, r.score
      FROM initial_ranking i, reranked_results r
      WHERE i.ref_number = r.index
      ORDER BY r.score DESC;

toolsets:
   supply_chain_toolset:
     - search_products_by_context
     - check_inventory_levels
     - track_shipment_status
     - analyze_supply_chain_risk

अब लोकल सर्वर में tools.yaml फ़ाइल की जांच करें:

./toolbox --tools-file "tools.yaml"

इसके अलावा, यूज़र इंटरफ़ेस (यूआई) में भी इसकी जांच की जा सकती है

./toolbox --ui

बहुत बढ़िया!! जब आपको लगे कि यह सब काम कर रहा है, तो इसे Cloud Run में इस तरह डिप्लॉय करें.

Cloud Run डिप्लॉयमेंट

  1. PROJECT_ID एनवायरमेंट वैरिएबल सेट करें:
export PROJECT_ID="my-project-id"
  1. gcloud सीएलआई शुरू करें:
gcloud init
gcloud config set project $PROJECT_ID
  1. आपके पास ये एपीआई चालू होने चाहिए:
gcloud services enable run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       iam.googleapis.com \
                       secretmanager.googleapis.com
  1. अगर आपके पास पहले से कोई बैकएंड सेवा खाता नहीं है, तो उसे बनाएं:
gcloud iam service-accounts create toolbox-identity
  1. Secret Manager का इस्तेमाल करने की अनुमतियां दें:
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor
  1. सेवा खाते को अतिरिक्त अनुमतियां दें. ये अनुमतियां, हमारे AlloyDB सोर्स (roles/alloydb.client और roles/serviceusage.serviceUsageConsumer) के लिए खास तौर पर दी जाती हैं
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \
    --role roles/alloydb.client


gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \
    --role serviceusage.serviceUsageConsumer
  1. tools.yaml को सीक्रेट के तौर पर अपलोड करें:
gcloud secrets create tools-scm-agent --data-file=tools.yaml
  1. अगर आपके पास पहले से कोई सीक्रेट है और आपको सीक्रेट का वर्शन अपडेट करना है, तो यह तरीका अपनाएं:
gcloud secrets versions add tools-scm-agent --data-file=tools.yaml
  1. उस कंटेनर इमेज के लिए एनवायरमेंट वैरिएबल सेट करें जिसका इस्तेमाल Cloud Run के लिए करना है:
export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest
  1. इस कमांड का इस्तेमाल करके, Toolbox को Cloud Run पर डिप्लॉय करें:

अगर आपने अपने AlloyDB इंस्टेंस में सार्वजनिक ऐक्सेस चालू किया है (यह सुझाव नहीं दिया जाता), तो Cloud Run पर डिप्लॉय करने के लिए, यहां दिया गया निर्देश इस्तेमाल करें:

gcloud run deploy toolbox-scm-agent \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools-scm-agent:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --allow-unauthenticated

अगर वीपीसी नेटवर्क का इस्तेमाल किया जा रहा है, तो यहां दिए गए निर्देश का इस्तेमाल करें:

gcloud run deploy toolbox-scm-agent \
    --image $IMAGE \
    --service-account toolbox-identity \
    --region us-central1 \
    --set-secrets "/app/tools.yaml=tools-scm-agent:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    # TODO(dev): update the following to match your VPC details
    --network <<YOUR_NETWORK_NAME>> \
    --subnet <<YOUR_SUBNET_NAME>> \
    --allow-unauthenticated

6. एजेंट सेटअप

एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, हमने मोनोलिथिक प्रॉम्प्ट से हटकर, खास मल्टी-एजेंट आर्किटेक्चर की ओर रुख किया है:

  • InventorySpecialist: यह प्रॉडक्ट के स्टॉक और वेयरहाउस की मेट्रिक पर फ़ोकस करता है.
  • LogisticsManager: यह ग्लोबल शिपिंग रूट और जोखिम के विश्लेषण में विशेषज्ञ है.
  • GlobalOrchestrator: यह "ब्रेन" है, जो तर्क का इस्तेमाल करके टास्क सौंपता है और खोज के नतीजों को एक साथ रखता है.

इस रेपो को अपने प्रोजेक्ट में क्लोन करें और आइए, इसके बारे में जानते हैं.

इसे क्लोन करने के लिए, अपने Cloud Shell टर्मिनल में (रूट डायरेक्ट्री में या जहां भी आपको यह प्रोजेक्ट बनाना है), यह कमांड चलाएं:

git clone https://github.com/AbiramiSukumaran/scm-memory-agent
  1. इससे प्रोजेक्ट बन जाएगा. इसकी पुष्टि Cloud Shell Editor में की जा सकती है.

53a398aff6ba7d5b.png

  1. पक्का करें कि आपने .env फ़ाइल को अपने प्रोजेक्ट और इंस्टेंस की वैल्यू के साथ अपडेट किया हो.

कोड के बारे में पूरी जानकारी

ऑर्केस्ट्रेटर एजेंट के बारे में खास जानकारी

    Go to app.py and you should be able to see the following snippet:

orchestrator = adk.Agent(
    name="GlobalOrchestrator",
    model="gemini-2.5-flash",
    description="Global Supply Chain Orchestrator root agent.",
    instruction="""
    You are the Global Supply Chain Brain. You are responsible for products, inventory and logistics.
    You also have access to the memory tool, remember to include all the information that the tool can provide you with about the user before you respond.
    1. Understand intent and delegate to specialists. As the Global Orchestrator, you have access to the full conversation history with the user.
    When you transfer a query to a specialist agent, sub agent or tool, share the important facts and information from your memory to them so they can operate with the full context. 
    2. Ensure the final response is professional and uses Markdown tables for data.
    3. If a specialist provides a long list, ensure only the top 10 items are shown initially.
    4. Conclude with a brief, high-level executive summary of what the data implies.
    """,
    tools=[adk.tools.preload_memory_tool.PreloadMemoryTool()],
    sub_agents=[inventory_agent, logistics_agent],
    
    #after_agent_callback=auto_save_session_to_memory_callback,
)

यह स्निपेट, रूट की परिभाषा है. यह ऑर्केस्ट्रेटर एजेंट है, जो उपयोगकर्ता से बातचीत या अनुरोध पाता है. इसके बाद, यह टास्क के आधार पर, संबंधित सब एजेंट या उपयोगकर्ता को संबंधित टूल पर भेजता है.

  1. आइए, इन्वेंट्री एजेंट के बारे में जानते हैं
inventory_agent = adk.Agent(
    name="InventorySpecialist",
    model="gemini-2.5-flash",
    description="Specialist in product stock and warehouse data.",
    instruction="""
    Analyze inventory levels.
    1. Use 'search_products_by_context' or 'check_inventory_levels'.
    2. ALWAYS format results as a clean Markdown table.
    3. If there are many results, display only the TOP 10 most relevant ones.
    4. At the end, state: 'There are additional records available. Would you like to see more?'
    """,
    tools=tools
)

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

  1. इसके बाद, लॉजिस्टिक्स सब-एजेंट होता है:
logistics_agent = adk.Agent(
    name="LogisticsManager",
    model="gemini-2.5-flash",
    description="Expert in global shipping routes and logistics tracking.",
    instruction="""
    Check shipment statuses.
    1. Use 'track_shipment_status' or 'analyze_supply_chain_risk'.
    2. ALWAYS format results as a clean Markdown table.
    3. Limit initial output to the top 10 shipments.
    4. Ask if the user needs the full manifest if more results exist.
    """,
    tools=tools
)

यह सब-एजेंट, लॉजिस्टिक्स से जुड़ी गतिविधियों में विशेषज्ञ है. जैसे, शिपमेंट को ट्रैक करना और सप्लाई चेन में जोखिमों का विश्लेषण करना.

  1. हमने अब तक जिन तीन एजेंट के बारे में बात की है वे सभी टूल का इस्तेमाल करते हैं. इन टूल का रेफ़रंस, हमारे Toolbox सर्वर के ज़रिए दिया जाता है. इसे हमने पिछले सेक्शन में पहले ही डिप्लॉय कर दिया है. यहां दिए गए स्निपेट को देखें:
from toolbox_core import ToolboxSyncClient

TOOLBOX_SERVER = os.environ["TOOLBOX_SERVER"]
TOOLBOX_TOOLSET = os.environ["TOOLBOX_TOOLSET"]

# --- ADK TOOLBOX CONFIGURATION ---
toolbox = ToolboxSyncClient(TOOLBOX_SERVER)
tools = toolbox.load_toolset(TOOLBOX_TOOLSET)

यह सब-एजेंट, लॉजिस्टिक्स से जुड़ी गतिविधियों में विशेषज्ञ है. जैसे, शिपमेंट को ट्रैक करना और सप्लाई चेन में जोखिमों का विश्लेषण करना.

7. Agent Engine

शुरुआती रन में, एजेंट इंजन बनाएं

import vertexai

GOOGLE_CLOUD_PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
GOOGLE_CLOUD_LOCATION = os.environ["GOOGLE_CLOUD_LOCATION"]

client = vertexai.Client(
  project=GOOGLE_CLOUD_PROJECT,
  location=GOOGLE_CLOUD_LOCATION
)

agent_engine = client.agent_engines.create()
  1. अगली बार चलाने के लिए, एजेंट इंजन को मेमोरी बैंक कॉन्फ़िगरेशन के साथ अपडेट करें:
agent_engine = client.agent_engines.update(
    name=APP_NAME,
    config={
        "context_spec": {
            "memory_bank_config": {
                "generation_config": {
                    "model": f"projects/{PROJECT_ID}/locations/{GOOGLE_CLOUD_LOCATION}/publishers/google/models/gemini-2.5-flash"
                }
            }
        }
    })

8. कॉन्टेक्स्ट, रन, और मेमोरी

कॉन्टेक्स्ट मैनेजमेंट को दो अलग-अलग लेयर में बांटा गया है, ताकि एजेंट को ऐसा लगे कि वह एक लगातार काम करने वाला पार्टनर है, न कि स्टेटलेस बॉट:

कम समय के लिए सेव की गई मेमोरी (सेशन): इसे VertexAiSessionService के ज़रिए मैनेज किया जाता है. यह एक इंटरैक्शन के दौरान, इवेंट के इतिहास (उपयोगकर्ता के मैसेज, टूल के जवाब) को ट्रैक करता है.

लॉन्ग-टर्म मेमोरी (मेमोरी बैंक): यह adk.memorybankservice के ज़रिए Vertex AI Memory Bank की मदद से काम करती है. यह लेयर, "काम की" जानकारी निकालती है. जैसे, किसी उपयोगकर्ता की पसंद के शिपिंग कैरियर या बार-बार होने वाली वेयरहाउस में देरी. साथ ही, यह जानकारी सभी सेशन में बनी रहती है.

बातचीत के दायरे में सेशन मेमोरी के लिए सेशन शुरू करता है

यह स्निपेट का वह हिस्सा है जो मौजूदा उपयोगकर्ता के लिए, मौजूदा ऐप्लिकेशन का सेशन बनाता है.

from google.adk.sessions import VertexAiSessionService

...

session_service = VertexAiSessionService(
    project=PROJECT_ID,
    location=GOOGLE_CLOUD_LOCATION,
)

...

# Initialize the session *outside* of the route handler to avoid repeated creation
session = None
session_lock = threading.Lock()

async def initialize_session():
    global session
    try:
        session = await session_service.create_session(app_name=APP_NAME, user_id=USER_ID)
        print(f"Session {session.id} created successfully.")  # Add a log
    except Exception as e:
        print(f"Error creating session: {e}")
        session = None  # Ensure session is None in case of error

# Create the session on app startup
asyncio.run(initialize_session())

लंबे समय तक चलने वाली मेमोरी के लिए, Vertex AI Memory Bank को शुरू करना

यह स्निपेट का वह हिस्सा है जो एजेंट इंजन के लिए, Vertex AI Memory Bank Service ऑब्जेक्ट को इंस्टैंशिएट करता है.

from google.adk.memory import InMemoryMemoryService
from google.adk.memory import VertexAiMemoryBankService

...

try:
    memory_bank_service = adk.memory.VertexAiMemoryBankService(
        agent_engine_id=AGENT_ENGINE_ID,
        project=PROJECT_ID,
        location=GOOGLE_CLOUD_LOCATION,
    )
    #in_memory_service = InMemoryMemoryService()
    print("Memory Bank Service initialized successfully.")
except Exception as e:
    print(f"Error initializing Memory Bank Service: {e}")
    memory_bank_service = None

runner = adk.Runner(
    agent=orchestrator,
    app_name=APP_NAME,
    session_service=session_service,
    memory_service=memory_bank_service,
)

...

क्या कॉन्फ़िगर किया गया है?

स्निपेट के इस हिस्से में, हम लंबी अवधि की मेमोरी के लिए Vertex AI Memory Bank Service को कॉन्फ़िगर कर रहे हैं. यह किसी खास ऐप्लिकेशन के सेशन को किसी खास उपयोगकर्ता के लिए, Vertex AI Memory Bank में मेमोरी के तौर पर सेव करता है.

एजेंट के एक्ज़ीक्यूशन के दौरान क्या-क्या काम किए जाते हैं?

   async def run_and_collect():
        final_text = ""
        try:
            async for event in runner.run_async(
                new_message=content,
                user_id=user_id,
                session_id=session_id
            ):
                if hasattr(event, 'author') and event.author:
                    if not any(log['agent'] == event.author for log in execution_logs):
                        execution_logs.append({
                            "agent": event.author,
                            "action": "Analyzing data requirements...",
                            "type": "orchestration_event"
                        })
                if hasattr(event, 'text') and event.text:
                    final_text = event.text
                elif hasattr(event, 'content') and hasattr(event.content, 'parts'):
                    for part in event.content.parts:
                        if hasattr(part, 'text') and part.text:
                            final_text = part.text
        except Exception as e:
            print(f"Error during runner.run_async: {e}")
            raise  # Re-raise the exception to signal failure
        finally:
            gc.collect()
            return final_text

यह कुकी, उपयोगकर्ता के इनपुट किए गए कॉन्टेंट को new_message ऑब्जेक्ट में प्रोसेस करती है. इसमें उपयोगकर्ता आईडी और सेशन आईडी शामिल होता है. इसके बाद, एजेंट बातचीत को आगे बढ़ाता है. एजेंट के जवाब को प्रोसेस किया जाता है और वापस भेजा जाता है.

लॉन्ग टर्म मेमोरी में क्या सेव होता है?

ऐप्लिकेशन और उपयोगकर्ता के स्कोप में सेशन की जानकारी, सेशन वैरिएबल में निकाली जाती है.

इसके बाद, इस सेशन को "add_session_to_memory" तरीके का इस्तेमाल करके, Vertex AI Memory Bank ऑब्जेक्ट के मौजूदा ऐप्लिकेशन के मौजूदा उपयोगकर्ता के लिए मेमोरी के तौर पर जोड़ा जाता है.

session = asyncio.run(session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=session.id))

if memory_bank_service and session:  # Check memory service AND session
                try:
                    #asyncio.run(in_memory_service.add_session_to_memory(session))
                    asyncio.run(memory_bank_service.add_session_to_memory(session))
                    '''
                    client.agent_engines.memories.generate(
                        scope={"app_name": APP_NAME, "user_id": USER_ID},
                        name=APP_NAME,
                        direct_contents_source={
                            "events": [
                                {"content": content}
                            ]
                        },
                        config={"wait_for_completion": True},
                    )   
                    '''

                    print("Successfully added session to memory.******")
                    print(session.id)

                except Exception as e:
                    print(f"Error adding session to memory: {e}")

याददाश्त वापस पाना

हमें ऐप्लिकेशन के नाम और उपयोगकर्ता के नाम को स्कोप के तौर पर इस्तेमाल करके, सेव की गई लॉन्ग टर्म मेमोरी को वापस पाना होगा. ऐसा इसलिए, क्योंकि हमने मेमोरी को इसी स्कोप के लिए सेव किया था. इससे हम इसे ऑर्केस्ट्रेटर और अन्य एजेंट को कॉन्टेक्स्ट के तौर पर पास कर पाएंगे.

    results = client.agent_engines.memories.retrieve(
    name=APP_NAME,
    scope={"app_name": APP_NAME, "user_id": USER_ID}
    )
    # RetrieveMemories returns a pager. You can use `list` to retrieve all pages' memories.
    list(results)
    print(list(results))

कॉन्टेक्स्ट के हिस्से के तौर पर, वापस लाई गई मेमोरी को कैसे लोड किया जाता है?

हम Orchestrator एजेंट की परिभाषा में इस एट्रिब्यूट का इस्तेमाल करते हैं. इससे रूट एजेंट, मेमोरी बैंक से कॉन्टेक्स्ट को प्रीलोड कर पाता है. यह उन टूल के अलावा है जिन्हें हम सब-एजेंट के लिए टूलबॉक्स सर्वर से ऐक्सेस करते हैं.

tools=[adk.tools.preload_memory_tool.PreloadMemoryTool()],

कॉलबैक कॉन्टेक्स्ट

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

  • ट्रेस इवेंट: "GlobalOrchestrator is analyzing data requirements..."
  • ट्रेस इवेंट: "Delegating to InventorySpecialist for stock levels..."
  • ट्रेस इवेंट: "Retrieving historical supplier delay patterns from Memory Bank..."

यह ऑडिट ट्रेल, डीबग करने के लिए बहुत ज़रूरी है. साथ ही, इससे यह पक्का होता है कि ऑपरेटर, एजेंट के अपने-आप लिए गए फ़ैसलों पर भरोसा कर सकते हैं.

from google.adk.agents.callback_context import CallbackContext

...

# --- ADK CALLBACKS (Narrative Engine) ---
execution_logs = []

async def trace_callback(context: CallbackContext):
    """
    Captures agent and tool invocation flow for the UI narrative.
    """
    agent_name = context.agent.name
    event = {
        "agent": agent_name,
        "action": "Processing request steps...",
        "type": "orchestration_event"
    }
    execution_logs.append(event)
    return None

...

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

इसे आज़माने के लिए, क्लोन की गई रेपो के प्रोजेक्ट फ़ोल्डर पर जाएं और ये कमांड चलाएं:

>> pip install -r requirements.txt

>> python app.py

इससे आपका एजेंट स्थानीय तौर पर शुरू हो जाएगा और आपको इसे टेस्ट करने का विकल्प मिलेगा.

9. इसे Cloud Run पर डिप्लॉय करते हैं

  1. इसे Cloud Run पर डिप्लॉय करें. इसके लिए, Cloud Shell टर्मिनल में यह कमांड चलाएं. यह वह टर्मिनल होना चाहिए जहां प्रोजेक्ट को क्लोन किया गया है. साथ ही, पक्का करें कि आप प्रोजेक्ट के रूट फ़ोल्डर में हों.

इसे अपने Cloud Shell टर्मिनल में चलाएं:

gcloud run deploy supply-chain-agent --source . --platform managed   --region us-central1 --allow-unauthenticated --set-env-vars GOOGLE_CLOUD_PROJECT=<<YOUR_PROJECT>>,GOOGLE_CLOUD_LOCATION=us-central1,GOOGLE_GENAI_USE_VERTEXAI=TRUE,REASONING_ENGINE_APP_NAME=<<YOUR_APP_ENGINE_URL>>,TOOLBOX_SERVER=<<YOUR_TOOLBOX_SERVER>>,TOOLBOX_TOOLSET=supply_chain_toolset,AGENT_ENGINE_ID=<<YOUR_AGENT_ENGINE_ID>>

प्लेसहोल्डर <<YOUR_PROJECT>>, <<YOUR_APP_ENGINE_URL>>, <<YOUR_TOOLBOX_SERVER>> और <<YOUR_AGENT_ENGINE_ID>> की वैल्यू बदलें

कमांड पूरी होने के बाद, यह सेवा का यूआरएल जनरेट करेगा. इसे कॉपी करें.

  1. Cloud Run सेवा खाते को AlloyDB क्लाइंट की भूमिका असाइन करें.इससे आपका सर्वरलेस ऐप्लिकेशन, डेटाबेस में सुरक्षित तरीके से टनल कर पाएगा.

इसे अपने Cloud Shell टर्मिनल में चलाएं:

# 1. Get your Project ID and Project Number
PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

# 2. Grant the AlloyDB Client role
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
--role="roles/alloydb.client"

अब सेवा के यूआरएल (Cloud Run एंडपॉइंट, जिसे आपने पहले कॉपी किया था) का इस्तेमाल करें और ऐप्लिकेशन को टेस्ट करें.

ध्यान दें: अगर आपको सेवा से जुड़ी कोई समस्या आती है और इसकी वजह मेमोरी बताई जाती है, तो जांच करने के लिए, मेमोरी की तय सीमा को बढ़ाकर 1 GiB करें.

3e4d36ed99b39325.png

d6b337f79a1f1d82.png

5e781a193a4aa903.png

10. व्यवस्थित करें

इस लैब को पूरा करने के बाद, alloyDB क्लस्टर और इंस्टेंस को मिटाना न भूलें.

इससे क्लस्टर और उसके इंस्टेंस मिट जाएंगे.

11. बधाई हो

हमने AlloyDB की स्पीड, MCP टूलबॉक्स की ऑर्केस्ट्रेशन क्षमता, और Vertex AI Memory Bank की "संस्थागत मेमोरी" को मिलाकर, सप्लाई चेन सिस्टम बनाया है. यह सिस्टम समय के साथ बेहतर होता जाता है. यह सिर्फ़ सवालों के जवाब नहीं देता. इसे यह भी याद रहता है कि सिंगापुर में मौजूद आपके वेयरहाउस में, मॉनसून की वजह से हमेशा शिपमेंट में देरी होती है. इसलिए, यह आपसे पूछे बिना ही शिपमेंट को किसी दूसरे रास्ते से भेजने का सुझाव देता है.