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

विशेषीकृत एजेंट्स को टीमों में संयोजित करके परिष्कृत एप्लिकेशन बनाएं।

आप क्या बनाएंगे

इस गाइड में, आप एक ग्राहक सेवा सिस्टम बनाएंगे जहाँ एक Coordinator प्रश्नों को Specialists के पास भेजता है:

                        ┌─────────────────────┐
       User Query       │                     │
      ────────────────▶ │    COORDINATOR      │
                        │  "Route to expert"  │
                        └──────────┬──────────┘
                                   │
                   ┌───────────────┴───────────────┐
                   │                               │
                   ▼                               ▼
        ┌──────────────────┐            ┌──────────────────┐
        │  BILLING AGENT   │            │  SUPPORT AGENT   │
        │                  │            │                  │
        │  💰 Payments     │            │  🔧 Tech Issues  │
        │  📄 Invoices     │            │  🐛 Bug Reports  │
        │  💳 Subscriptions│            │  ❓ How-To       │
        └──────────────────┘            └──────────────────┘

मुख्य अवधारणाएँ:

Coordinator - सभी अनुरोध प्राप्त करता है, तय करता है कि उन्हें कौन संभालेगा।
Specialists - केंद्रित Agents जो विशिष्ट डोमेन में उत्कृष्ट होते हैं।
Transfer - Coordinator से Specialist को निर्बाध हस्तांतरण।

त्वरित शुरुआत

1. अपना प्रोजेक्ट बनाएं

cargo new multi_agent_demo
cd multi_agent_demo

Cargo.toml में डिपेंडेंसी जोड़ें:

[dependencies]
adk-rust = { version = "0.2", features = ["agents", "models", "cli"] }
tokio = { version = "1", features = ["full"] }
dotenvy = "0.15"

अपनी API कुंजी के साथ .env बनाएं:

echo 'GOOGLE_API_KEY=your-api-key' > .env

2. ग्राहक सेवा उदाहरण

यहाँ एक पूर्ण कार्यरत उदाहरण है:

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

    // Specialist: Billing Agent
    let billing_agent = LlmAgentBuilder::new("billing_agent")
        .description("Handles billing questions: payments, invoices, subscriptions, refunds")
        .instruction("You are a billing specialist. Help customers with:\n\
                     - Invoice questions and payment history\n\
                     - Subscription plans and upgrades\n\
                     - Refund requests\n\
                     - Payment method updates\n\
                     Be professional and provide clear information about billing matters.")
        .model(model.clone())
        .build()?;

    // Specialist: Technical Support Agent
    let support_agent = LlmAgentBuilder::new("support_agent")
        .description("Handles technical support: bugs, errors, troubleshooting, how-to questions")
        .instruction("You are a technical support specialist. Help customers with:\n\
                     - Troubleshooting errors and bugs\n\
                     - How-to questions about using the product\n\
                     - Configuration and setup issues\n\
                     - Performance problems\n\
                     Be patient and provide step-by-step guidance.")
        .model(model.clone())
        .build()?;

    // Coordinator: Routes to appropriate specialist
    let coordinator = LlmAgentBuilder::new("coordinator")
        .description("Main customer service coordinator")
        .instruction("You are a customer service coordinator. Analyze each customer request:\n\n\
                     - For BILLING questions (payments, invoices, subscriptions, refunds):\n\
                       Transfer to billing_agent\n\n\
                     - For TECHNICAL questions (errors, bugs, how-to, troubleshooting):\n\
                       Transfer to support_agent\n\n\
                     - For GENERAL greetings or unclear requests:\n\
                       Respond yourself and ask clarifying questions\n\n\
                     When transferring, briefly acknowledge the customer and explain the handoff.")
        .model(model.clone())
        .sub_agent(Arc::new(billing_agent))
        .sub_agent(Arc::new(support_agent))
        .build()?;

    println!("🏢 Customer Service Center");
    println!("   Coordinator → Billing Agent | Support Agent");
    println!();

    Launcher::new(Arc::new(coordinator)).run().await?;
    Ok(())
}

उदाहरण संवाद:

आप: मेरे पिछले चालान के बारे में मेरा एक प्रश्न है

[Agent: coordinator]
सहायक: मैं आपके चालान के प्रश्न में सहायता के लिए आपको हमारे बिलिंग विशेषज्ञ से जोड़ रहा हूँ।

[Agent: billing_agent]
सहायक: नमस्ते! मैं आपके चालान में आपकी सहायता कर सकता हूँ। आपके पिछले चालान के बारे में आपका विशेष प्रश्न क्या है?

आप: मुझसे दो बार शुल्क क्यों लिया गया?

[Agent: billing_agent]
सहायक: मैं दोहरे शुल्क के बारे में आपकी चिंता समझता हूँ। मुझे इसकी जाँच में आपकी मदद करने दें...

मल्टी-एजेंट ट्रांसफर कैसे काम करता है

बड़ी तस्वीर

जब आप किसी पैरेंट एजेंट में सब-एजेंट जोड़ते हैं, तो LLM को कार्य प्रतिनिधित्व करने की क्षमता मिलती है:

                    ┌─────────────────────┐
    User Message    │                     │
   ─────────────────▶    COORDINATOR      │
                    │                     │
                    └──────────┬──────────┘
                               │
           "This is a billing question..."
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │  billing_agent   │              │  support_agent   │
   │  💰 Payments     │              │  🔧 Tech Issues  │
   │  📄 Invoices     │              │  🐛 Bug Reports  │
   └──────────────────┘              └──────────────────┘

चरण-दर-चरण ट्रांसफर फ्लो

जब कोई उपयोगकर्ता बिलिंग संबंधी प्रश्न पूछता है तो ठीक यही होता है:

┌──────────────────────────────────────────────────────────────────────┐
│ STEP 1: उपयोगकर्ता संदेश भेजता है                                    │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   User: "Why was I charged twice on my invoice?"                     │
│                                                                      │
│                              ↓                                       │
│                                                                      │
│   ┌──────────────────────────────────────┐                          │
│   │         COORDINATOR AGENT            │                          │
│   │  सबसे पहले संदेश प्राप्त करता है      │                          │
│   └──────────────────────────────────────┘                          │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 2: LLM विश्लेषण करता है और ट्रांसफर करने का निर्णय लेता है        │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   🧠 LLM सोचता है: "यह एक इनवॉइस चार्ज के बारे में है..."               │
│                  "इनवॉइस = बिलिंग विषय..."                           │
│                  "मुझे billing_agent को ट्रांसफर करना चाहिए"          │
│                                                                      │
│   📞 LLM calls: transfer_to_agent(agent_name="billing_agent")        │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 3: Runner ट्रांसफर का पता लगाता है और टारगेट को इनवोक करता है     │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────┐     transfer event      ┌─────────────────┐           │
│   │ Runner  │ ─────────────────────▶  │  billing_agent  │           │
│   └─────────┘   (वही उपयोगकर्ता संदेश)   └─────────────────┘           │
│                                                                      │
│   • Runner एजेंट ट्री में "billing_agent" ढूंढता है                     │
│   • SAME उपयोगकर्ता संदेश के साथ नया संदर्भ बनाता है                 │
│   • billing_agent को तुरंत इनवोक करता है                              │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 4: टारगेट एजेंट प्रतिक्रिया देता है                                │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────────────────────────────────────┐                       │
│   │           billing_agent प्रतिक्रिया देता है │                       │
│   │                                         │                       │
│   │  "मैं आपके डुप्लिकेट चार्ज में मदद       │                       │
│   │   कर सकता हूँ। मुझे जांच करने दें..."    │                       │
│   └─────────────────────────────────────────┘                       │
│                                                                      │
│   ✅ उपयोगकर्ता को सहज प्रतिक्रिया मिलती है - कोई रुकावट नहीं!         │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

इसे क्या काम करता है

Component	Role
`.sub_agent()`	पैरेंट के तहत विशेषज्ञों को पंजीकृत करता है
`transfer_to_agent` tool	सब-एजेंट मौजूद होने पर स्वतः इंजेक्ट होता है
Agent descriptions	LLM को यह तय करने में मदद करते हैं कि कौन सा एजेंट क्या संभालता है
Runner	ट्रांसफर घटनाओं का पता लगाता है और टारगेट एजेंट को इनवोक करता है
Shared session	ट्रांसफर में स्थिति और इतिहास संरक्षित रहता है

सब-एजेंट जोड़ने से पहले बनाम बाद में

सब-एजेंट के बिना - एक एजेंट सब कुछ करता है:

User ──▶ coordinator ──▶ Response (बिलिंग और सपोर्ट दोनों को संभालता है)

सब-एजेंट के साथ - विशेषज्ञ अपने डोमेन को संभालते हैं:

User ──▶ coordinator ──▶ billing_agent ──▶ Response (बिलिंग विशेषज्ञ)
                    ──▶ support_agent ──▶ Response (तकनीकी विशेषज्ञ)

पदानुक्रमित मल्टी-एजेंट सिस्टम

जटिल परिदृश्यों के लिए, आप बहु-स्तरीय पदानुक्रम बना सकते हैं। प्रत्येक एजेंट के अपने उप-एजेंट हो सकते हैं, जो एक ट्री बनाते हैं:

दृश्य: 3-स्तरीय सामग्री टीम

                    ┌─────────────────────┐
                    │  PROJECT MANAGER    │  ← स्तर 1: शीर्ष-स्तरीय समन्वयक
                    │  "परियोजनाओं का प्रबंधन करें"  │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │  CONTENT CREATOR    │  ← स्तर 2: मध्य-स्तरीय समन्वयक  
                    │  "अनुसंधान और लेखन का समन्वय करें"   │
                    └──────────┬──────────┘
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │   RESEARCHER     │              │     WRITER       │  ← स्तर 3: विशेषज्ञ
   │                  │              │                  │
   │  📚 तथ्य एकत्र करें │              │  ✍️ सामग्री लिखें │
   │  🔍 डेटा का विश्लेषण करें │              │  📝 पाठ को परिष्कृत करें  │
   │  📊 स्रोत खोजें │              │  🎨 शैली और लहजा │
   └──────────────────┘              └──────────────────┘

अनुरोध कैसे नीचे जाते हैं

उपयोगकर्ता: "इलेक्ट्रिक वाहनों के बारे में एक ब्लॉग पोस्ट बनाएँ"
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  PROJECT MANAGER: "यह एक सामग्री कार्य है"                  │
│  → content_creator को स्थानांतरित करता है                             │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  CONTENT CREATOR: "पहले अनुसंधान की आवश्यकता है, फिर लेखन"       │
│  → researcher को स्थानांतरित करता है                             │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  RESEARCHER: "यहाँ मैंने ईवीएस के बारे में क्या पाया है..."             │
│  → अनुसंधान सारांश प्रदान करता है                                │
└─────────────────────────────────────────────────────────────┘

पूर्ण उदाहरण कोड

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

    // स्तर 3: पत्ती विशेषज्ञ
    let researcher = LlmAgentBuilder::new("researcher")
        .description("विषयों पर शोध करता है और व्यापक जानकारी एकत्र करता है")
        .instruction("आप एक अनुसंधान विशेषज्ञ हैं। जब किसी विषय पर शोध करने के लिए कहा जाए तो:\n\
                     - मुख्य तथ्य और डेटा एकत्र करें\n\
                     - मुख्य विषयों और उप-विषयों की पहचान करें\n\
                     - महत्वपूर्ण स्रोतों या संदर्भों को नोट करें\n\
                     विस्तृत, सुव्यवस्थित अनुसंधान सारांश प्रदान करें।")
        .model(model.clone())
        .build()?;

    let writer = LlmAgentBuilder::new("writer")
        .description("अनुसंधान के आधार पर परिष्कृत सामग्री लिखता है")
        .instruction("आप एक सामग्री लेखक हैं। जब लिखने के लिए कहा जाए तो:\n\
                     - आकर्षक, स्पष्ट सामग्री बनाएँ\n\
                     - दर्शकों के लिए उपयुक्त लहजे का उपयोग करें\n\
                     - सामग्री को तार्किक रूप से संरचित करें\n\
                     - व्याकरण और शैली के लिए परिष्कृत करें\n\
                     पेशेवर, प्रकाशन-तैयार सामग्री का उत्पादन करें।")
        .model(model.clone())
        .build()?;

    // स्तर 2: सामग्री समन्वयक
    let content_creator = LlmAgentBuilder::new("content_creator")
        .description("अनुसंधान और लेखन को सौंपकर सामग्री निर्माण का समन्वय करता है")
        .instruction("आप एक सामग्री निर्माण प्रमुख हैं। सामग्री अनुरोधों के लिए:\n\n\
                     - यदि अनुसंधान की आवश्यकता है: researcher को स्थानांतरित करें\n\
                     - यदि लेखन की आवश्यकता है: writer को स्थानांतरित करें\n\
                     - योजना या अवलोकन के लिए: स्वयं संभालें\n\n\
                     अनुसंधान और लेखन चरणों के बीच समन्वय स्थापित करें।")
        .model(model.clone())
        .sub_agent(Arc::new(researcher))
        .sub_agent(Arc::new(writer))
        .build()?;

    // स्तर 1: शीर्ष-स्तरीय प्रबंधक
    let project_manager = LlmAgentBuilder::new("project_manager")
        .description("परियोजनाओं का प्रबंधन करता है और सामग्री टीम के साथ समन्वय करता है")
        .instruction("आप एक परियोजना प्रबंधक हैं। आने वाले अनुरोधों के लिए:\n\n\
                     - सामग्री निर्माण कार्यों के लिए: content_creator को स्थानांतरित करें\n\
                     - परियोजना की स्थिति या सामान्य प्रश्नों के लिए: स्वयं संभालें\n\n\
                     समग्र परियोजना लक्ष्यों और समय-सीमाओं पर नज़र रखें।")
        .model(model.clone())
        .sub_agent(Arc::new(content_creator))
        .build()?;

    println!("📊 पदानुक्रमित मल्टी-एजेंट सिस्टम");
    println!();
    println!("   project_manager");
    println!("       └── content_creator");
    println!("               ├── researcher");
    println!("               └── writer");
    println!();

    Launcher::new(Arc::new(project_manager)).run().await?;
    Ok(())
}

एजेंट पदानुक्रम:

project_manager
└── content_creator
    ├── researcher
    └── writer

उदाहरण संकेत:

"स्वास्थ्य सेवा में एआई के बारे में एक ब्लॉग पोस्ट बनाएँ" → PM → Content Creator → Writer
"इलेक्ट्रिक वाहनों पर शोध करें" → PM → Content Creator → Researcher

उप-एजेंट कॉन्फ़िगरेशन

sub_agent() बिल्डर मेथड का उपयोग करके किसी भी LlmAgent में उप-एजेंट जोड़ें:

let parent = LlmAgentBuilder::new("parent")
    .description("Coordinates specialized tasks")
    .instruction("Route requests to appropriate specialists.")
    .model(model.clone())
    .sub_agent(Arc::new(specialist_a))
    .sub_agent(Arc::new(specialist_b))
    .build()?;

मुख्य बिंदु:

प्रत्येक एजेंट के कई उप-एजेंट हो सकते हैं
उप-एजेंटों के अपने उप-एजेंट हो सकते हैं (बहु-स्तरीय पदानुक्रम)
पदानुक्रम के भीतर एजेंट के नाम अद्वितीय होने चाहिए
विवरण LLM को यह तय करने में मदद करते हैं कि किस एजेंट को स्थानांतरित करना है

प्रभावी स्थानांतरण निर्देश लिखना

सफल एजेंट स्थानांतरण के लिए, स्पष्ट निर्देश और विवरण प्रदान करें:

पैरेंट एजेंट निर्देश

let coordinator = LlmAgentBuilder::new("coordinator")
    .description("Main customer service coordinator")
    .instruction("You are a customer service coordinator. Analyze each request:\n\n\
                 - For BILLING questions (payments, invoices, subscriptions):\n\
                   Transfer to billing_agent\n\n\
                 - For TECHNICAL questions (errors, bugs, troubleshooting):\n\
                   Transfer to support_agent\n\n\
                 - For GENERAL greetings or unclear requests:\n\
                   Respond yourself and ask clarifying questions")
    .model(model.clone())
    .sub_agent(Arc::new(billing_agent))
    .sub_agent(Arc::new(support_agent))
    .build()?;

उप-एजेंट विवरण

let billing_agent = LlmAgentBuilder::new("billing_agent")
    .description("Handles billing questions: payments, invoices, subscriptions, refunds")
    .instruction("You are a billing specialist. Help with payment and subscription issues.")
    .model(model.clone())
    .build()?;

let support_agent = LlmAgentBuilder::new("support_agent")
    .description("Handles technical support: bugs, errors, troubleshooting, how-to questions")
    .instruction("You are a technical support specialist. Provide step-by-step guidance.")
    .model(model.clone())
    .build()?;

सर्वोत्तम अभ्यास:

वर्णनात्मक एजेंट नामों का उपयोग करें जो उनके उद्देश्य को स्पष्ट रूप से दर्शाते हैं
विस्तृत विवरण लिखें - LLM स्थानांतरण का निर्णय लेने के लिए इनका उपयोग करता है
विवरण में विशिष्ट कीवर्ड शामिल करें जो संभावित उपयोगकर्ता अनुरोधों से मेल खाते हों
पैरेंट एजेंट निर्देशों में स्पष्ट प्रत्यायोजन नियम दें
एजेंट विवरणों में सुसंगत शब्दावली का उपयोग करें

अपने मल्टी-एजेंट सिस्टम का परीक्षण करना

उदाहरण चलाना

# Run the customer service example
cargo run --bin customer_service

# Run the hierarchical example  
cargo run --bin hierarchical

उदाहरण परीक्षण प्रॉम्प्ट

ग्राहक सेवा:

"मेरे अंतिम चालान के बारे में मेरा एक प्रश्न है" → को billing_agent पर रूट करना चाहिए
"ऐप बार-बार क्रैश हो रहा है" → को support_agent पर रूट करना चाहिए
"मैं अपनी योजना कैसे अपग्रेड करूं?" → को billing_agent पर रूट करना चाहिए
"नमस्ते, मुझे मदद चाहिए" → स्पष्टीकरण के लिए coordinator के साथ रहना चाहिए

पदानुक्रमित:

"स्वास्थ्य सेवा में AI के बारे में एक ब्लॉग पोस्ट बनाएं" → PM → Content Creator → Writer
"इलेक्ट्रिक वाहनों के इतिहास पर शोध करें" → PM → Content Creator → Researcher
"हमारी वर्तमान परियोजनाओं की स्थिति क्या है?" → को project_manager के साथ रहना चाहिए

स्थानांतरण समस्याओं का निवारण

यदि स्थानांतरण अपेक्षा के अनुरूप काम नहीं कर रहे हैं:

एजेंट नामों की जाँच करें - स्थानांतरण कॉलों में बिल्कुल मेल खाना चाहिए
विवरणों की समीक्षा करें - उन्हें अधिक विशिष्ट और कीवर्ड-समृद्ध बनाएं
निर्देशों को स्पष्ट करें - स्थानांतरण कब करना है, इसके बारे में स्पष्ट रहें
एज केस का परीक्षण करें - रूटिंग व्यवहार देखने के लिए अस्पष्ट अनुरोधों का प्रयास करें
स्थानांतरण संकेतकों की तलाश करें - [Agent: name] दिखाता है कि कौन सा एजेंट प्रतिक्रिया दे रहा है

वैश्विक निर्देश

मूल उपयोग

let agent = LlmAgentBuilder::new("assistant")
    .description("A helpful assistant")
    .global_instruction(
        "You are a professional assistant for Acme Corp. \
         Always maintain a friendly but professional tone. \
         Our company values are: customer-first, innovation, and integrity."
    )
    .instruction("Help users with their questions and tasks.")
    .model(model.clone())
    .build()?;

ग्लोबल बनाम एजेंट निर्देश

Global Instruction: पदानुक्रम में सभी एजेंटों पर लागू होता है, समग्र व्यक्तित्व/संदर्भ निर्धारित करता है
Agent Instruction: प्रत्येक एजेंट के लिए विशिष्ट, उसकी विशेष भूमिका और व्यवहार को परिभाषित करता है

दोनों निर्देश वार्तालाप इतिहास में शामिल होते हैं, जिसमें ग्लोबल निर्देश पहले आता है।

डायनामिक ग्लोबल निर्देश

अधिक उन्नत परिदृश्यों के लिए, आप एक ग्लोबल निर्देश प्रदाता का उपयोग कर सकते हैं जो निर्देश को गतिशील रूप से गणना करता है:

use adk_core::GlobalInstructionProvider;

let provider: GlobalInstructionProvider = Arc::new(|ctx| {
    Box::pin(async move {
        // Access context information
        let user_id = ctx.user_id();
        
        // Compute dynamic instruction
        let instruction = format!(
            "You are assisting user {}. Tailor your responses to their preferences.",
            user_id
        );
        
        Ok(instruction)
    })
});

let agent = LlmAgentBuilder::new("assistant")
    .description("A personalized assistant")
    .global_instruction_provider(provider)
    .model(model.clone())
    .build()?;

स्टेट वेरिएबल इंजेक्शन

ग्लोबल और एजेंट दोनों निर्देश {variable} सिंटैक्स का उपयोग करके स्टेट वेरिएबल इंजेक्शन का समर्थन करते हैं:

// Set state in a previous agent or tool
// state["company_name"] = "Acme Corp"
// state["user_role"] = "manager"

let agent = LlmAgentBuilder::new("assistant")
    .global_instruction(
        "You are an assistant for {company_name}. \
         The user is a {user_role}."
    )
    .instruction("Help with {user_role}-level tasks.")
    .model(model.clone())
    .build()?;

फ्रेमवर्क स्वचालित रूप से सत्र स्टेट से मानों को निर्देश टेम्पलेट्स में इंजेक्ट करता है।

सामान्य मल्टी-एजेंट पैटर्न

समन्वयक/प्रेषक पैटर्न (Coordinator/Dispatcher Pattern)

एक केंद्रीय एजेंट विशेष उप-एजेंटों को अनुरोध भेजता है:

let billing = LlmAgentBuilder::new("billing")
    .description("Handles billing and payment questions")
    .model(model.clone())
    .build()?;

let support = LlmAgentBuilder::new("support")
    .description("Provides technical support")
    .model(model.clone())
    .build()?;

let coordinator = LlmAgentBuilder::new("coordinator")
    .instruction("Route requests to billing or support agents as appropriate.")
    .sub_agent(Arc::new(billing))
    .sub_agent(Arc::new(support))
    .model(model.clone())
    .build()?;

उदाहरण बातचीत:

User: I have a question about my last invoice

[Agent: coordinator]
Assistant: I'll connect you with our billing specialist.
🔄 [Transfer requested to: billing]

[Agent: billing]
Assistant: Hello! I can help you with your invoice. 
What specific question do you have?

User: Why was I charged twice?

[Agent: billing]
Assistant: Let me investigate that duplicate charge for you...

मुख्य बातें:

समन्वयक अनुरोध का विश्लेषण करता है और billing agent को स्थानांतरित करता है।
billing agent उसी मोड़ में तुरंत प्रतिक्रिया देता है।
बाद के संदेश billing agent के साथ जारी रहते हैं।
स्थानांतरण संकेतक (🔄) दिखाते हैं कि हैंडऑफ़ कब होते हैं।

पदानुक्रमित कार्य अपघटन (Hierarchical Task Decomposition)

जटिल कार्यों को तोड़ने के लिए बहु-स्तरीय पदानुक्रम:

// Low-level specialists
let researcher = LlmAgentBuilder::new("researcher")
    .description("Researches topics and gathers information")
    .model(model.clone())
    .build()?;

let writer = LlmAgentBuilder::new("writer")
    .description("Writes content based on research")
    .model(model.clone())
    .build()?;

// Mid-level coordinator
let content_creator = LlmAgentBuilder::new("content_creator")
    .description("Creates content by coordinating research and writing")
    .sub_agent(Arc::new(researcher))
    .sub_agent(Arc::new(writer))
    .model(model.clone())
    .build()?;

// Top-level manager
let project_manager = LlmAgentBuilder::new("project_manager")
    .description("Manages content creation projects")
    .sub_agent(Arc::new(content_creator))
    .model(model.clone())
    .build()?;

वर्कफ़्लो एजेंटों के साथ संयोजन

मल्टी-एजेंट सिस्टम वर्कफ़्लो एजेंटों (SequentialAgent, ParallelAgent, LoopAgent) के साथ अच्छी तरह से काम करते हैं:

use adk_agent::workflow::{SequentialAgent, ParallelAgent};

// Create specialized agents
let validator = LlmAgentBuilder::new("validator")
    .instruction("Validate the input data.")
    .output_key("validation_result")
    .model(model.clone())
    .build()?;

let processor = LlmAgentBuilder::new("processor")
    .instruction("Process data if {validation_result} is valid.")
    .output_key("processed_data")
    .model(model.clone())
    .build()?;

// Combine in a sequential workflow
let pipeline = SequentialAgent::new(
    "validation_pipeline",
    vec![Arc::new(validator), Arc::new(processor)]
);

// Use the pipeline as a sub-agent
let coordinator = LlmAgentBuilder::new("coordinator")
    .description("Coordinates data processing")
    .sub_agent(Arc::new(pipeline))
    .model(model.clone())
    .build()?;

एजेंटों के बीच संचार

एक पदानुक्रम में एजेंट साझा session state के माध्यम से संचार करते हैं:

// Agent A saves data to state
let agent_a = LlmAgentBuilder::new("agent_a")
    .instruction("Analyze the topic and save key points.")
    .output_key("key_points")  // Automatically saves output to state
    .model(model.clone())
    .build()?;

// Agent B reads data from state
let agent_b = LlmAgentBuilder::new("agent_b")
    .instruction("Expand on the key points: {key_points}")
    .model(model.clone())
    .build()?;

output_key कॉन्फ़िगरेशन स्वचालित रूप से एक एजेंट की अंतिम प्रतिक्रिया को session state में सहेजता है, जिससे यह बाद के एजेंटों के लिए उपलब्ध हो जाती है।

मल्टी-एजेंट सिस्टम चलाना

लॉन्चर का उपयोग करना

Launcher मल्टी-एजेंट सिस्टम को चलाने और उनका परीक्षण करने का एक आसान तरीका प्रदान करता है:

use adk_rust::Launcher;

let coordinator = /* your multi-agent setup */;

Launcher::new(Arc::new(coordinator))
    .run()
    .await?;

रन मोड:

# Interactive console mode
cargo run --example multi_agent -- chat

# Web server mode with UI
cargo run --example multi_agent -- serve
cargo run --example multi_agent -- serve --port 3000

विशेषताएं:

Agent इंडिकेटर: दिखाता है कि कौन सा agent प्रतिक्रिया दे रहा है [Agent: coordinator]
Transfer विज़ुअलाइज़ेशन: Transfer घटनाओं को प्रदर्शित करता है 🔄 [Transfer requested to: billing_agent]
निर्बाध हैंडऑफ़: Transfer के तुरंत बाद लक्ष्य agent प्रतिक्रिया देता है
बातचीत का इतिहास: agent transfers में संदर्भ बनाए रखता है

Transfers का परीक्षण करना

यह सत्यापित करने के लिए कि आपका मल्टी-एजेंट सिस्टम सही ढंग से काम करता है:

agent नाम जांचें जब वे प्रतिक्रिया दें तो कोष्ठकों में दिखाई दें
transfer इंडिकेटर (🔄) देखें जब agents हैंडऑफ़ करते हैं
लक्ष्य agents से बिना दोबारा प्रॉम्प्ट किए तत्काल प्रतिक्रियाओं को सत्यापित करें
उचित रूटिंग सुनिश्चित करने के लिए विभिन्न अनुरोध प्रकारों का परीक्षण करें
गैर-मौजूदा agents में transferring जैसे एज मामलों की जांच करें

Transfer समस्याओं को डीबग करना

यदि transfers काम नहीं कर रहे हैं:

sub-agents को जोड़ा गया है .sub_agent() के माध्यम से सत्यापित करें
agent descriptions की जांच करें - LLM इनका उपयोग transfers तय करने के लिए करता है
निर्देशों की समीक्षा करें - parent को यह बताना चाहिए कि कब transfer करना है
agent नाम जांचें - transfer calls में बिल्कुल मेल खाना चाहिए
इवेंट स्ट्रीम में transfer actions देखने के लिए logging सक्षम करें

सर्वोत्तम अभ्यास

स्पष्ट Descriptions: LLM को अच्छे transfer निर्णय लेने में मदद करने के लिए वर्णनात्मक agent नाम और descriptions लिखें
विशिष्ट Instructions: प्रत्येक agent को उसकी भूमिका के लिए स्पष्ट, केंद्रित instructions दें
Global Instruction का उपयोग करें: सभी agents में लगातार व्यक्तित्व और संदर्भ निर्धारित करें
State Management: agent communication के लिए output_key और state variables का उपयोग करें
Hierarchy Depth सीमित करें: बेहतर रखरखाव के लिए hierarchies को उथला (2-3 स्तर) रखें
Transfer Logic का परीक्षण करें: सत्यापित करें कि agents विभिन्न अनुरोधों के लिए सही sub-agents को transfer करते हैं