ग्राफ़ वर्कफ़्लो (अल्ट्रा-रिव्यू)

एकल एजेंट लूप से परे किसी भी चीज़ के लिए — समानांतर समीक्षक, विरोधी जाँच, बहु-स्तरीय पाइपलाइन — कोडिंग एजेंटों को एक adk-graph StateGraph के रूप में व्यवस्थित करें। ultracode कमांड और coding_graph उदाहरण इसी तरह काम करते हैं।

"अल्ट्रा" पैटर्न

  START → implement ──┬─▶ review:correctness ─┐
                      ├─▶ review:edge-cases  ─┤   (parallel, real agents)
                      └─▶ review:style       ─┤
                                               ▼
                                         synthesize   ← deferred fan-in (runs once)
                                               │
                            decision ──────────┤
                        ┌── "revise" ◀──────────┘
                        ▼                       └──▶ "finalize" → END
                     revise ─▶ (back to the reviewers)

• implement / revise पूर्ण CodingAgents (read/write/bash) हैं।
• प्रत्येक reviewer एक रीड-ओनली LlmAgent है जो कोड का निरीक्षण करता है और नोट्स के साथ एक VERDICT: approve या VERDICT: changes लौटाता है।
• synthesize निर्णयों को एकत्रित करता है और revise या finalize पर रूट करता है, जो एक राउंड कैप + ग्राफ़ रिकर्सन लिमिट द्वारा सीमित होता है।

adk-graph में Fan-out / fan-in

दो adk-graph क्षमताएँ इसे सही बनाती हैं:

• Parallel fan-out — एक अपस्ट्रीम नोड से पहुँच योग्य कई नोड एक ही super-step में समवर्ती रूप से चलते हैं।
• Fan-in barrier — add_deferred_node_fn के साथ घोषित एक नोड ठीक एक बार चलता है, केवल सभी अपस्ट्रीम पाथ पूरे होने के बाद (प्रति अपस्ट्रीम एक बार नहीं)।

use adk_graph::graph::StateGraph;
use adk_graph::{DeferredNodeConfig, MergeStrategy};
use adk_graph::edge::{START, END};

let graph = StateGraph::with_channels(&["task", "round", "decision", "notes",
                                        "rev_correctness", "rev_edge-cases", "rev_style"])
    .add_node_fn("implement", /* coding agent */)
    .add_node_fn("review_correctness", /* read-only reviewer */)
    .add_node_fn("review_edge-cases",  /* … */)
    .add_node_fn("review_style",       /* … */)
    // fan-in: runs once, after all three reviewers finish
    .add_deferred_node_fn("synthesize", /* aggregate verdicts */,
        DeferredNodeConfig { merge_strategy: MergeStrategy::Collect, fan_in_timeout: None })
    .add_node_fn("revise", /* coding agent applies notes */)
    .add_node_fn("finalize", /* done */)
    .add_edge(START, "implement")
    .add_edge("implement", "review_correctness")
    .add_edge("implement", "review_edge-cases")
    .add_edge("implement", "review_style")
    .add_edge("revise", "review_correctness")     // loop fans out again
    .add_edge("revise", "review_edge-cases")
    .add_edge("revise", "review_style")
    .add_edge("review_correctness", "synthesize") // fan-in
    .add_edge("review_edge-cases", "synthesize")
    .add_edge("review_style", "synthesize")
    .add_conditional_edges("synthesize",
        |s| s.get("decision").and_then(|v| v.as_str()).unwrap_or("finalize").to_string(),
        [("revise", "revise"), ("finalize", "finalize")])
    .add_edge("finalize", END)
    .compile()?
    .with_recursion_limit(16);

add_deferred_node_fn (और कस्टम नोड्स के लिए mark_deferred) कोर StateGraph बिल्डर में fan-in लाता है — पहले केवल उच्च-स्तरीय GraphAgentBuilder ही एक डिफर्ड नोड घोषित कर सकता था। इसके बिना, कई अपस्ट्रीम एजेस वाला एक एग्रीगेटर पहली ब्रांच के समाप्त होते ही सक्रिय हो जाता।

प्रत्येक नोड एक async क्लोजर है जो एक एजेंट चलाता है और उसके परिणाम को ग्राफ़ स्टेट में लिखता है; कंडीशनल एज लूप करने या समाप्त करने के लिए decision पढ़ता है। सामान्य API के लिए coding_graph उदाहरण और Graph Agents संदर्भ में पूर्ण, चलने योग्य कार्यान्वयन देखें।

ग्राफ़ बनाम हार्नेस का उपयोग कब करें

• Single agent, linear/iterative work → केवल एक CodingAgent (code / goal कमांड)।
• Parallel specialists, multi-stage review, adversarial refutation, swarms → एक adk-graph वर्कफ़्लो (ultracode कमांड)।

अगला: उदाहरण →