कार्यप्रवाह एजेंट
कार्यप्रवाह एजेंट अनुमानित पैटर्न—अनुक्रमिक पाइपलाइनें, समानांतर निष्पादन, या पुनरावृत्तीय लूप—में कई एजेंट्स का समन्वय करते हैं। LlmAgent के विपरीत जो AI तर्क का उपयोग करता है, कार्यप्रवाह एजेंट नियतात्मक निष्पादन पथों का पालन करते हैं।
त्वरित शुरुआत
एक नया प्रोजेक्ट बनाएं:
cargo new workflow_demo
cd workflow_demoCargo.toml में निर्भरताएं जोड़ें:
[dependencies]
adk-rust = "0.2.0"
tokio = { version = "1.40", features = ["full"] }
dotenvy = "0.15".env फ़ाइल बनाएं:
echo 'GOOGLE_API_KEY=your-api-key' > .envSequentialAgent
SequentialAgent सब-एजेंट्स को एक के बाद एक चलाता है। प्रत्येक एजेंट पिछले एजेंट्स से संचित बातचीत का इतिहास देखता है।
कब उपयोग करें
- मल्टी-स्टेप पाइपलाइनें जहाँ आउटपुट अगले स्टेप में फीड होता है
- रिसर्च → एनालिसिस → समरी वर्कफ़्लो
- डेटा ट्रांसफ़ॉर्मेशन चेन
पूरा उदाहरण
src/main.rs को बदलें:
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")?);
// Step 1: Research agent gathers information
let researcher = LlmAgentBuilder::new("researcher")
.instruction("Research the given topic. List 3-5 key facts or points. \
Be factual and concise.")
.model(model.clone())
.output_key("research") // Saves output to state
.build()?;
// Step 2: Analyzer agent identifies patterns
let analyzer = LlmAgentBuilder::new("analyzer")
.instruction("Based on the research above, identify 2-3 key insights \
or patterns. What's the bigger picture?")
.model(model.clone())
.output_key("analysis")
.build()?;
// Step 3: Summarizer creates final output
let summarizer = LlmAgentBuilder::new("summarizer")
.instruction("Create a brief executive summary combining the research \
and analysis. Keep it under 100 words.")
.model(model.clone())
.build()?;
// Create the sequential pipeline
let pipeline = SequentialAgent::new(
"research_pipeline",
vec![Arc::new(researcher), Arc::new(analyzer), Arc::new(summarizer)],
).with_description("Research → Analyze → Summarize");
println!("📋 Sequential Pipeline: Research → Analyze → Summarize");
println!();
Launcher::new(Arc::new(pipeline)).run().await?;
Ok(())
}इसे चलाएँ:
cargo runउदाहरण इंटरैक्शन
You: Tell me about Rust programming language
🔄 [researcher] Researching...
Here are key facts about Rust:
1. Systems programming language created at Mozilla in 2010
2. Memory safety without garbage collection via ownership system
3. Zero-cost abstractions and minimal runtime
4. Voted "most loved language" on Stack Overflow for 7 years
5. Used by Firefox, Discord, Dropbox, and Linux kernel
🔄 [analyzer] Analyzing...
Key insights:
1. Rust solves the memory safety vs performance tradeoff
2. Strong developer satisfaction drives rapid adoption
3. Trust from major tech companies validates production-readiness
🔄 [summarizer] Summarizing...
Rust is a systems language that achieves memory safety without garbage
collection through its ownership model. Created at Mozilla in 2010, it's
been rated the most loved language for 7 consecutive years. Major companies
like Discord and Linux kernel adopt it for its zero-cost abstractions
and performance guarantees.यह कैसे काम करता है
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ रिसर्चर │ → │ एनालाइज़र │ → │ समराइज़र │
│ (स्टेप 1) │ │ (स्टेप 2) │ │ (स्टेप 3) │
└─────────────┘ └─────────────┘ └─────────────┘
↓ ↓ ↓
"मुख्य तथ्य..." "जानकारी..." "कार्यकारी सारांश"- उपयोगकर्ता संदेश पहले एजेंट (रिसर्चर) के पास जाता है
- रिसर्चर का जवाब इतिहास में जोड़ा जाता है
- एनालाइज़र देखता है: उपयोगकर्ता संदेश + रिसर्चर का जवाब
- समराइज़र देखता है: उपयोगकर्ता संदेश + रिसर्चर + एनालाइज़र के जवाब
- पाइपलाइन तब पूरी होती है जब अंतिम एजेंट समाप्त हो जाता है
ParallelAgent
ParallelAgent सभी सब-एजेंटों को समवर्ती रूप से चलाता है। प्रत्येक एजेंट समान इनपुट प्राप्त करता है और स्वतंत्र रूप से काम करता है।
कब उपयोग करें
- एक ही विषय पर कई दृष्टिकोण
- फैन-आउट प्रोसेसिंग (समान इनपुट, विभिन्न विश्लेषण)
- गति-महत्वपूर्ण मल्टी-टास्क परिदृश्य
पूर्ण उदाहरण
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")?);
// Three analysts with DISTINCT personas (important for parallel execution)
let technical = LlmAgentBuilder::new("technical_analyst")
.instruction("You are a senior software architect. \
FOCUS ONLY ON: code quality, system architecture, scalability, \
security vulnerabilities, and tech stack choices. \
Start your response with '🔧 TECHNICAL:' and give 2-3 bullet points.")
.model(model.clone())
.build()?;
let business = LlmAgentBuilder::new("business_analyst")
.instruction("You are a business strategist and MBA graduate. \
FOCUS ONLY ON: market opportunity, revenue model, competition, \
cost structure, and go-to-market strategy. \
Start your response with '💼 BUSINESS:' and give 2-3 bullet points.")
.model(model.clone())
.build()?;
let user_exp = LlmAgentBuilder::new("ux_analyst")
.instruction("You are a UX researcher and designer. \
FOCUS ONLY ON: user journey, accessibility, pain points, \
visual design, and user satisfaction metrics. \
Start your response with '🎨 UX:' and give 2-3 bullet points.")
.model(model.clone())
.build()?;
// Create parallel agent
let multi_analyst = ParallelAgent::new(
"multi_perspective",
vec![Arc::new(technical), Arc::new(business), Arc::new(user_exp)],
).with_description("Technical + Business + UX analysis in parallel");
println!("⚡ Parallel Analysis: Technical | Business | UX");
println!(" (All three run simultaneously!)");
println!();
Launcher::new(Arc::new(multi_analyst)).run().await?;
Ok(())
}💡 सुझाव:
ParallelAgentनिर्देशों को विशिष्ट व्यक्तित्वों, फ़ोकस क्षेत्रों और प्रतिक्रिया उपसर्गों के साथ अत्यधिक भिन्न बनाएं। यह सुनिश्चित करता है कि प्रत्येक एजेंट अद्वितीय आउटपुट उत्पन्न करता है।
उदाहरण बातचीत
You: Evaluate a mobile banking app
🔧 TECHNICAL:
• Requires robust API security: OAuth 2.0, certificate pinning, encrypted storage
• Offline mode with sync requires complex state management and conflict resolution
• Biometric auth integration varies significantly across iOS/Android platforms
💼 BUSINESS:
• Highly competitive market - need unique differentiator (neobanks, traditional banks)
• Revenue model: interchange fees, premium tiers, or lending products cross-sell
• Regulatory compliance costs significant: PCI-DSS, regional banking laws, KYC/AML
🎨 UX:
• Critical: fast task completion - check balance must be < 3 seconds
• Accessibility essential: screen reader support, high contrast mode, large touch targets
• Trust indicators important: security badges, familiar banking patternsयह कैसे काम करता है
┌─────────────────┐
│ User Message │
└────────┬────────┘
┌───────────────────┼───────────────────┐
↓ ↓ ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Technical │ │ Business │ │ UX │
│ Analyst │ │ Analyst │ │ Analyst │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
↓ ↓ ↓
(response 1) (response 2) (response 3)सभी एजेंट एक साथ शुरू होते हैं और उनके पूरा होने पर परिणाम स्ट्रीम होते हैं।
LoopAgent
LoopAgent उप-एजेंटों को बार-बार तब तक चलाता है जब तक कि बाहर निकलने की शर्त पूरी न हो जाए या अधिकतम पुनरावृत्तियाँ न पहुँच जाएं।
कब उपयोग करें
- पुनरावृत्तीय सुधार (ड्राफ्ट → आलोचना → सुधार → दोहराना)
- सुधार के साथ पुनः प्रयास तर्क
- गुणवत्ता द्वार जिनके लिए कई पास की आवश्यकता होती है
ExitLoopTool
किसी लूप से जल्दी बाहर निकलने के लिए, एक एजेंट को ExitLoopTool दें। जब इसे कॉल किया जाता है, तो यह लूप को रोकने का संकेत देता है।
पूर्ण उदाहरण
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")?);
// Critic agent evaluates content
let critic = LlmAgentBuilder::new("critic")
.instruction("Review the content for quality. Score it 1-10 and list \
specific improvements needed. Be constructive but critical.")
.model(model.clone())
.build()?;
// Refiner agent improves based on critique
let refiner = LlmAgentBuilder::new("refiner")
.instruction("Apply the critique to improve the content. \
If the score is 8 or higher, call exit_loop to finish. \
Otherwise, provide an improved version.")
.model(model.clone())
.tool(Arc::new(ExitLoopTool::new())) // Can exit the loop
.build()?;
// Create inner sequential: critic → refiner
let critique_refine = SequentialAgent::new(
"critique_refine_step",
vec![Arc::new(critic), Arc::new(refiner)],
);
// Wrap in loop with max 3 iterations
let iterative_improver = LoopAgent::new(
"iterative_improver",
vec![Arc::new(critique_refine)],
).with_max_iterations(3)
.with_description("Critique-refine loop (max 3 passes)");
println!("🔄 Iterative Improvement Loop");
println!(" critic → refiner → repeat (max 3x or until quality >= 8)");
println!();
Launcher::new(Arc::new(iterative_improver)).run().await?;
Ok(())
}उदाहरण इंटरैक्शन
You: Write a tagline for a coffee shop
🔄 Iteration 1
[critic] Score: 5/10. "Good coffee here" is too generic. Needs:
- Unique value proposition
- Emotional connection
- Memorable phrasing
[refiner] Improved: "Where every cup tells a story"
🔄 Iteration 2
[critic] Score: 7/10. Better! But could be stronger:
- More action-oriented
- Hint at the experience
[refiner] Improved: "Brew your perfect moment"
🔄 Iteration 3
[critic] Score: 8/10. Strong, action-oriented, experiential.
Minor: could be more distinctive.
[refiner] Score is 8+, quality threshold met!
[exit_loop called]
Final: "Brew your perfect moment"यह कैसे काम करता है
┌──────────────────────────────────────────┐
│ LoopAgent │
│ ┌────────────────────────────────────┐ │
│ │ SequentialAgent │ │
│ │ ┌──────────┐ ┌──────────────┐ │ │
→ │ │ │ Critic │ → │ Refiner │ │ │ →
│ │ │ (review) │ │ (improve or │ │ │
│ │ └──────────┘ │ exit_loop) │ │ │
│ │ └──────────────┘ │ │
│ └────────────────────────────────────┘ │
│ ↑_____________↓ │
│ repeat until exit │
└──────────────────────────────────────────┘ConditionalAgent (नियम-आधारित)
ConditionalAgent निष्पादन को तुल्यकालिक, नियम-आधारित शर्त पर आधारित करता है। इसका उपयोग नियतात्मक रूटिंग के लिए करें जैसे A/B परीक्षण या परिवेश-आधारित रूटिंग।
ConditionalAgent::new("router", |ctx| ctx.session().state().get("premium")..., premium_agent)
.with_else(basic_agent)ध्यान दें: LLM-आधारित इंटेलिजेंट रूटिंग के लिए,
LlmConditionalAgentका उपयोग करें।
LlmConditionalAgent (LLM-आधारित)
LlmConditionalAgent उपयोगकर्ता इनपुट को LLM का उपयोग करके वर्गीकृत करता है और उपयुक्त सब-एजेंट को रूट करता है। यह बुद्धिमत्तापूर्ण रूटिंग के लिए आदर्श है जहाँ रूटिंग निर्णय के लिए सामग्री को समझने की आवश्यकता होती है।
कब उपयोग करें
- इरादे का वर्गीकरण - उपयोगकर्ता क्या पूछ रहा है, उसके आधार पर रूट करें
- बहु-मार्ग रूटिंग - 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")?);
// Create specialist agents
let tech_agent: Arc<dyn Agent> = Arc::new(
LlmAgentBuilder::new("tech_expert")
.instruction("You are a senior software engineer. Be precise and technical.")
.model(model.clone())
.build()?
);
let general_agent: Arc<dyn Agent> = Arc::new(
LlmAgentBuilder::new("general_helper")
.instruction("You are a friendly assistant. Explain simply, use analogies.")
.model(model.clone())
.build()?
);
let creative_agent: Arc<dyn Agent> = Arc::new(
LlmAgentBuilder::new("creative_writer")
.instruction("You are a creative writer. Be imaginative and expressive.")
.model(model.clone())
.build()?
);
// LLM classifies the query and routes accordingly
let router = LlmConditionalAgent::new("smart_router", model.clone())
.instruction("Classify the user's question as exactly ONE of: \
'technical' (coding, debugging, architecture), \
'general' (facts, knowledge, how-to), \
'creative' (writing, stories, brainstorming). \
Respond with ONLY the category name.")
.route("technical", tech_agent)
.route("general", general_agent.clone())
.route("creative", creative_agent)
.default_route(general_agent)
.build()?;
println!("🧠 LLM-Powered Intelligent Router");
Launcher::new(Arc::new(router)).run().await?;
Ok(())
}उदाहरण इंटरेक्शन
You: How do I fix a borrow error in Rust?
[Routing to: technical]
[Agent: tech_expert]
A borrow error occurs when Rust's ownership rules are violated...
You: What's the capital of France?
[Routing to: general]
[Agent: general_helper]
The capital of France is Paris! It's a beautiful city...
You: Write me a haiku about the moon
[Routing to: creative]
[Agent: creative_writer]
Silver orb above,
Shadows dance on silent waves—
Night whispers secrets.यह कैसे काम करता है
┌─────────────────┐
│ उपयोगकर्ता संदेश│
└────────┬────────┘
↓
┌─────────────────┐
│ LLM वर्गीकृत करता है│ "technical" / "general" / "creative"
│ (smart_router)│
└────────┬────────┘
↓
┌────┴────┬──────────┐
↓ ↓ ↓
┌───────┐ ┌───────┐ ┌─────────┐
│ तकनीकी│ │सामान्य│ │रचनात्मक │
│विशेषज्ञ│ │सहायक │ │ लेखक │
└───────┘ └───────┘ └─────────┘वर्कफ़्लो Agent को जोड़ना
जटिल पैटर्न के लिए वर्कफ़्लो agent को नेस्ट किया जा सकता है।
Sequential + Parallel + Loop
use adk_rust::prelude::*;
use std::sync::Arc;
// 1. Parallel analysis from multiple perspectives
let parallel_analysis = ParallelAgent::new(
"multi_analysis",
vec![Arc::new(tech_analyst), Arc::new(biz_analyst)],
);
// 2. Synthesize the parallel results
let synthesizer = LlmAgentBuilder::new("synthesizer")
.instruction("Combine all analyses into a unified recommendation.")
.model(model.clone())
.build()?;
// 3. Quality loop: critique and refine
let quality_loop = LoopAgent::new(
"quality_check",
vec![Arc::new(critic), Arc::new(refiner)],
).with_max_iterations(2);
// Final pipeline: parallel → synthesize → quality loop
let full_pipeline = SequentialAgent::new(
"full_analysis_pipeline",
vec![
Arc::new(parallel_analysis),
Arc::new(synthesizer),
Arc::new(quality_loop),
],
);वर्कफ़्लो निष्पादन का Tracing
यह देखने के लिए कि किसी वर्कफ़्लो के अंदर क्या हो रहा है, tracing को सक्षम करें:
use adk_rust::prelude::*;
use adk_rust::runner::{Runner, RunnerConfig};
use adk_rust::futures::StreamExt;
use std::sync::Arc;
// Create pipeline as before...
// Use Runner instead of Launcher for detailed control
let session_service = Arc::new(InMemorySessionService::new());
let runner = Runner::new(RunnerConfig {
app_name: "workflow_trace".to_string(),
agent: Arc::new(pipeline),
session_service: session_service.clone(),
artifact_service: None,
memory_service: None,
run_config: None,
})?;
let session = session_service.create(CreateRequest {
app_name: "workflow_trace".to_string(),
user_id: "user".to_string(),
session_id: None,
state: Default::default(),
}).await?;
let mut stream = runner.run(
"user".to_string(),
session.id().to_string(),
Content::new("user").with_text("Analyze Rust"),
).await?;
// Process each event to see workflow execution
while let Some(event) = stream.next().await {
let event = event?;
// Show which agent is responding
println!("📍 Agent: {}", event.author);
// Show the response content
if let Some(content) = event.content() {
for part in &content.parts {
if let Part::Text { text } = part {
println!(" {}", text);
}
}
}
println!();
}API संदर्भ
SequentialAgent
SequentialAgent::new("name", vec![agent1, agent2, agent3])
.with_description("Optional description")
.before_callback(callback) // Called before execution
.after_callback(callback) // Called after executionParallelAgent
ParallelAgent::new("name", vec![agent1, agent2, agent3])
.with_description("Optional description")
.before_callback(callback)
.after_callback(callback)LoopAgent
LoopAgent::new("name", vec![agent1, agent2])
.with_max_iterations(5) // Safety limit (recommended)
.with_description("Optional description")
.before_callback(callback)
.after_callback(callback)ConditionalAgent
ConditionalAgent::new("name", |ctx| condition_fn, if_agent)
.with_else(else_agent) // Optional else branch
.with_description("Optional description")ExitLoopTool
// Add to an agent to let it exit a LoopAgent
.tool(Arc::new(ExitLoopTool::new()))पिछला: LlmAgent | अगला: मल्टी-Agent सिस्टम →