ADK की मदद से एजेंटिक वर्कफ़्लो

1. परिचय

VibeStudio

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

स्थिति

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

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

क्लिप बनाने से लेकर उसे पब्लिश करने तक का वर्कफ़्लो

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

10-खास जानकारी

  • ग्राफ़ इंजीनियरिंग के बुनियादी सिद्धांत: कई चरणों वाले एजेंट आर्किटेक्चर के लिए, कंट्रोल फ़्लो और स्ट्रक्चर्ड तरीके से काम करने के पाथ की ज़रूरत होती है. आपने ADK Workflow बनाया है. इसमें एज टपल, START एंट्री पॉइंट, पैरलल फ़ैन-आउट एग्रीगेशन के लिए JoinNode, और स्थिति के आधार पर एक्ज़ीक्यूशन को कंट्रोल करने के लिए डिटरमिनिस्टिक राउटर नोड का इस्तेमाल किया गया है.
  • Agent मोड और लाइफ़साइकल कॉलबैक: खास टास्क के लिए, अलग-अलग तरह के ऑपरेशनल बिहेवियर और डिटरमिनिस्टिक गार्डरेल की ज़रूरत होती है. ADK Agent इंस्टेंस को कॉन्फ़िगर करने के लिए, chat, single_turn, और टूल की सुविधा वाले task मोड का इस्तेमाल वर्कफ़्लो नोड के तौर पर किया जाता है. साथ ही, इंटरसेप्टर को before_model_callback और after_agent_callback के साथ लागू किया जाता है.
  • निगरानी में काम करने वाले एआई मॉडल की मदद से ऑर्केस्ट्रेशन: प्रोडक्शन पाइपलाइन, क्रिएटिव चेकपॉइंट पर इंसानी फ़ैसले के लिए रुक जाती हैं. वर्कफ़्लो के एक्ज़ीक्यूशन को निलंबित करने, स्ट्रक्चर्ड रिस्पॉन्स स्कीमा लागू करने, और बिना इस्तेमाल वाली रनटाइम प्रोसेस को चालू रखे बिना एक्ज़ीक्यूशन को फिर से शुरू करने के लिए, RequestInput को लागू किया जाता है.
  • क्रम के हिसाब से एजेंट की मेमोरी: प्रोडक्शन सिस्टम, कुछ समय के लिए एक्ज़ीक्यूट होने वाली स्थिति को लंबे समय तक चलने वाले कॉन्टेक्स्ट से अलग करते हैं. Event(state=...) और पैरामीटर बाइंडिंग का इस्तेमाल करके, शॉर्ट-टर्म सेशन स्टेट को मैनेज किया जाता है. साथ ही, GEAP मेमोरी बैंक को कनेक्ट किया जाता है, ताकि अलग-अलग रन के दौरान क्रिएटर की प्राथमिकताओं को निकाला, इकट्ठा, और सेव किया जा सके.
  • एंटरप्राइज़ के नॉलेज बेस के साथ ग्राउंडिंग: ऑटोनॉमस एजेंट को डाइनैमिक डोमेन कॉन्टेक्स्ट और ऑडियंस के सेंटिमेंट की ज़रूरत होती है. आपने GEAP RAG इंजन कॉर्पस को, पैरलल फ़ैन-आउट के अंदर एक खास रिट्रीवल नोड के तौर पर कनेक्ट किया है, ताकि एजेंट के आउटपुट को सिमैंटिक तौर पर सही बनाया जा सके.
  • लंबे समय तक चलने वाले वर्कफ़्लो और डिप्लॉयमेंट: मल्टीमोडल वीडियो रेंडरिंग, लंबे समय तक एसिंक्रोनस तरीके से काम करती है. कॉल आईडी के हिसाब से वर्कफ़्लो को निलंबित करने और फिर से शुरू करने के लिए, कॉल की रसीदें पेंडिंग होने पर LongRunningFunctionTool को लागू किया जाता है. साथ ही, Cloud Run पर ADK Runner का इस्तेमाल करके, पूरी हो चुकी पाइपलाइन को डिप्लॉय किया जाता है.

इस कोडलैब को कैसे व्यवस्थित किया गया है

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

प्रैक्टिकल काम VibeStudio Workbench में किया जाता है. यह एक कंपैनियन वेब इंटरफ़ेस है, जिसमें इंटरैक्टिव कोड एडिटर, रनटाइम वेरिफ़ायर, और एम्बेड किया गया एडीके इंस्पेक्टर शामिल है. वर्कबेंच में दिए गए चरणों की संख्या, इस कोडलैब में दिए गए चरणों की संख्या से मेल खाती है, ताकि आपकी प्रोग्रेस सिंक रहे. ग्राफ़ में किए गए बुनियादी बदलाव, सभी चरणों में बने रहते हैं. साथ ही, वर्कबेंच आपके आगे बढ़ने पर, ज़रूरी शर्तों की अपने-आप पुष्टि करता है.

वर्कबेंच की एक्सरसाइज़ पूरी करने के बाद, आपको एंड-टू-एंड एजेंटिक पाइपलाइन को असेंबल करना होगा. साथ ही, वीडियो वाला कॉन्टेंट जनरेट करने के लिए, Cloud Run पर VibeStudio ऐप्लिकेशन को डिप्लॉय करना होगा.

कौनसी चीज़ कहां चलती है: VibeStudio Workbench, आपका बैकएंड, और Google Cloud की सेवाएं

इस एनवायरमेंट में तीन मुख्य कॉम्पोनेंट शामिल हैं: VibeStudio Workbench (कोड में बदलाव करने और रनटाइम की पुष्टि करने के लिए लोकल वेब इंटरफ़ेस), आपका बैकएंड (agent/ में ADK Workflow और स्टेज सैंडबॉक्स), और Google Cloud (Gemini मॉडल, GEAP मेमोरी बैंक, आरएजी इंजन, और Veo वीडियो जनरेशन).

2. सेटअप

वर्कशॉप के क्रेडिट पर दावा करना

अगर आपको किसी प्रशिक्षक की निगरानी में लैब में हिस्सा लेना है, तो प्रशिक्षक आपके Google Cloud प्रोजेक्ट के लिए क्रेडिट देगा. क्रेडिट रिडीम करने के लिए, प्रशिक्षक के निर्देशों का पालन करें. साथ ही, यह पक्का करें कि जारी रखने से पहले, आपके खाते में बिलिंग चालू हो.

Cloud Shell खोलें

Cloud Shell, ब्राउज़र पर आधारित एक डेवलपमेंट एनवायरमेंट है. इसमें gcloud, Python, और git पहले से इंस्टॉल होते हैं.

Cloud Shell लॉन्च करने के लिए:

  1. Google Cloud Shell पर जाएं.

ब्राउज़र विंडो के सबसे नीचे, एक टर्मिनल सेशन खुलता है.

डेटाबेस को क्लोन करना और शुरू करना

प्रोजेक्ट को क्लोन करने के लिए, Cloud Shell टर्मिनल में ये कमांड चलाएं:

git clone https://github.com/gca-americas/vibetube-studio
cd ~/vibetube-studio

कॉन्फ़िगरेशन प्रॉम्प्ट

सेटअप के दौरान, आपसे यह जानकारी मांगी जाएगी:

  • Google Cloud प्रोजेक्ट आईडी: setup_project.sh से प्रॉम्प्ट मिलने पर, Enter दबाएं. इससे एक नया प्रोजेक्ट अपने-आप बन जाएगा. अगर आपको किसी मौजूदा प्रोजेक्ट (जैसे, पहले से असाइन किया गया प्रोजेक्ट) का इस्तेमाल करना है, तो अपना प्रोजेक्ट आईडी डालें. साथ ही, पक्का करें कि स्पेलिंग सही हो और बिलिंग चालू हो.
  • इवेंट कोड: अपने शिक्षक से मिला मीटिंग रूम का कोड डालें. अगर आपको यह नहीं मिला है, तो किसी टीचिंग असिस्टेंट या पड़ोसी से संपर्क करें. अगर यह लैब घर से पूरी की जा रही है, तो डिफ़ॉल्ट sandbox रूम को स्वीकार करने के लिए, Enter दबाएं.
  • चैनल का डिसप्ले नेम: setup_codelab.sh के कहे जाने पर, अपना नाम या चैनल का पसंदीदा हैंडल डालें. इसके अलावा, अपने Google खाते से जनरेट किए गए डिफ़ॉल्ट नाम को स्वीकार करने के लिए, Enter दबाएं.

सेटअप की दोनों स्क्रिप्ट को इस क्रम में चलाएं:

./setup_project.sh
./setup_codelab.sh
  • setup_project.sh: यह चालू बिलिंग वाले Google Cloud प्रोजेक्ट को बनाता है या उसका फिर से इस्तेमाल करता है. साथ ही, प्रोजेक्ट आईडी को ~/project_id.txt में सेव करता है और चालू gcloud कॉन्टेक्स्ट को कॉन्फ़िगर करता है.
  • setup_codelab.sh: .venv में uv और Python डिपेंडेंसी इंस्टॉल करता है. साथ ही, ज़रूरी Google Cloud API चालू करता है और .env में आपके चैनल की सेटिंग कॉन्फ़िगर करता है. इसके अलावा, Gemini के साथ मॉडल के ऐक्सेस की पुष्टि करता है, मेमोरी बैंक और आरएजी संसाधनों का प्रावधान करता है, वर्कबेंच इंटरफ़ेस बनाता है, और VibeStudio वर्कबेंच को शुरू करता है.

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

7 · Preflight
  ✓ python 3.12
  ✓ auth path A: Vertex via ADC (STUDIO_VERTEX=1)
  ✓ Google Cloud ADC (project <your-project>)
  ✓ stage0_prompt loads
  ...
  ✓ stage6_video loads (13 edges)
  ✓ aiplatform.googleapis.com enabled (Gemini, Veo, Memory Bank, RAG Engine)
  ✓ vectorsearch.googleapis.com enabled (the vector store a RAG corpus is built on)
  ✓ Memory Bank connected
  ✓ RAG corpus connected
  ✓ VibeStudio Workbench running on port 4600

PREFLIGHT GREEN

Setup finished. The VibeStudio Workbench is already running.

  Open this and start at step 1
      https://4600-<your cloud shell host>/step/story

  It runs in the background. You do not need to start anything else.
      log      runs/lab.log
      stop     kill $(cat runs/lab.pid)
      start    scripts/start.sh

उस लिंक पर क्लिक करें. यही पता Web Preview → Change port → 4600 में भी उपलब्ध है.

किसी भी समय एनवायरमेंट की फिर से जांच करने के लिए, python scripts/preflight.py चलाएं. वर्कबेंच को रीस्टार्ट करने के लिए, scripts/restart.sh चलाएं. फिर से सेट अप करने के लिए, ./setup_codelab.sh चलाएं. इससे आपका कॉन्फ़िगरेशन और प्रोग्रेस सेव रहती है.

इसे खोलें और स्थिति के बारे में जानने के लिए, पहला चरण, कहानी पढ़ें. साथ ही, फ़ाइनल ग्राफ़ के आकार के बारे में जानने के लिए, दूसरा चरण, आपने क्या बनाया पढ़ें. दोनों में से किसी में भी कसरत नहीं है. इसके बाद, तीसरे चरण के लिए यहां वापस आएं.

VibeStudio Workbench के हर हैंड-ऑन पार्ट के आखिर में, पुष्टि करने वाला एक पैनल होता है. यह पैनल, असल आर्टफ़ैक्ट को पढ़ता है: डिस्क पर मौजूद फ़ाइल और रन से लिखे गए सेशन.

डेटाबेस का लेआउट

रिपॉज़िटरी को मुख्य वर्कफ़्लो लॉजिक, चरण-दर-चरण सैंडबॉक्स, वर्कबेंच एनवायरमेंट, और प्रोडक्शन ऐप्लिकेशन में बांटा गया है:

vibe-studio-lab/
├── agent/                  # Core ADK workflow, graph definition, and platform services
│   ├── graph.py            # Workflow graph definition, node functions, and routers
│   ├── desk.py             # Video render desk using LongRunningFunctionTool
│   ├── schemas.py          # Pydantic schemas for directions, gates, and scripts
│   ├── trends.py           # Trend generation and sampling utilities
│   ├── backlog.txt         # Creator video ideas backlog
│   ├── comments.md         # Audience comments for RAG Engine corpus seeding
│   ├── policy_words.txt    # Blocked subject words for deterministic policy checks
│   └── platform/           # Google Cloud service clients (Memory Bank, RAG, Veo)
│       ├── config.py       # Environment variables, locations, and model configurations
│       ├── memory.py       # GEAP Memory Bank callbacks and context injection
│       ├── rag.py          # GEAP RAG Engine corpus creation and semantic retrieval
│       └── videogen.py     # Veo video generation and operation polling
├── stage0_prompt/          # Step sandboxes: isolated agent.py files runnable in adk web
│   └── ...                 # stage1_fanout through stage6_video for incremental steps
├── server/ & web/          # VibeStudio Workbench (FastAPI backend and React frontend)
├── vibestudio/             # Complete production application deployed to Cloud Run
│   ├── server/             # FastAPI production server and event runner
│   ├── web/                # End-user React web application
  • agent/: इसमें मुख्य वर्कफ़्लो ग्राफ़ होता है. आपको इस डायरेक्ट्री में मौजूद फ़ाइलों में बदलाव करना होगा. ऐसा इसलिए, ताकि पैरलल फ़ैन-आउट नोड, डिटरमिनिस्टिक नीति राउटिंग, मेमोरी कॉलबैक, और वीडियो जनरेशन टूल लागू किए जा सकें.
  • agent/platform/: यह Google Cloud की सेवाओं के साथ इंटरफ़ेस करता है. इनमें Gemini मॉडल, GEAP मेमोरी बैंक, GEAP RAG इंजन, और Veo वीडियो सिंथेसिस शामिल हैं.
  • stage0_prompt/ से stage6_video/: सैंडबॉक्स एनवायरमेंट, जो अपने-आप काम करते हैं. हर फ़ोल्डर, एक अलग root_agent एक्सपोर्ट करता है. इससे, एम्बेड किए गए ADK डेवलपमेंट इंटरफ़ेस के ज़रिए, हर चरण को अलग से चलाया और जांचा जा सकता है.
  • server/ और web/: पोर्ट 4600 पर स्थानीय तौर पर चल रहा VibeStudio Workbench ऐप्लिकेशन. इसमें हर चरण का दस्तावेज़, इन-पेज कोड एडिटर, रनटाइम के सबूत की पुष्टि करने वाले टूल, और ग्राफ़ विज़ुअलाइज़ेशन की सुविधा होती है.
  • vibestudio/: आखिरी चरण में, प्रोडक्शन ऐप्लिकेशन को पैकेज करके Cloud Run पर डिप्लॉय किया जाता है. इसमें पूरे हो चुके वर्कफ़्लो ग्राफ़ की अलग से मौजूद कॉपी होती है.

3. मोनोलिथिक एजेंट

एक से ज़्यादा नोड वाले वर्कफ़्लो ग्राफ़ को बनाने से पहले, stage0_prompt/agent.py में एक एजेंट के साथ आर्किटेक्चरल बेसलाइन सेट अप करें. यह एजेंट, एक ही सिस्टम प्रॉम्प्ट पर निर्भर करता है. इसमें प्रोडक्शन पाइपलाइन के बारे में जानकारी दी जाती है. साथ ही, इसमें Python फ़ंक्शन के दो टूल भी काम करते हैं.

इस बेसलाइन का आकलन करने से, प्रॉम्प्ट के आधार पर काम करने वाले सिस्टम की सीमाओं का पता चलता है. साथ ही, यह भी पता चलता है कि प्रोडक्शन सिस्टम के लिए ग्राफ़ ऑर्केस्ट्रेशन की ज़रूरत क्यों होती है.

ADK एजेंट का आर्किटेक्चर (3A)

VibeStudio Workbench में, तीसरा चरण · मोनोलिथिक एजेंट पर जाएं और ADK एजेंट आर्किटेक्चर (3A) खोलें. इस व्यू में, ADK एजेंट (LlmAgent) की मुख्य आर्किटेक्चरल लेयर दिखती हैं:

03-3A

from google.adk.agents import LlmAgent
from google.adk.tools import mcp_toolset

root_agent = LlmAgent(
    model="gemini-3.5-flash",                 # model
    instruction=BRAND_INSTRUCTION,            # instruction
    skills=[load_skill("brand-audit")],       # skills
    tools=[mcp_toolset("mcp_brand_style")],   # tools
    output_schema=BrandStyleReport,           # structured output
    before_agent_callback=setup_ctx,          # interceptor
    before_model_callback=require_image,      # interceptor
    after_model_callback=schema_guard,        # interceptor
)

इंटरैक्टिव डायग्राम, एजेंट के कॉम्पोनेंट को पांच ऑपरेशनल डोमेन में बांटता है:

  • रीज़निंग लेयर (मॉडल): Gemini 3 Flash जैसा कोर लैंग्वेज मॉडल, जो सीखने-सिखाने से जुड़ी ऐक्टिविटी, प्रॉम्प्ट रीज़निंग, और टूल चुनने जैसे काम करता है. आर्किटेक्चर में मौजूद अन्य सभी चीज़ें, इस मॉडल को जानकारी देती हैं या इसे सीमित करती हैं.
  • कॉन्टेक्स्ट लेयर (निर्देश और स्किल): ऐसे निर्देश जो मॉडल की रीज़निंग को बेहतर बनाते हैं. instruction, सिस्टम प्रॉम्प्ट, पर्सोना, और काम करने के नियमों को स्थायी तौर पर सेट करता है. skills, बार-बार इस्तेमाल किए जाने वाले वर्कफ़्लो के लिए, वर्शन के हिसाब से सिलसिलेवार निर्देश (SKILL.md) उपलब्ध कराता है.
  • मिलकर काम करने और कार्रवाई करने की लेयर (टूल, सब-एजेंट, वर्कफ़्लो, आउटपुट स्कीमा): ऐसे इंटरफ़ेस जो एजेंट को बाहरी सिस्टम पर कार्रवाई करने और टाइप किया गया डेटा भेजने की सुविधा देते हैं. tools कॉल किए जा सकने वाले Python फ़ंक्शन या मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) एंडपॉइंट उपलब्ध कराएं. subagents सौंपे गए टास्क पूरे कर सकता है. workflow मल्टी-एजेंट ग्राफ़ को व्यवस्थित करता है. output_schema, Pydantic मॉडल लागू करता है. इससे यह पक्का किया जाता है कि डाउनस्ट्रीम उपभोक्ताओं को बिना किसी स्ट्रक्चर वाला टेक्स्ट नहीं, बल्कि पुष्टि किया गया JSON मिले.
  • इंटरसेप्टर लेयर (लाइफ़साइकल कॉलबैक): डिटरमिनिस्टिक गार्डरेल, एजेंट के एक्ज़ीक्यूशन (before_agent/after_agent), अलग-अलग मॉडल टर्न (before_model/after_model), और टूल कॉल (before_tool/after_tool) से पहले और बाद में कस्टम कोड को एक्ज़ीक्यूट करती हैं. इंटरसेप्टर, मॉडल के अनुपालन पर भरोसा किए बिना नीति के नियमों को लागू करते हैं.
  • बाहरी स्थिति (सेशन और मेमोरी): एजेंट के लॉजिक से अलग की गई स्टेटफ़ुल परसिस्टेंस. Session, मौजूदा एक्ज़ीक्यूशन थ्रेड के लिए, कुछ समय के लिए काम करने वाली मेमोरी और इवेंट ट्रेस को सेव रखता है. Memory, GEAP मेमोरी बैंक जैसी मैनेज की जा रही सेवाओं का इस्तेमाल करके, अलग-अलग सेशन के तथ्यों और प्राथमिकताओं को लंबे समय तक सेव रखता है.

इस चरण में, मोनोलिथिक एजेंट सिर्फ़ तीन प्रिमिटिव लागू करता है: model, instruction, और tools. इसके बाद के चरणों में, ग्राफ़ वर्कफ़्लो, स्ट्रक्चर्ड स्कीमा, इंटरसेप्टर, और परसिस्टेंट मेमोरी सेवाओं के बारे में बताया गया है.

मोनोलिथिक एजेंट स्पेसिफ़िकेशन (3B)

वर्कबेंच में, मोनोलिथिक एजेंट स्पेसिफ़िकेशन (3B) पर जाएं. बेसलाइन एजेंट की परिभाषा देखने के लिए, stage0_prompt/agent.py खोलें:

  • एक प्रॉम्प्ट में निर्देश: सिस्टम प्रॉम्प्ट, वीडियो बनाने से जुड़े पांच अलग-अलग टास्क को एक ही पैराग्राफ़ में शामिल करता है: प्लैटफ़ॉर्म के ट्रेंड का पता लगाना, बैकलाॅग आइडिया की समीक्षा करना, क्रिएटिव कॉन्सेप्ट का सुझाव देना, प्रतिबंधित विषयों से जुड़ी नीतियों को लागू करना, और शॉट की सूचियों का ड्राफ़्ट तैयार करना.
  • अंडरलाइंग डेटा सोर्स: एजेंट, ग्राफ़ के बगल में बताए गए दो सोर्स का रेफ़रंस देता है:
    • agent/trends.py: यह 250 फ़ॉर्मैट और स्टाइल के पूल में से, 10 सबसे लोकप्रिय फ़ॉर्मैट और स्टाइल के सैंपल दिखाता है. साथ ही, डाइनैमिक हीट स्कोर भी दिखाता है.
    • agent/backlog.txt: क्रिएटर के कॉन्सेप्ट नोट को लाइन-दर-लाइन पढ़ता है.

एजेंट (3C) में मौजूद टूल

वर्कबेंच में, एजेंट में टूल (3C) पर जाएं.

एजेंट के लिए टूल क्या होता है?

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

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

03-3C

टूल कॉलिंग, मॉडल और एडीके रनटाइम के बीच पांच चरणों वाले प्रोटोकॉल का पालन करती है:

  1. स्कीमा डिक्लेरेशन: डेवलपर, एजेंट को Python फ़ंक्शन उपलब्ध कराता है. एडीके, हर फ़ंक्शन के नाम, टाइप एनोटेशन, और डॉकस्ट्रिंग की जांच करता है. इससे OpenAPI के साथ काम करने वाला JSON स्कीमा डिक्लेरेशन जनरेट होता है. इसमें फ़ंक्शन के पैरामीटर और मकसद के बारे में बताया जाता है.
  2. मॉडल रीज़निंग: अनुमान लगाने के दौरान, मॉडल यह आकलन करता है कि उपयोगकर्ता के प्रॉम्प्ट के लिए बाहरी डेटा की ज़रूरत है या नहीं. ज़रूरत पड़ने पर, मॉडल एक स्ट्रक्चर्ड function_call इवेंट जनरेट करता है. इसमें टारगेट फ़ंक्शन का नाम और स्कीमा से मैच करने वाली आर्ग्युमेंट डिक्शनरी शामिल होती है.
  3. रनटाइम एक्ज़ीक्यूशन: मॉडल खुद कोड को एक्ज़ीक्यूट नहीं करता. ADK रनटाइम, function_call को इंटरसेप्ट करता है. साथ ही, दिए गए तर्कों का इस्तेमाल करके, असल लोकल Python फ़ंक्शन को लागू करता है और रिटर्न वैल्यू को कैप्चर करता है.
  4. कॉन्टेक्स्ट को फिर से इंजेक्ट करना: ADK रनटाइम, फ़ंक्शन की रिटर्न वैल्यू को function_response इवेंट में पैकेज करता है. साथ ही, इसे चालू सेशन के इतिहास में जोड़ता है.
  5. फ़ाइनल सिंथेसिस: मॉडल, टूल के आउटपुट को प्रोसेस करता है. यह आउटपुट अब उसकी कॉन्टेक्स्ट विंडो में मौजूद होता है. इसके बाद, मॉडल अपना जवाब पूरा करता है.

stage0_prompt/agent.py में, दोनों रिसर्च टूल को स्टैंडर्ड Python फ़ंक्शन के तौर पर तय किया गया है:

def check_trends() -> dict:
    """Ten formats trending on the platform right now, with a heat score each."""
    from agent.trends import sample_trends
    return {"trends": sample_trends()}


def read_backlog() -> dict:
    """The creator's backlog: ideas they noted down to make someday."""
    from agent.graph import backlog_notes
    return {"backlog": backlog_notes()}

खुद से बदलाव करना और लागू करना

वर्कबेंच के कोड एडिटर में, एजेंट की tools सूची में फ़ंक्शन के दो रेफ़रंस जोड़ें:

    tools=[check_trends, read_backlog],

बदलाव को सेव करें. फ़ाइल, डिस्क पर अपडेट हो जाती है. साथ ही, पुष्टि करने वाली लाइन से यह पक्का होता है कि दोनों टूल कनेक्ट हैं.

एंबेड किए गए ADK डेवलपमेंट इंटरफ़ेस को लॉन्च करने के लिए, Open adk web पर क्लिक करें. सुझाया गया आइडिया प्रॉम्प्ट भेजने के लिए:

tonight's idea: a tiny robot doing laundry at midnight

इसके बाद क्या होगा और क्यों

यह प्रॉम्प्ट भेजने पर, सेशन ट्रेस में इस क्रम में कार्रवाई होती है:

  • जवाब से पहले, टूल के इस्तेमाल से जुड़े दो इवेंट दिखते हैं: आपको check_trends और read_backlog के लिए, function_call और function_response इवेंट दिखते हैं.
    • वजह: Gemini ने सिस्टम प्रॉम्प्ट के निर्देश ("देखें कि क्या ट्रेंड कर रहा है. अपने आइडिया का बैकलाॅग देखें") का आकलन किया. उसे पता चला कि उसके पास प्लैटफ़ॉर्म के रुझानों और चैनल के नोट की जानकारी नहीं है. इसलिए, उसने दोनों फ़ंक्शन को कॉल किया, ताकि वह सही संदर्भ में जवाब दे सके.
  • एजेंट, वीडियो के लिए एक आइडिया देता है और आपकी पुष्टि का इंतज़ार करता है: एजेंट, ट्रेंड और बैकलॉग को ध्यान में रखते हुए वीडियो के लिए एक आइडिया देता है और आपसे पुष्टि करने के लिए कहता है.
    • वजह: निर्देश में मॉडल को स्क्रिप्ट जनरेट करने से पहले, क्रिएटर के साथ स्क्रिप्ट की दिशा पर सहमत होने के लिए कहा गया था.
  • फ़ॉलो-अप टर्न में पुष्टि को बायपास करना: दूसरा मैसेज भेजें: skip the questions, just describe the video. एजेंट, पुष्टि करने की प्रोसेस को तुरंत बायपास कर देता है. इसके बाद, टाइटल और शॉट का ड्राफ़्ट तैयार करता है.
    • ऐसा क्यों होता है: प्रॉम्प्ट में दिए गए निर्देश, डिटरमिनिस्टिक एल्गोरिदम की तरह काम करने वाली पाबंदियां नहीं, बल्कि सलाह देने वाले दिशा-निर्देश होते हैं. मोनोलिथिक एजेंट में, उपयोगकर्ता के निर्देश, सिस्टम प्रॉम्प्ट के मौजूदा नियमों को बदल सकते हैं. ऐसा इसलिए होता है, क्योंकि कोई बाहरी वर्कफ़्लो, एक्ज़ीक्यूशन फ़्लो को कंट्रोल नहीं करता.

मोनोलिथिक प्रॉम्प्ट के आर्किटेक्चर की सीमाएं

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

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

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

4. एजेंटिक वर्कफ़्लो के बुनियादी सिद्धांत

VibeStudio Workbench में, चौथा चरण · एजेंटिक वर्कफ़्लो की बुनियादी बातें पर जाएं. इसके बाद, 4A से 4D तक के हिस्सों पर जाएं.

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

ग्राफ़ आर्किटेक्चर और एक्ज़ीक्यूशन चेन (4A)

वर्कबेंच में, ग्राफ़ आर्किटेक्चर और एक्ज़ीक्यूशन चेन (4A) खोलें.

ADK Workflow, एजेंट के एक्ज़ीक्यूशन को एक डायरेक्टेड ग्राफ़ के तौर पर स्ट्रक्चर करता है. इसे एज लिस्ट से तय किया जाता है:

  • चेन: सीक्वेंशियल टपल, लीनियर नोड के एक्ज़ीक्यूशन ((node_a, node_b, node_c)) को तय करते हैं.
  • पैरलल ब्रांच: एक ही ओरिजिन नोड से जुड़ी इंडिपेंडेंट चेन, एक साथ चलती हैं.
  • सिंक्रनाइज़ेशन: JoinNode पर मिलने वाली चेन, रिलीज़ करने से पहले सभी इनकमिंग ब्रांच की रिपोर्ट आने तक इंतज़ार करती हैं.
  • डिटरमिनिस्टिक कंट्रोल: एक्ज़ीक्यूशन फ़्लो, प्रॉम्प्ट टेक्स्ट से अनुमान लगाने के बजाय, कोड स्ट्रक्चर के हिसाब से तय होता है.

04-4A

ADK में नोड आर्किटाइप

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

नोड आर्किटाइप

लागू करना

पाइपलाइन में भूमिका

फ़ंक्शन नोड

Event दिखाने वाला Python फ़ंक्शन

यह लॉजिक, डेटा वापस पाने, और स्टेट म्यूटेशन को लागू करता है.

नोड को जोड़ना

पहले से मौजूद JoinNode इंस्टेंस

यह एक साथ चलने वाली ब्रांच को एक एग्रीगेट डिक्शनरी में सिंक करता है.

एजेंट नोड

Agent, single_turn मोड में चल रहा है

यह अपस्ट्रीम इनपुट के आधार पर निर्देशों का आकलन करता है और पुष्टि किया गया डेटा दिखाता है.

राऊटर नोड

route टैग के साथ Event दिखाने वाला फ़ंक्शन

यह डाउनस्ट्रीम एक्ज़ीक्यूशन ब्रांच चुनने के लिए, कंडिशनल लॉजिक का आकलन करता है.

लोगों से मिले इनपुट का नोड

फ़ंक्शन से नतीजे मिल रहे हैं RequestInput

यह फ़ंक्शन, बाहरी उपयोगकर्ता के जवाब मिलने तक एक्ज़ीक्यूशन की स्थिति को निलंबित कर देता है.

root_agent = Workflow(
    name="stage1_fanout",
    description="2 real readers -> join -> one research dict",
    edges=[...])

इस कॉन्फ़िगरेशन में, root_agent अलग से मौजूद Agent के बजाय Workflow का इंस्टेंस है. एडीके, वर्कफ़्लो को फ़र्स्ट-क्लास एजेंट के तौर पर इस्तेमाल करता है. इससे पूरे ग्राफ़ को एक ऐप्लिकेशन के तौर पर लोड, इस्तेमाल, और जांचा जा सकता है. name, ऐप्लिकेशन को ADK Web में रजिस्टर करता है. वहीं, edges सूची से, ऐप्लिकेशन को लागू करने के तरीके के बारे में पता चलता है.

पैरलल रिसर्च फ़ैन-आउट (4B)

वर्कबेंच में, Parallel research fan-out (4B) पर जाएं. stage1_fanout/agent.py खोलें.

04-4B

फ़ंक्शन नोड और सिंक्रनाइज़ेशन बैरियर

रिसर्च फ़ेज़ में, agent/graph.py से इंपोर्ट किए गए दो फ़ंक्शन नोड का इस्तेमाल किया जाता है:

  • scan_trends: यह Event(output={"trends": [...]}) दिखाता है. इसमें प्लैटफ़ॉर्म के 10 ट्रेंड शामिल होते हैं.
  • read_backlog: Event(output={"backlog": [...], "idea": "..."}) दिखाता है. इसमें चैनल के बैकलॉग के लिए 15 आइडिया और शुरुआती रन प्रॉम्प्ट शामिल होता है.

हर फ़ंक्शन, node_input (पिछले नोड का आउटपुट) को स्वीकार करता है और Event दिखाता है.

JoinNode, सिंक्रनाइज़ेशन बैरियर के तौर पर काम करता है: यह तब तक रुका रहता है, जब तक हर इनबाउंड चेन कोई इवेंट डिलीवर नहीं करती. इसके बाद, यह सभी ब्रांच के नतीजों को नोड के नाम ({"scan_trends": {...}, "read_backlog": {...}}) के हिसाब से डिक्शनरी में इकट्ठा करता है.

हाथों से बदलाव करना: जॉइन और पैरलल एज को तय करना

stage1_fanout/agent.py में, JoinNode को इंस्टैंशिएट करें और START से शुरू होने वाली दो पैरलल चेन को वायर करें:

join_research = JoinNode(name="join_research")
    edges=[(START, scan_trends, join_research),
           (START, read_backlog, join_research)])

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

इसके बाद क्या होगा और क्यों

  • एक साथ कई रीडर का इस्तेमाल: एक्ज़ीक्यूशन ग्राफ़ में, scan_trends और read_backlog एक साथ एक्ज़ीक्यूट होते हैं.
    • क्यों: दोनों चेन START से शुरू होती हैं. ADK इंजन, एक साथ कई ब्रांच शेड्यूल करता है.
  • एग्रीगेट की गई डिक्शनरी का आउटपुट: वर्कफ़्लो join_research पर पूरा होता है. इससे एक डिक्शनरी बनती है, जिसमें दोनों रीडर की एंट्री होती हैं.
    • क्यों: JoinNode यह पक्का करता है कि बाद के नोड को एक्ज़ीक्यूट करने की अनुमति देने से पहले, पूरा डेटा कैप्चर कर लिया गया हो.

एजेंट नोड (4C)

वर्कबेंच में, एजेंट नोड (4C) पर जाएं. stage2_direction/agent.py खोलें.

04-4C

ऑपरेटिंग मोड और स्ट्रक्चर्ड स्कीमा

Workflow में एम्बेड किए जाने पर, Agent डिफ़ॉल्ट रूप से single_turn मोड में चलता है:

  • यह पिछले नोड के आउटपुट को अपने कॉन्टेक्स्ट इनपुट के तौर पर लेता है.
  • यह बातचीत के बिना, सिर्फ़ एक बार अनुमान लगाने के लिए कॉल करता है.
  • यह अगले नोड को स्ट्रक्चर्ड डेटा आउटपुट करता है.

output_schema=Directions को असाइन करके, एजेंट मॉडल आउटपुट पर Pydantic वैलिडेशन लागू करता है. डाउनस्ट्रीम ग्राफ़ को, बिना किसी स्ट्रक्चर वाले गद्य के बजाय टाइप किए गए ऑब्जेक्ट मिलते हैं:

class Direction(BaseModel):
    title: str           # <=60 chars, filmable, characterful
    angle: str           # the twist, one line
    hook: str = ""       # 2-4 words, the video's sticker line
    evidence: list[Evidence]


class Directions(BaseModel):
    candidates: list[Direction]   # exactly 4

PROPOSE_INSTRUCTION मॉडल को चार विकल्प सुझाने का निर्देश देता है. इसके लिए, वह रुझानों और बैकलॉग, दोनों से सबूत देता है. पहले से तीसरे नंबर के उम्मीदवारों ने चैनल के लिए सही कॉन्सेप्ट दिए हैं. चौथे कैंडिडेट ने जान-बूझकर नीति का उल्लंघन करने वाला कॉन्सेप्ट पेश किया है, ताकि अगले चरण में सुरक्षा गेट की जांच की जा सके.

हैंड्स-ऑन एडिट: एजेंट नोड को तय करना और जॉइन को चेन करना

stage2_direction/agent.py में, propose_directions को कॉन्फ़िगर करें और वर्कफ़्लो के किनारों को बढ़ाएं:

propose_directions = Agent(
    name="propose_directions",
    model=config.MODEL,
    instruction=PROPOSE_INSTRUCTION,
    output_schema=Directions)
    edges=[(START, scan_trends, join_research),
           (START, read_backlog, join_research),
           (join_research, propose_directions, direction_gate)])

इसके बाद क्या होगा और क्यों

  • डिक्शनरी का सीधे तौर पर इस्तेमाल करना: propose_directions, join_research से मिले JSON पेलोड का इस्तेमाल करता है. इसके लिए, मैन्युअल फ़ॉर्मैटिंग की ज़रूरत नहीं होती.
  • टाइप किया गया कैंडिडेट आउटपुट: एजेंट, पुष्टि किया गया Directions ऑब्जेक्ट दिखाता है. इसमें चार अलग-अलग कैंडिडेट होते हैं. डाउनस्ट्रीम नोड, स्ट्रिंग को पार्स किए बिना एट्रिब्यूट के नाम (candidate.title) के हिसाब से फ़ील्ड पढ़ते हैं.

निगरानी में काम करने वाला एआई मॉडल (4D)

वर्कबेंच में, निगरानी में काम करने वाला एआई मॉडल (4D) पर जाएं. agent/graph.py खोलें.

04-4D

प्रॉम्प्ट के निर्देश बनाम डिटरमिनिस्टिक सस्पेंशन

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

  • RequestInput को यील्ड करने से, वर्कफ़्लो का एक्ज़ीक्यूशन तुरंत निलंबित हो जाता है.
  • ADK, सेशन स्टोर में ओपन इंटरप्ट कॉल रिकॉर्ड करता है और एक यूनीक interrupt_id जारी करता है.
  • टोकन या सर्वर थ्रेड का इस्तेमाल किए बिना, प्रोसेस रुक जाती है.
  • ग्राफ़ का एक्ज़ीक्यूशन सिर्फ़ तब फिर से शुरू होता है, जब स्कीमा और इंटरप्ट आईडी से मैच करने वाला मान्य function_response सबमिट किया जाता है.

हैंड्स-ऑन एडिट: RequestInput की मदद से, कोड के एक्ज़ीक्यूशन को रोकना

agent/graph.py में, direction_gate के अंदर सस्पेंशन कॉल लागू करें:

    yield RequestInput(
        message="Pick tonight's direction: 1, 2, 3 or 4.",
        response_schema={
            "type": "object",
            "properties": {
                "pick": {"type": "string", "enum": ["1", "2", "3", "4"]}}},
        payload={"candidates": cands})

RequestInput तीन एट्रिब्यूट कॉन्फ़िगर करता है:

  • message: उपयोगकर्ता को दिखाया गया समीक्षा का प्रॉम्प्ट.
  • response_schema: एक JSON स्कीमा, जिसे फ़्रंटएंड, इनपुट फ़ॉर्म के तौर पर रेंडर करता है. सबमिट करने पर, ADK इसकी पुष्टि करता है.
  • payload: अनुरोध के साथ बंडल किया गया मेटाडेटा (चार कैंडिडेट). इससे क्लाइंट इंटरफ़ेस, सेशन की स्थिति के बारे में क्वेरी किए बिना समीक्षा कार्ड रेंडर कर सकते हैं.

इसके बाद क्या होगा और क्यों

  • direction_gate पर वर्कफ़्लो रुक जाता है: ADK Web या वर्कबेंच इंटरफ़ेस में, रन रुक जाता है और इंटरैक्टिव कैंडिडेट चुनने का फ़ॉर्म दिखता है.
    • वजह: इंजन को RequestInput मिला और उसने एक्ज़ीक्यूशन की स्थिति को runs/sessions.db पर बनाए रखा.
  • चैट को फिर से शुरू करने के लिए, स्ट्रक्चर्ड इनपुट की ज़रूरत होती है: चैट में कोई भी टेक्स्ट भेजने से, ग्राफ़ आगे नहीं बढ़ता. किसी विकल्प (1, 2, 3 या 4) को चुनने पर, टाइप किया गया function_response सबमिट हो जाता है. इससे response_schema की शर्त पूरी हो जाती है और प्रोग्राम फिर से शुरू हो जाता है.

5. स्टेट और राऊटर

VibeStudio Workbench में, Step 5 · State and Router पर जाएं. इसके बाद, (5A) से लेकर (5C) तक के हिस्से पर जाएं.

आपको उपयोगकर्ता के चुने गए विकल्पों को सेशन की स्थिति में बनाए रखना होगा. साथ ही, डिटरमिनिस्टिक राऊटर नोड का इस्तेमाल करके, चैनल की सुरक्षा से जुड़ी नीतियों को लागू करना होगा. इसके अलावा, वीडियो स्क्रिप्ट जनरेट करने से पहले, नीति के उल्लंघनों को अपने-आप ठीक करने के लिए, बार-बार टास्क करने वाले एजेंट को असेंबल करना होगा.

वर्कफ़्लो की स्थिति (5A)

वर्कबेंच में, Workflow State (5A) पर जाएं.

05-5A

सेशन की स्थिति बनाम नोड आउटपुट

एडीके वर्कफ़्लो में, डेटा दो अलग-अलग तरीकों से ग्राफ़ में मूव करता है:

  • नोड आउटपुट (Event(output=...)): डेटा को सिर्फ़ उन उपभोक्ताओं को भेजा जाता है जिन्हें एज लिस्ट में शामिल किया गया है.
  • सेशन की स्थिति (Event(state=...)): यह शेयर की गई ऐसी डिक्शनरी होती है जिसमें कुंजी और वैल्यू होती है. इसे एक्ज़ीक्यूशन लाइफ़साइकल में मौजूद कोई भी नोड ऐक्सेस कर सकता है.

05-5A

जब कोई उपयोगकर्ता direction_gate पर किसी कैंडिडेट को चुनता है, तो चुना गया विकल्प न्यूमेरिक इंडेक्स ({"pick": "2"}) के तौर पर दिखता है. डाउनस्ट्रीम नोड को पूरे डायरेक्शन ऑब्जेक्ट की ज़रूरत होती है: टाइटल, नैरेटिव ऐंगल, और हुक लाइन. हर इंटरमीडिएट नोड पेलोड के ज़रिए ज़्यादा शब्दों में मेटाडेटा पास करने के बजाय, persist_direction चुने गए कैंडिडेट को शेयर किए गए सेशन की स्थिति में सेव करता है.

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

    yield Event(state={"direction": chosen["title"], "angle": chosen.get("angle", ""),
                       "hook": hook, "user:prefs": {"last_direction": chosen["title"]}})

इससे Event, Workflow रनटाइम को कंट्रोल करने की अनुमति देता है. यह नई वैल्यू को runs/sessions.db में सेशन जर्नल में सेव करता है.

पैरामीटर बाइंडिंग

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

def persist_direction(node_input, candidates: list = []):
    ni = node_input if isinstance(node_input, dict) else {}
    raw = ni.get("pick")
    pick = str(raw).strip() if raw is not None else ""
    if candidates:
        i = int(pick) - 1 if pick.isdigit() else 0
        chosen = candidates[max(0, min(len(candidates) - 1, i))]
    else:
        chosen = {"title": "untitled", "angle": "", "evidence": []}
    hook = chosen.get("hook") or " ".join(chosen["title"].split()[:4])

यहां, direction_gate ने सेशन की स्थिति में candidates को लिखा. एडीके, इसे सीधे persist_direction(node_input, candidates: list = []) से जोड़ता है. इसके लिए, डिक्शनरी में अलग से खोजने की ज़रूरत नहीं पड़ती.

user: से प्रीफ़िक्स की गई कुंजियां, उपयोगकर्ता के लेवल पर स्टोरेज में सभी सेशन में बनी रहती हैं. इससे बाद के वर्कफ़्लो रन, क्रिएटर की प्राथमिकताओं को ऐक्सेस कर पाते हैं.

खुद करके देखें: स्थिति को बनाए रखना और नोड को वायर करना

  1. agent/graph.py में, persist_direction के अंदर, TODO: PERSIST_STATE लाइन को स्टेट इवेंट यील्ड से बदलें:
    yield Event(state={"direction": chosen["title"], "angle": chosen.get("angle", ""),
                       "hook": hook, "user:prefs": {"last_direction": chosen["title"]}})
  1. stage3_router/agent.py में, edges सूची में मौजूद तीसरी चेन में persist_direction जोड़ें:
           (join_research, propose_directions, direction_gate,
            persist_direction)

अपनी फ़ाइलें सेव करें. वर्कबेंच में, पुष्टि करें कि state write in place और persist_direction in the chain, दोनों के लिए हरे रंग के सही के निशान दिख रहे हों.

राऊटर नोड (5B)

वर्कबेंच में, राऊटर नोड (5B) पर जाएं.

05-5B

डिटरमिनिस्टिक पॉलिसी रूटिंग

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

राऊटर, route टैग के बारे में जानकारी देने वाला Event दिखाता है:

def length_check(node_input):
    too_long = len(node_input.get("title", "")) > 60
    return Event(output=node_input, route="TRIM" if too_long else "PASS")

वर्कफ़्लो की परिभाषा में, डिक्शनरी के तौर पर तय किया गया एज टारगेट, रूट के नामों को डेस्टिनेशन नोड पर मैप करता है:

    (length_check, {"TRIM": shorten, "PASS": scripter}),

वर्कफ़्लो राऊटर policy_check, agent/policy_words.txt से प्रतिबंधित वाक्यांशों को पढ़ता है. साथ ही, चुने गए डायरेक्शन के टाइटल और ऐंगल के हिसाब से, पूरे शब्द का मिलान करता है:

    return Event(output=node_input, route="BLOCK" if bad else "OK")

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

डेस्टिनेशन: स्क्रिप्ट लिखने वाला और क्वारंटाइन

राउटर, ट्रैफ़िक को दो डाउनस्ट्रीम नोड में से किसी एक पर भेजता है:

  • scripter: यह एक single_turn एजेंट नोड है, जो मंज़ूर किए गए डायरेक्शन को स्ट्रक्चर्ड प्रोडक्शन स्क्रिप्ट में बदलता है. यह स्क्रिप्ट, Script Pydantic स्कीमा के मुताबिक होती है:
scripter = Agent(
    name="scripter",
    model=config.MODEL,
    instruction=SCRIPT_INSTRUCTION,
    output_schema=Script)
  • quarantine: शुरुआत में, यह एक प्लेसहोल्डर फ़ंक्शन होता है, जो फ़्लैग किए गए निर्देशों को रोकता है. अगले हिस्से में, इसे अपने-आप समस्या हल करने वाले एजेंट से बदल दिया जाता है.

नीति की जांच को रूट करने के बारे में जानकारी

  1. agent/graph.py में, policy_check के अंदर, रिटर्न स्टेटमेंट को पूरा करें:
    return Event(output=node_input, route="BLOCK" if bad else "OK")
  1. stage3_router/agent.py में, edges को policy_check पर रूट करने के लिए अपडेट करें. साथ ही, क्वॉरंटीन की गई ब्रांच को scripter में फिर से शामिल करें:
           (join_research, propose_directions, direction_gate,
            persist_direction, policy_check),
           (policy_check, {"OK": scripter, "BLOCK": quarantine}),
           (quarantine, scripter)])

अपनी फ़ाइलें सेव करें. वर्कबेंच में, पुष्टि करें कि राऊटर एज मैपिंग की पुष्टि हो गई है.

एजेंट मोड और टास्क नोड (5C)

वर्कबेंच में, Agent मोड और टास्क नोड (5C) पर जाएं.

05-5C

एजेंट के लिए टास्क पूरा करने के मोड

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

मोड

प्लान लागू करने का लाइफ़साइकल

पाइपलाइन में भूमिका

chat

सिलसिलेवार बातचीत का लूप. मॉडल यह तय करता है कि टूल को कब शुरू करना है, इनपुट कब मांगना है या टर्न कब खत्म करना है.

रूट एजेंट, जो किसी इंसान से इंटरैक्ट कर रहे हैं.

single_turn

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

क्रम में चलने वाले ग्राफ़ ट्रांसफ़ॉर्मेशन (propose_directions, scripter).

task

टूल के एक्ज़ीक्यूशन के साथ ऑटोनॉमस लूप. एजेंट, पहले से मौजूद finish_task टूल को कॉल करने तक, बार-बार कोशिश करता है.

कई चरणों में समस्या हल करने और जांच करने की सुविधा (quarantine).

नीति के उल्लंघन की समस्या को अपने-आप ठीक करने की सुविधा

फ़्लैग किए गए किसी निर्देश को फिर से लिखने के लिए, task मोड की ज़रूरत होती है. ऐसा इसलिए, क्योंकि समस्या को ठीक करने के लिए, बार-बार निर्देश लिखने की संख्या अलग-अलग हो सकती है. एजेंट को फ़्लैग किया गया निर्देश मिलता है. इसके बाद, वह उल्लंघनों का पता लगाने के लिए find_policy_hits को चालू करता है. साथ ही, suggest_replacement के ज़रिए मंज़ूर किए गए विकल्पों का अनुरोध करता है, निर्देश को फिर से लिखता है, और आगे बढ़ने से पहले यह पुष्टि करता है कि निर्देश में कोई उल्लंघन न हो.

दोनों टूल को agent/cleanup_tools.py में टाइप किए गए सिग्नेचर और डॉकस्ट्रिंग के साथ परिभाषित किया गया है:

def find_policy_hits(text: str) -> dict:
    """Which refused words appear in `text`. Matches whole words and phrases
    from agent/policy_words.txt, case-insensitive.

    Returns {"hits": [...], "clean": bool}. clean is true when hits is empty.
    """


def suggest_replacement(word: str) -> dict:
    """The channel's approved stand-in for a refused word, read from
    agent/policy_replacements.txt.

    Returns {"word", "replacement", "listed"}. When the word has no entry,
    listed is false and replacement is a hint to pick a gentle synonym.
    """

Hands-on edit: assembling the quarantine task agent

stage3_router/agent.py में, प्लेसहोल्डर quarantine फ़ंक्शन को टास्क एजेंट की परिभाषा से बदलें:

quarantine = Agent(
    name="quarantine",
    model=config.MODEL,
    instruction=QUARANTINE_INSTRUCTION,
    mode="task",
    tools=[find_policy_hits, suggest_replacement],
    output_schema=CleanedDirection,
)

टास्क मोड, एजेंट को टूल उपलब्ध कराता है और finish_task को कॉल करके प्रोसेस को खत्म करता है. mode="task" को कॉन्फ़िगर करने पर, ADK अपने-आप finish_task उपलब्ध कराता है. साथ ही, output_schema से इसके पैरामीटर लेता है. इससे यह पक्का होता है कि नोड, स्क्रिप्टर नोड के इनपुट स्कीमा से मैच करने वाला टाइप किया गया CleanedDirection ऑब्जेक्ट जनरेट करे.

05-5C

इसके बाद क्या होगा और क्यों

ADK Web या VibeStudio Workbench में, दोनों एक्ज़ीक्यूशन पाथ की जांच करें:

  • मंज़ूरी वाला रास्ता (उम्मीदवार 1, 2 या 3):
    • मंज़ूरी पा चुके किसी कैंडिडेट को चुनने पर, policy_check से scripter (route="OK") पर रीडायरेक्ट किया जाता है.
    • स्क्रिप्ट राइटर, Script स्कीमा के मुताबिक तीन शॉट वाली प्रोडक्शन स्क्रिप्ट जनरेट करता है.
  • Quarantine remediation route (Candidate 4):
    • चौथे विकल्प में, फ़्लैग की गई शब्दावली ("क्लिकबेट", "वायरल हैक") शामिल है.
    • quarantine (route="BLOCK") के लिए, policy_check रूट.
    • सेशन ट्रेस में, हर उल्लंघन के लिए quarantine को find_policy_hits और suggest_replacement को कॉल करते हुए देखें. साथ ही, टाइटल को फिर से लिखते हुए और finish_task को कॉल करते हुए देखें.
    • इसके बाद, एक्ज़ीक्यूशन scripter में शामिल हो जाता है. इससे, साफ़ किए गए निर्देश से स्क्रिप्ट जनरेट होती है.

6. मेमोरी बैंक

VibeStudio Workbench में, छठा चरण · मेमोरी बैंक के (6A) और (6B) सेक्शन पर जाएं.

फ़िलहाल, वर्कफ़्लो में अलग-अलग सेशन के लिए मेमोरी की सुविधा उपलब्ध नहीं है. हर बार, यह प्रोसेस नए सिरे से शुरू होती है. इसमें क्रिएटर की पिछली पसंद या पसंदीदा शैलियों को ध्यान में नहीं रखा जाता. इस चरण में, Vertex AI Agent Engine Memory Bank को कनेक्ट किया जाता है, ताकि अलग-अलग रन के दौरान क्रिएटर की प्राथमिकताओं को सेव और वापस पाया जा सके.

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

मेमोरी बैंक (6A)

वर्कबेंच में, मेमोरी बैंक (6A) पर जाएं.

06-6A

उपयोगकर्ता की प्राथमिकताएं सेव करने की सेटिंग मैनेज की गई

मेमोरी बैंक, उपयोगकर्ता की मेमोरी को लंबे समय तक सेव रखने के लिए मैनेज की जाने वाली सेवा है. यह कुकी, किसी व्यक्ति के बारे में तथ्यों को तय किए गए स्कोप के हिसाब से व्यवस्थित करती है. यहां, स्कोप की पहचान ऐप्लिकेशन के नाम और यूज़र आईडी से की जाती है:

SCOPE = {"app_name": config.APP, "user_id": config.USER}
TOPICS = {
    "CREATOR_TASTE": "Which video directions this creator picks and passes on, "
                     "and how that preference changes over time.",
    "CHANNEL_RULES": "Standing instructions the creator states for every video "
                     "(style, subjects to avoid, format rules).",
}

कस्टम मेमोरी के विषयों से यह तय होता है कि बैंक क्या रिकॉर्ड करता है:

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

दोनों कार्रवाइयां, agent/platform/memory.py में लागू की जाती हैं. उपलब्ध कराए गए बैंक संसाधन का नाम, runs/memorybank.json में स्थानीय तौर पर कैश मेमोरी में सेव किया जाता है.

मेमोरी बैंक सेट अप करना

वर्कबेंच कंट्रोल का इस्तेमाल करें या अपने टर्मिनल में सीएलआई कमांड चलाएं:

  1. बैंक खाते को कनेक्ट और सेट अप करना:
    python -m agent.platform.bank
    
    यह एजेंट इंजन इंस्टेंस बनाता है और CREATOR_TASTE और CHANNEL_RULES विषयों को कॉन्फ़िगर करता है.
  2. सीड हिस्टॉरिकल सेशन:
    python -m agent.platform.bank load
    
    इसमें क्रिएटर के चार पुराने सेशन लोड होते हैं. इनमें दो एनिमल थीम (स्टाइल से जुड़ी पाबंदियों के साथ), एक गैजेट थीम, और एक हाल ही की फ़ैंटसी थीम शामिल है.
  3. एक साथ इकट्ठा किए गए तथ्यों की जांच करना:
    python -m agent.platform.bank list
    
    आउटपुट की जांच करें. ध्यान दें कि कैसे नैरेटिव ट्रांसक्रिप्ट को स्ट्रक्चर्ड और तथ्यों के हिसाब से सही जानकारी देने वाले स्टेटमेंट में बदला गया है.

कॉलबैक (6B)

वर्कबेंच में, कॉल बैक (6B) पर जाएं. stage4_memory/agent.py खोलें.

06-6A

ADK एजेंट लाइफ़साइकल कॉलबैक

कॉलबैक एक ऐसा फ़ंक्शन होता है जिसे Agent में आर्ग्युमेंट के तौर पर पास किया जाता है. ADK, पहले से तय किए गए लाइफ़साइकल के समय पर कॉलबैक शुरू करता है. साथ ही, चालू कॉन्टेक्स्ट पास करता है. None को वापस करने से सामान्य तरीके से काम जारी रहता है. रिप्लेसमेंट ऑब्जेक्ट को वापस करने से, कार्रवाई को बदल दिया जाता है या उसे रोक दिया जाता है.

06-6A

एडीके, कॉलबैक के तीन पेयर उपलब्ध कराता है:

कॉलबैक पेयर

शुरू करने का पॉइंट

मिले पैरामीटर

रिटर्न वैल्यू का व्यवहार

before_agent_callback
after_agent_callback

पूरे एजेंट टर्न के आस-पास

CallbackContext (स्टेट, सेशन, इनवोकेशन)

Content को रिटर्न करने पर, एजेंट का जवाब बदल जाता है; None सामान्य रूप से आगे बढ़ता है.

before_model_callback
after_model_callback

एलएलएम के हर अनुमानित कॉल के आस-पास

LlmRequest या LlmResponse

LlmResponse मॉडल कॉल को इंटरसेप्ट करता है या उसे स्किप करता है; None आगे बढ़ता है.

before_tool_callback
after_tool_callback

हर टूल के इस्तेमाल से जुड़ी जानकारी

टूल की परिभाषा, आर्ग्युमेंट, नतीजा

डिक्शनरी को वापस करने पर, टूल का आउटपुट बदल जाता है; None आगे बढ़ता है.

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

हैंड्स-ऑन एडिट: वायरिंग रिकॉल और कॉलबैक याद रखना

  1. stage4_memory/agent.py में, before_model_callback=recall_taste अटैच करने के लिए propose_directions को अपडेट करें:
    output_schema=Directions,
    before_model_callback=recall_taste)

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

  1. stage4_memory/agent.py में, after_agent_callback=remember_pick को अटैच करने के लिए scripter को अपडेट करें:
    output_schema=Script,
    after_agent_callback=remember_pick)

scripter की बारी पूरी होने के बाद, remember_pick रन होता है. यह सेशन की स्थिति से चुनी गई दिशा को पढ़ता है. साथ ही, क्रिएटर के फ़ैसले के बारे में खास जानकारी देने वाला एक छोटा स्टेटमेंट बनाता है. इसके बाद, Memory Bank को अपडेट करने के लिए memories.generate को कॉल करता है.

इसके बाद क्या होगा और क्यों

वर्कबेंच या ADK Web में, कॉल बैक की सुविधा के साथ बेहतर बनाए गए वर्कफ़्लो की जांच करें:

  1. बिना किसी प्रॉम्प्ट के रन को एक्ज़ीक्यूट करना:
    • सेशन ट्रेस में, propose_directions के लिए LlmRequest की जांच करें. ध्यान दें कि मेमोरी में जोड़ी गई जानकारी में, क्रिएटर की पसंद के बारे में बताया गया है. जैसे, उसे फ़ैंटसी थीम और कम समय में ज़्यादा जानकारी देने वाले वीडियो पसंद हैं.
    • सुझाए गए विषयों पर ध्यान दें: पहले से लेकर तीसरे तक के उम्मीदवार, क्रिएटर की पुरानी प्राथमिकताओं के मुताबिक हैं. भले ही, रुझान अन्य विषयों पर ज़ोर देते हों.
  2. direction_gate पर जाकर, कोई उम्मीदवार चुनें.
  3. scripter पूरा होने के बाद, मेमोरी बैंक के रिकॉर्ड की समीक्षा करें:
    python -m agent.platform.bank list
    
    अब बैंक में, उपयोगकर्ता की नई पसंद दिखती है. साथ ही, इसे उपयोगकर्ता की पिछली पसंद के रिकॉर्ड के साथ जोड़ दिया जाता है.

7. आरएजी इंजन

VibeStudio Workbench में, सातवां चरण · आरएजी इंजन, पार्ट (7A), और (7B) पर जाएं.

07-7A

पब्लिश किए गए वीडियो पर, दर्शकों से लगातार सुझाव/राय मिलती रहती है. agent/comments.md में 30 टिप्पणियां इकट्ठा की गई हैं. इनमें दर्शकों की तारीफ़, स्पॉन्सर किए गए कॉन्टेंट की रफ़्तार की आलोचना, और ऑडियो से जुड़ी पसंद शामिल हैं. इस चरण में, Vertex AI RAG Engine का इस्तेमाल करके इन टिप्पणियों को इंडेक्स किया जाता है. साथ ही, सिमैंटिक रीट्रिवल को रिसर्च फ़ैन-आउट से कनेक्ट किया जाता है.

दस्तावेज़ों से जानकारी हासिल करना (7A)

वर्कबेंच में, आरएजी इंजन (7A) पर जाएं.

मेमोरी बैंक बनाम RAG इंजन

दोनों टूल, बाहरी डेटा के आधार पर वर्कफ़्लो को बेहतर बनाते हैं. हालांकि, दोनों टूल अलग-अलग आर्किटेक्चर के लिए काम करते हैं:

डाइमेंशन

मेमोरी बैंक

RAG Engine

इस्तेमाल का मुख्य उदाहरण

लंबे समय तक उपयोगकर्ता की प्राथमिकताएं और ऑपरेशनल नियम

दस्तावेज़ों के बड़े कलेक्शन से सिमैंटिक तरीके से जानकारी हासिल करना

दायरा

अलग-अलग यूज़र आईडी और ऐप्लिकेशन के नामों के लिए स्कोप किया गया

सभी उपयोगकर्ताओं के लिए, शेयर किए गए कॉर्पस संसाधनों तक सीमित

डेटा प्रोसेसिंग

रीयल-टाइम में डेटा निकालना, एंबेड करना, और सिमैंटिक कंसोलिडेशन

दस्तावेज़ को छोटे-छोटे हिस्सों में बांटना, वेक्टर एंबेडिंग, और सबसे मिलते-जुलते आइटम खोजना

ग्राफ़ इंटिग्रेशन

एजेंट के लाइफ़साइकल कॉलबैक (before_model_callback, after_agent_callback)

रिसर्च फ़ैन-आउट में खास फ़ंक्शन नोड (read_feedback)

07-7A

दस्तावेज़ को चंक में बांटना और एम्बेड करना

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

corpus = rag.create_corpus(
    display_name="vibestudio-feedback",
    description="Vibe Studio: what the audience wrote under the channel's past videos.",
    backend_config=rag.RagVectorDbConfig(
        rag_embedding_model_config=rag.RagEmbeddingModelConfig(
            vertex_prediction_endpoint=rag.VertexPredictionEndpoint(
                publisher_model="publishers/google/models/text-embedding-005"))))

rag.upload_file(
    corpus_name=corpus.name, path="agent/comments.md", display_name="comments.md",
    transformation_config=rag.TransformationConfig(
        chunking_config=rag.ChunkingConfig(chunk_size=120, chunk_overlap=20)))
  • चंक साइज़: इसे 120 टोकन पर कॉन्फ़िगर किया गया है. इसमें 20 टोकन ओवरलैप होते हैं. यह हर पैसेज से दो से तीन टिप्पणियां कैप्चर करता है. इससे यह पक्का होता है कि हर वेक्टर, एक जैसी भावना को दिखाता है. साथ ही, इसमें काम की टिप्पणियों के बीच, ऐसी टिप्पणियां शामिल नहीं की जातीं जिनका कोई मतलब नहीं होता.
  • एंबेड करने वाला मॉडल: text-embedding-005 टेक्स्ट को ज़्यादा डाइमेंशन वाले वेक्टर में बदलता है. जब कोई क्वेरी सबमिट की जाती है, तो मॉडल उसे वेक्टर में बदल देता है. इसके बाद, सिमैंटिक डिस्टेंस के आधार पर सबसे मिलते-जुलते नतीजे ढूंढता है. मोज़ों की रखवाली करने वाले छोटे ड्रैगन के बारे में की गई टिप्पणी, जादुई जीवों के बारे में दिए गए प्रॉम्प्ट से मैच करती है. इसके लिए, सटीक कीवर्ड ओवरलैप की ज़रूरत नहीं होती.

आरएजी कॉर्पस सेट अप करना

वर्कबेंच बटन या टर्मिनल कमांड का इस्तेमाल करके, कॉर्पस को शुरू करें:

  1. कॉर्पस बनाना:
    python -m agent.platform.rag
    
    मैनेज किए जा रहे वेक्टर डेटाबेस को प्रावधान करता है और संसाधन आईडी को runs/ragcorpus.json में रिकॉर्ड करता है.
  2. टिप्पणियां अपलोड और इंडेक्स करना: चंकिंग कॉन्फ़िगरेशन के साथ agent/comments.md अपलोड करता है और इंडेक्स होने का इंतज़ार करता है.
  3. कॉर्पस से क्वेरी करना: ऐसी क्वेरी के साथ मिलते-जुलते कॉन्टेंट को वापस पाने की सुविधा को आज़माएं जिनमें टिप्पणियों के सटीक शब्द शामिल न हों. उदाहरण के लिए, ड्रेगन के बारे में टिप्पणियां वापस पाने के लिए, "छोटे जादुई जीव" क्वेरी करें.

डेटा वापस पाने वाला नोड (7B)

वर्कबेंच में, तीसरा रीडर (7B) पर जाएं. stage5_rag/agent.py खोलें.

07-7B

ग्राफ़ नोड के तौर पर जानकारी हासिल करना

ऑडियंस के फ़ीडबैक से, रिसर्च डेटा का पता चलता है. इसे वर्कफ़्लो में शेयर किया जाता है. क्रिएटर की निजी मेमोरी के उलट, दर्शकों की भावनाएं सीधे तौर पर join_research में फ़ीड होती हैं. साथ ही, इसमें ट्रेंड और बैकलॉग डेटा भी शामिल होता है. इसलिए, इसे फ़ंक्शन नोड के तौर पर लागू किया जाता है:

07-7B

def read_feedback(node_input):
    """The third reader (step 7): what the audience wrote under past videos,
    the passages nearest to tonight's idea. Retrieval, not a model call."""
    from .platform import rag
    idea = idea_text(node_input)
    query = idea or "what viewers liked and what they complained about"
    try:
        hits = rag.retrieve(query)
    except Exception as e:
        print(f"  [rag] feedback unavailable ({str(e)[:80]})")
        return Event(output={"query": query, "feedback": [],
                             "note": "no corpus connected - run: python -m agent.platform.rag"})
    return Event(output={"query": query, "feedback": [h["text"] for h in hits]})

read_feedback, उपयोगकर्ता के शुरुआती आइडिया को निकालता है और RAG Engine के कॉर्पस के ख़िलाफ़ वेक्टर क्वेरी को एक्ज़ीक्यूट करता है. यह फ़ंक्शन, फ़ेच की गई टिप्पणियों को Event(output=...) पेलोड में दिखाता है.

हैंड्स-ऑन एडिट: फ़ैन-आउट में तीसरे रीडर को वायर करना

stage5_rag/agent.py में, edges को अपडेट करके read_feedback को join_research में शामिल होने वाली तीसरी पैरलल ब्रांच के तौर पर जोड़ें:

           (START, read_backlog, join_research),
           (START, read_feedback, join_research),

join_research एक JoinNode है. इसलिए, यह सभी इनकमिंग ब्रांच को सिंक करता है. यह तब तक इंतज़ार करता है, जब तक scan_trends, read_backlog, और read_feedback सभी इवेंट को इकट्ठा करके डाउनस्ट्रीम में नहीं भेज देते.

इसके बाद क्या होगा और क्यों

वर्कबेंच में वर्कफ़्लो चलाएं:

  1. आइडिया प्रॉम्प्ट सबमिट करें. जैसे, "किचन काउंटर की रखवाली करता हुआ एक छोटा ड्रैगन".
  2. एक्ज़ीक्यूशन ट्रेस में, पुष्टि करें कि तीनों रीडर नोड एक साथ एक्ज़ीक्यूट होते हैं.
  3. join_research को देखें: इसकी आउटपुट डिक्शनरी में अब trends, backlog, और feedback शामिल हैं.
  4. propose_directions से जनरेट किए गए कैंडिडेट की जांच करें: मॉडल, दर्शकों की टिप्पणियों को अपने प्रपोज़ल में शामिल करता है. साथ ही, सबूत वाले फ़ील्ड में दर्शकों की भावनाओं का रेफ़रंस देता है.
  5. ध्यान दें कि आरएजी की मदद से जानकारी हासिल करने की प्रोसेस डिटरमिनिस्टिक होती है. इसका मतलब है कि एक जैसी क्वेरी के लिए, एक जैसी टिप्पणियां मिलती हैं. वहीं, जनरेटिव प्रपोज़ल नोड, क्रिएटिव वैरिएशन जनरेट करता है.

8. Veo की मदद से एसिंक्रोनस वीडियो जनरेट करना

VibeStudio Workbench में, आठवां चरण · वीडियो, (8A), और (8B) सेक्शन पर जाएं.

Google Veo की मदद से हाई-डेफ़िनिशन वीडियो जनरेट करने में, हर रेंडर के लिए कुछ मिनट लगते हैं. इस दौरान ग्राफ़ को एक्ज़ीक्यूट होने से रोकने पर, कंप्यूट रिसॉर्स बर्बाद होते हैं, थ्रेड पूल लॉक हो जाते हैं, और एचटीटीपी कनेक्शन ड्रॉपआउट हो जाता है. इस चरण में, ADK के LongRunningFunctionTool का इस्तेमाल करके, वीडियो रेंडरिंग को असिंक्रोनस बनाया जाता है.

लंबे समय तक चलने वाले टूल (8A)

वर्कबेंच में, लंबे समय तक चलने वाला टूल (8A) पर जाएं. stage6_video/agent.py और agent/deliver.py खोलें.

08-8A

सिंक्रोनस टूल बनाम लंबे समय तक चलने वाले टूल

स्टैंडर्ड एडीके फ़ंक्शन टूल, एजेंट के टर्न में सिंक्रोनस तरीके से काम करते हैं: मॉडल टूल को कॉल करता है, पेलोड के वापस आने का इंतज़ार करता है, और नतीजे को मौजूदा टर्न में शामिल करता है.

वीडियो रेंडर करने की प्रोसेस एक बार में पूरी नहीं हो सकती. इसके बजाय, render_submit जनरेशन जॉब शुरू करता है और तुरंत "pending" स्टेटस के साथ ऑपरेशनल रसीद दिखाता है:

def render_submit(prompt: str) -> dict:
    """Submit one Veo render of `prompt`. Returns at once with a pending
    receipt; the clip is delivered later, to this call, by id."""
    receipt = videogen.start(f"{prompt} {videogen.NO_TEXT}")
    return {"status": "pending", "operation": receipt["operation"], "prompt": receipt["prompt"]}

LongRunningFunctionTool के साथ रैप किए जाने पर, ADK "pending" स्टेटस को इंटरसेप्ट करता है. एजेंट की बारी खत्म हो जाती है, वर्कफ़्लो नोड पर रुक जाता है, और कॉल का बाकी मेटाडेटा (इसमें कॉल आईडी और रसीद शामिल है) runs/sessions.db में रिकॉर्ड हो जाता है. एक्ज़ीक्यूशन प्रोसेस, ऐक्टिव इंटरनेट कनेक्शन या वर्कर थ्रेड को बनाए रखे बिना ही बंद हो जाती है.

हैंड्स-ऑन एडिट: रेंडर टूल को रैप करना

stage6_video/agent.py में, render_submit को LongRunningFunctionTool में रैप करने के लिए, render_desk को अपडेट करें:

    tools=[LongRunningFunctionTool(render_submit)])

कॉल आईडी के हिसाब से कॉल फिर से शुरू करना

यूनिवर्सल रिज़ंप्शन पैटर्न

एडीके, इंसानों और बाहरी टूल, दोनों के लिए वर्कफ़्लो को निलंबित करने और फिर से शुरू करने के लिए एक ही तरीका अपनाता है:

निलंबन का ट्रिगर

Construct को शुरू किया जा रहा है

निलंबन की जानकारी सेव की गई

फिर से शुरू करने का इवेंट

मानवीय फ़ैसला

yield RequestInput(...)

सेशन स्टोर में इनपुट प्रॉम्प्ट खोलें

FunctionResponse में निलंबन का कॉल आईडी मौजूद है

लंबे समय तक चलने वाला टूल

pending को LongRunningFunctionTool(...) वापस किया जा रहा है

सेशन स्टोर में टूल कॉल खोलें

FunctionResponse, जिसमें निलंबन कॉल आईडी शामिल है

दोनों ही स्थितियों में, वर्कफ़्लो पूरी तरह से रुक जाता है. यह सिर्फ़ तब फिर से शुरू होता है, जब किसी बाहरी सोर्स से मैचिंग FunctionResponse वाला कोई इवेंट मिलता है. जैसे, उपयोगकर्ता इंटरफ़ेस, वेबुक या बैकग्राउंड वर्कर.

खुद करके देखें: डिलीवरी के जवाब को पूरा करना

agent/deliver.py में, फिर से शुरू करने के लिए FunctionResponse हिस्सा बनाएं:

    part = Part(function_response=FunctionResponse(
        id=row["call_id"], name=row["name"], response=response))

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

.env में STUDIO_REAL_VIDEO=0 सेट करने पर, मॉक रेंडरिंग की सुविधा चालू हो जाती है: start से तुरंत टेस्ट रसीद मिलती है. साथ ही, check से पांच सेकंड में लेन-देन पूरा होने का सिम्युलेशन होता है. इसके लिए, Veo API के बिल किए जा सकने वाले एपीआई कॉल नहीं किए जाते.

पाइपलाइन इंटिग्रेशन (8B)

वर्कबेंच में, ग्राफ़ (8B) में render_desk पर जाएं. stage6_video/agent.py खोलें.

पाइपलाइन में टर्मिनल नोड store_video है. यह runs/state.json से रेंडर की गई पूरी जानकारी को पढ़ता है (जहां डिलीवरी प्रोसेस ने इसे रिकॉर्ड किया था). साथ ही, वीडियो के यूआरएल और जनरेट होने की स्थिति को शेयर किए गए सेशन की स्थिति में सेव करता है.

08-8B

हैंड्स-ऑन एडिट: वीडियो पाइपलाइन को पूरी तरह से वायर करना

stage6_video/agent.py में, edges को अपडेट करें, ताकि render_desk और store_video को जोड़ा जा सके:

           (quarantine, scripter),
           (scripter, render_desk, store_video)])

इसके बाद क्या होगा और क्यों

वर्कबेंच में एसिंक्रोनस जनरेशन फ़्लो की जांच करें:

  1. उम्मीदवार चुनने और स्क्रिप्ट जनरेट करने के लिए, वर्कफ़्लो को लागू करें.
  2. render_desk पर, एजेंट को render_submit को शुरू करते हुए देखें.
  3. वर्कफ़्लो तुरंत निलंबित हो जाता है. वर्कबेंच या ADK Web में, 'मंज़ूरी बाकी है' स्टेटस देखें: सेशन में ओपन कॉल आईडी मौजूद होता है और बैकग्राउंड में चल रही कोई भी प्रोसेस, संसाधनों का इस्तेमाल नहीं करती.
  4. वर्कबेंच कंसोल या अपने टर्मिनल का इस्तेमाल करके, डिलीवरी डीमन चलाएं:
    python -m agent.deliver
    
    डिलीवरी प्रोसेस, Veo को तब तक मॉनिटर करती है, जब तक वीडियो तैयार नहीं हो जाता. इसके बाद, वह वीडियो को फिर से शुरू करने का इवेंट भेजती है.
  5. ADK Web में, सेशन को रीफ़्रेश करें: इससे store_video पर एक्ज़ीक्यूशन फिर से शुरू हो जाता है, वीडियो यूआरएल को सेशन की स्थिति में सेव कर दिया जाता है, और वर्कफ़्लो पूरा हो जाता है.

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

VibeStudio Workbench में, Step 9 · Deploy पर जाएं.

आपने अलग-अलग सैंडबॉक्स में, पाइपलाइन के हर कॉम्पोनेंट को डेवलप और उसकी पुष्टि कर ली है. इस चरण में, पूरी प्रोडक्शन पाइपलाइन को असेंबल किया जाता है और उसे Google Cloud Run पर डिप्लॉय किया जाता है.

09-9A

ADK Runner

डेवलपमेंट के दौरान, adk web ने ग्राफ़ को व्यवस्थित किया. प्रोडक्शन में, ऐप्लिकेशन ADK के Runner क्लास का इस्तेमाल करके वर्कफ़्लो को होस्ट करता है:

self._svc = DatabaseSessionService(db_url=config.DB_URL)
self._runner = Runner(app_name=config.APP, agent=wf, session_service=self._svc)

async for ev in self._runner.run_async(user_id=config.USER, session_id=run_id, new_message=message):
    self._absorb(ev)    # fold the ADK event into the run state, publish one app event

# the gate's answer and the render's delivery are the same call, with a function_response part
part = Part(function_response=FunctionResponse(id=call_id, name=name, response=response))
  • run_async: यह वर्कफ़्लो को पूरा करने की प्रोसेस को मैनेज करता है. साथ ही, नोड के चलने पर क्रम से इवेंट जनरेट करता है और सेशन सेवा में अपडेट सेव करता है.
  • Unified resumption: Both user decisions at direction_gate and completed video deliveries from Veo resume execution through identical FunctionResponse objects submitted to run_async.

प्रोडक्शन ऐप्लिकेशन आर्किटेक्चर

vibestudio/ में मौजूद प्रोडक्शन ऐप्लिकेशन में पूरी पाइपलाइन इंटिग्रेट की जाती है:

vibestudio/
  server/
    main.py                 FastAPI: application server, REST routes, static assets
    api.py                  REST API endpoints: run, pick, publish, backlog, profile, history
    runner.py               Runner orchestration over the workflow, background render poller
    platform/               Event bus (SSE stream), file storage, publishing, telemetry
    agent/                  Production agent package, verified by checks/verify_app.py
      graph.py              The complete workflow graph and node definitions
      desk.py               render_desk and render_submit wrapped with LongRunningFunctionTool
      schemas.py            Pydantic schemas: Directions, CleanedDirection, Script
      cleanup_tools.py      Deterministic policy tools: find_policy_hits, suggest_replacement
      platform/             Memory Bank, RAG Engine, and Veo integrations
  web/                      Production React user interface
  Dockerfile · deploy.py · run.sh
  • सिंगल इवेंट स्ट्रीम: FastAPI बैकएंड, एक ही सर्वर-सेंट इवेंट (एसएसई) स्ट्रीम पर इवेंट पब्लिश करता है. React फ़्रंटएंड, रीयल टाइम में ग्राफ़ की प्रोग्रेस को विज़ुअलाइज़ करता है. साथ ही, स्टेट को खोए बिना देर से होने वाले कनेक्शन को मैनेज करता है.
  • डिकपल्ड एक्ज़ीक्यूशन: ऐप्लिकेशन, इवेंट लूप को मैनेज करता है. वर्कफ़्लो ग्राफ़ पूरी तरह से एक्ज़ीक्यूशन लॉजिक पर फ़ोकस करता है. इसे फ़्रंटएंड इंटरफ़ेस की जानकारी नहीं होती.

agent/graph.py में मौजूद पूरी वर्कफ़्लो एज लिस्ट, इस कोडलैब में बनाए गए हर आर्किटेक्चरल पैटर्न को जोड़ती है:

        (START, scan_trends, join_research),
        (START, read_backlog, join_research),
        (START, read_feedback, join_research),
        (join_research, propose_directions, direction_gate,
         persist_direction, policy_check),
        (policy_check, {"OK": scripter, "BLOCK": quarantine}),
        (quarantine, scripter),
        (scripter, render_desk, store_video),

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

Google Cloud Run, सर्वरलेस होस्टिंग की सुविधा देता है. इसमें अपने-आप स्केल होने, अनुरोधों को रूट करने, और इंटिग्रेट किए गए कंटेनर बिल्ड की सुविधाएं शामिल हैं:

gcloud run deploy vibestudio --source vibestudio \
  --project $GOOGLE_CLOUD_PROJECT --region us-central1 \
  --labels dev-tutorial-codelab=vibetube --allow-unauthenticated \
  --memory 2Gi --cpu 2 --timeout 3600 --concurrency 40 \
  --max-instances 1 --min-instances 1 --session-affinity \
  --set-env-vars GOOGLE_CLOUD_PROJECT=...,STUDIO_VERTEX=1,STUDIO_MEMORY_BANK=...,STUDIO_RAG_CORPUS=...,VIBETUBE_URL=...,VIBETUBE_EVENT=...,VIBETUBE_NAME=...,VIBETUBE_PROJECT=...
  • कंटेनर बिल्ड: gcloud run deploy --source, vibestudio/ डायरेक्ट्री को पैकेज करता है, Cloud Build का इस्तेमाल करके कंटेनर इमेज बनाता है, और सेवा को एक ही कार्रवाई में डिप्लॉय करता है.
  • सेशन अफ़िनिटी: यह एक ही उपयोगकर्ता के अनुरोधों को एक ही कंटेनर इंस्टेंस पर भेजती है. इससे, बार-बार होने वाले चरणों में लोकल सेशन की स्थिति बनी रहती है.
  • ऑब्ज़र्वेबिलिटी: Cloud Trace इंटिग्रेशन, हर नोड, एलएलएम कॉल, और टूल के एक्ज़ीक्यूशन के लिए डिस्ट्रिब्यूटेड स्पैन रिकॉर्ड करता है. इन्हें Google Cloud Console में Trace Explorer में ऐक्सेस किया जा सकता है.

डिप्लॉयमेंट स्क्रिप्ट को लागू करने के लिए, वर्कबेंच में Deploy बटन पर क्लिक करें. बिल्ड पूरा होने पर, टर्मिनल में लाइव सर्विस का यूआरएल दिखता है.

ऐप्लिकेशन

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

VibeStudio Workbench में, चरण 10 · खास जानकारी पर जाएं. यहां आपको पूरा आर्किटेक्चर दिखेगा.

10-खास जानकारी

चरण

आर्किटेक्चर और कॉन्सेप्ट

लागू करने का पैटर्न

एक प्रॉम्प्ट

एक प्रॉम्प्ट, फ़ंक्शन टूल, क्रम में चलने वाला चैट लूप

Agent(tools=[...]), function_call / function_response

एजेंटिक वर्कफ़्लो के बुनियादी सिद्धांत

ग्राफ़ वर्कफ़्लो, पैरलल रिसर्च, स्कीमा आउटपुट, ह्यूमन गेट

Workflow, START, JoinNode, output_schema, RequestInput

स्टेट और राऊटर

शेयर किया गया सेशन स्टेट, पैरामीटर बाइंडिंग, डिटरमिनिस्टिक रूटिंग, टास्क एजेंट

Event(state=...), Event(route=...), mode="task", finish_task

मेमोरी बैंक

उपयोगकर्ता के लेवल पर लंबे समय तक सेव रहने वाली मेमोरी, सिमैंटिक कंसोलिडेशन, और लाइफ़साइकल हुक

memories.generate / retrieve, before_model_callback, after_agent_callback

RAG Engine

ऑडियंस की टिप्पणियों और सिमैंटिक एंबेडिंग के आधार पर दस्तावेज़ ढूंढना

rag.create_corpus, RagEmbeddingModelConfig, read_feedback नोड

Veo की मदद से एसिंक्रोनस वीडियो जनरेट करना

लंबे समय तक चलने वाले टूल, पेंडिंग रसीदें, बाहरी डिलीवरी डीमन

LongRunningFunctionTool, FunctionResponse(id=...) फिर से शुरू करना

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

प्रोग्रामैटिक ऑर्केस्ट्रेशन, सर्वर-सेंट इवेंट, बिना सर्वर वाला कंटेनर

Runner(agent=wf), run_async, Cloud Run डिप्लॉयमेंट

आर्किटेक्चर के मुख्य सिद्धांत

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

10-आउटपुट