एक्शन नोड

adk-action क्रेट ग्राफ़-आधारित वर्कफ़्लो में उपयोग किए जाने वाले 14 एक्शन नोड प्रकारों को परिभाषित करता है। प्रत्येक नोड प्रकार एक विशिष्ट ऑपरेशन (HTTP कॉल, डेटा रूपांतरण, सशर्त शाखा आदि) का प्रतिनिधित्व करता है, जिसे adk-graph के ActionNodeExecutor के माध्यम से निर्देशित ग्राफ़ में संयोजित किया जा सकता है।

अवलोकन

एक्शन नोड दृश्य और प्रोग्रामेटिक वर्कफ़्लो ग्राफ़ के मूलभूत घटक हैं। वे निम्नलिखित सुविधाएँ प्रदान करते हैं:

• टाइप किए गए ऑपरेशन — सामान्य वर्कफ़्लो पैटर्न को कवर करने वाले 14 नोड प्रकार
• StandardProperties — त्रुटि प्रबंधन, ट्रेसिंग और डेटा मैपिंग के लिए साझा कॉन्फ़िगरेशन
• वेरिएबल इंटरपोलेशन — डायनेमिक मानों के लिए {{variable}} सिंटैक्स
• ग्राफ़ एकीकरण — adk-graph के ActionNodeExecutor द्वारा निष्पादित

इंस्टॉलेशन

[dependencies]
adk-action = "2.1.0"

# Or specific action features via umbrella crate
adk-rust = { version = "2.1.0", features = ["action"] }

नोड प्रकार (14)

ग्राफ़ बनाए जाने पर उपलब्धता की जाँच की जाती है

कुछ नोड प्रकार ऐसे कॉन्फ़िगरेशन स्वीकार और सत्यापित करते हैं, जबकि उनका बैकएंड मौजूद नहीं होता।
उन्हें रन के बीच में नहीं, बल्कि StateGraph::compile() द्वारा अस्वीकार कर दिया जाता है:

अस्वीकृति में नोड और कारण का नाम दिया जाता है, इसलिए जो वर्कफ़्लो चल नहीं सकता, वह पहले के नोड्स के साइड इफ़ेक्ट उत्पन्न करने के बाद नहीं, बल्कि असेंबल किए जाते समय ही विफल हो जाता है।

कस्टम नोड पर Node::validate लागू करके उसे उसी जाँच में भाग लेने योग्य बनाएँ।

StandardProperties

हर एक्शन नोड में StandardProperties होता है — साझा कॉन्फ़िगरेशन जो निष्पादन व्यवहार को नियंत्रित करता है:

use adk_action::{StandardProperties, ErrorHandling, RetryConfig};

let props = StandardProperties::builder()
    // Error handling
    .on_error(ErrorHandling::ContinueOnFail)
    .retry(RetryConfig {
        max_attempts: 3,
        wait_between_ms: 1000,
    })

    // Tracing
    .notes("Fetch user profile from API")

    // Callbacks
    .on_success("notify_complete")
    .on_failure("alert_team")

    // Execution
    .timeout_ms(30_000)
    .continue_on_fail(true)

    // Input/output mapping
    .input_mapping("{{trigger.body.user_id}}")
    .output_key("user_profile")

    .build();

StandardProperties फ़ील्ड્સ

चर प्रतिस्थापन

Action नोड workflow state का संदर्भ देने के लिए {{variable}} सिंटैक्स का समर्थन करते हैं:

use adk_action::HttpNode;

let node = HttpNode::builder()
    .url("https://api.example.com/users/{{trigger.body.user_id}}")
    .method("GET")
    .headers(vec![
        ("Authorization".into(), "Bearer {{env.API_TOKEN}}".into()),
    ])
    .build();

चर स्रोत

नेस्टेड एक्सेस में डॉट नोटेशन का उपयोग होता है: {{nodes.http_1.json.data[0].id}}

नोड के उदाहरण

HTTP नोड

use adk_action::{HttpNode, HttpMethod};

let node = HttpNode::builder()
    .method(HttpMethod::Post)
    .url("https://api.example.com/orders")
    .headers(vec![
        ("Content-Type".into(), "application/json".into()),
    ])
    .body(r#"{"item": "{{trigger.body.item}}", "qty": {{trigger.body.quantity}}}"#)
    .properties(StandardProperties::builder()
        .timeout_ms(10_000)
        .on_error(ErrorHandling::RetryThenFail)
        .retry(RetryConfig { max_attempts: 3, wait_between_ms: 2000 })
        .output_key("order_response")
        .build())
    .build();

स्विच नोड

use adk_action::{SwitchNode, SwitchCase};

let node = SwitchNode::builder()
    .cases(vec![
        SwitchCase {
            condition: "{{nodes.classify.json.category}} == 'urgent'".into(),
            output: "urgent_path".into(),
        },
        SwitchCase {
            condition: "{{nodes.classify.json.category}} == 'normal'".into(),
            output: "normal_path".into(),
        },
    ])
    .fallback("default_path")
    .build();

लूप नोड

use adk_action::{LoopNode, LoopMode};

let node = LoopNode::builder()
    .mode(LoopMode::ForEach {
        items: "{{nodes.fetch_users.json.users}}".into(),
        item_var: "current_user".into(),
    })
    .body_nodes(vec!["process_user", "save_result"])
    .properties(StandardProperties::builder()
        .notes("Process each user in the list")
        .build())
    .build();

सेट नोड

use adk_action::SetNode;

let node = SetNode::builder()
    .assignments(vec![
        ("status".into(), "processing".into()),
        ("started_at".into(), "{{workflow.timestamp}}".into()),
        ("user_email".into(), "{{trigger.body.email}}".into()),
    ])
    .build();

adk-graph के साथ एकीकरण

एक्शन नोड्स को adk-graph के ActionNodeExecutor द्वारा निष्पादित किया जाता है:

use adk_graph::{Graph, ActionNodeExecutor};
use adk_action::{TriggerNode, HttpNode, SetNode};

// Define nodes
let trigger = TriggerNode::webhook("order_received");
let fetch = HttpNode::get("https://api.example.com/inventory/{{trigger.body.sku}}");
let update = SetNode::new(vec![("available", "{{nodes.fetch.json.quantity}}")]);

// Build graph
let graph = Graph::builder()
    .node("trigger", trigger)
    .node("check_inventory", fetch)
    .node("update_status", update)
    .edge("trigger", "check_inventory")
    .edge("check_inventory", "update_status")
    .build()?;

// Execute
let executor = ActionNodeExecutor::new();
let result = executor.run(graph, initial_context).await?;

कस्टम नोड प्रकार परिभाषित करना

ActionNode trait को लागू करें:

use adk_action::{ActionNode, ActionContext, ActionResult, StandardProperties};
use async_trait::async_trait;

struct CustomNode {
    config: MyConfig,
    properties: StandardProperties,
}

#[async_trait]
impl ActionNode for CustomNode {
    fn node_type(&self) -> &str { "custom" }
    fn properties(&self) -> &StandardProperties { &self.properties }

    async fn execute(&self, ctx: &ActionContext) -> ActionResult {
        let input = ctx.resolve("{{trigger.body.data}}")?;
        // Custom logic...
        Ok(serde_json::json!({ "result": "processed" }))
    }
}

संबंधित

• ग्राफ एजेंट — ग्राफ़ वर्कफ़्लो ऑर्केस्ट्रेशन
• स्टूडियो एक्शन नोड्स — ADK Studio में विज़ुअल नोड एडिटर
• ट्रिगर्स — वर्कफ़्लो ट्रिगर प्रकार

---

पिछला: ← Retry & Reflect | अगला: Plugins →