पुनः प्रयास और चिंतन

adk-retry-reflect क्रेट एक प्लगइन प्रदान करता है जो टूल विफलताओं को रोकता है, LLM संदर्भ में चिंतन प्रॉम्प्ट सम्मिलित करता है, और घातीय बैकऑफ़ के साथ पुनः प्रयास करता है। इससे एजेंट क्षणिक त्रुटियों या गलत रूप से बनाए गए टूल कॉल के बाद स्वयं को सुधार सकते हैं।

अवलोकन

जब कोई टूल कॉल विफल होता है, तो डिफ़ॉल्ट व्यवहार त्रुटि को LLM को लौटाना और उसे यह तय करने देना है कि क्या करना है। Retry & Reflect प्लगइन संरचित पुनर्प्राप्ति जोड़ता है:

1. LLM तक पहुँचने से पहले टूल विफलता को रोकता है
2. मॉडल से यह विश्लेषण करने के लिए कहने वाला चिंतन प्रॉम्प्ट सम्मिलित करता है कि क्या गलत हुआ
3. सुधारे गए तर्कों के साथ टूल कॉल का पुनः प्रयास करता है
4. विफलताएँ जारी रहने पर घातीय रूप से बैकऑफ़ करता है
5. अनंत लूप को रोकने के लिए बार-बार होने वाली विफलताओं के बाद सर्किट तोड़ता है

इंस्टॉलेशन

[dependencies]
adk-retry-reflect = "2.1.0"

# Or via umbrella crate (included in standard tier)
adk-rust = { version = "2.1.0", features = ["standard"] }

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

use adk_retry_reflect::RetryReflectPlugin;
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

let plugin = RetryReflectPlugin::builder()
    .max_retries(3)
    .initial_backoff_ms(500)
    .backoff_multiplier(2.0)
    .build();

let agent = LlmAgentBuilder::new("resilient_agent")
    .model(model)
    .instruction("You are a helpful assistant with access to external APIs.")
    .tool(Arc::new(flaky_api_tool))
    .plugin(Arc::new(plugin))
    .build()?;

कॉन्फ़िगरेशन

use adk_retry_reflect::{RetryReflectPlugin, RetryReflectConfig};

let plugin = RetryReflectPlugin::builder()
    // Retry settings
    .max_retries(3)                    // Maximum retry attempts [default: 3]
    .initial_backoff_ms(500)           // First retry delay in ms [default: 500]
    .backoff_multiplier(2.0)           // Multiply delay each retry [default: 2.0]
    .max_backoff_ms(30_000)            // Cap delay at this value [default: 30000]

    // Circuit breaker
    .circuit_breaker_threshold(5)      // Open circuit after N failures [default: 5]
    .circuit_breaker_reset_ms(60_000)  // Reset circuit after this duration [default: 60000]

    // Reflection
    .reflection_prompt(                // Custom reflection prompt template
        "The tool '{tool_name}' failed with: {error}. \
         Analyze what went wrong and provide corrected arguments."
    )

    // Scope
    .include_tools(&["api_call", "db_query"])  // Only retry these tools
    .exclude_tools(&["exit_loop"])             // Never retry these tools

    .build();

कॉन्फ़िगरेशन संदर्भ

सर्किट ब्रेकर

सर्किट ब्रेकर तब अनंत पुनःप्रयास लूप को रोकता है, जब कोई टूल लगातार विफल हो रहा हो:

Closed (normal) ─── failure count >= threshold ──→ Open (all calls fail fast)
       ↑                                                    │
       └──────── reset_ms elapsed, next call succeeds ──────┘
                              (Half-Open)

जब सर्किट खुला हो:

• टूल कॉल सर्किट-ब्रेकर त्रुटि के साथ तुरंत विफल हो जाते हैं
• कोई पुनःप्रयास नहीं किया जाता
• circuit_breaker_reset_ms के बाद, अगली कॉल को आगे जाने की अनुमति दी जाती है (हाफ-ओपन)
• यदि यह सफल होती है, तो सर्किट बंद हो जाता है; यदि यह विफल होती है, तो सर्किट खुला रहता है

रिफ्लेक्शन कैसे काम करता है

जब कोई टूल कॉल विफल होती है, तो प्लगइन बातचीत में एक रिफ्लेक्शन प्रॉम्प्ट सम्मिलित करता है:

[User]: What's the weather in NYC?
[Model]: *calls get_weather({"city": "nyc", "units": "kelvin"})*
[Tool Error]: Invalid units. Supported: celsius, fahrenheit
[Plugin injects]: The tool 'get_weather' failed with: "Invalid units. 
    Supported: celsius, fahrenheit". Analyze what went wrong and provide 
    corrected arguments.
[Model]: *calls get_weather({"city": "NYC", "units": "celsius"})*
[Tool Success]: {"temperature": 22, "condition": "sunny"}

रिफ्लेक्शन प्रॉम्प्ट LLM को विफलता के बारे में स्पष्ट संदर्भ देता है, ताकि वह उसी गलती को दोहराने के बजाय स्वयं सुधार कर सके।

कब उपयोग करें

अच्छा विकल्प:

• ऐसे टूल जो क्षणिक विफलताओं वाले बाहरी APIs को कॉल करते हैं
• ऐसे टूल जहाँ LLM थोड़े गलत तर्क प्रदान कर सकता है
• ऐसे डेटाबेस क्वेरी जो कनेक्शन संबंधी समस्याओं के कारण विफल हो सकती हैं
• नेटवर्क स्टोरेज पर फ़ाइल संचालन

अच्छा विकल्प नहीं:

• ऐसे टूल जो नियतात्मक रूप से खराब हैं (इसके बजाय टूल को ठीक करें)
• लंबे समय तक चलने वाले टूल, जहाँ पुनःप्रयास महँगे होते हैं
• ऐसे टूल जिनके साइड इफ़ेक्ट इडेम्पोटेंट नहीं हैं (जैसे, ईमेल भेजना)
• exit_loop जैसे नियंत्रण-प्रवाह टूल

अन्य प्लगइनों के साथ संयोजन

Retry & Reflect प्लगइन प्राथमिकता क्रम का सम्मान करता है:

use adk_plugin::PluginManager;

let agent = LlmAgentBuilder::new("agent")
    .model(model)
    .plugin(Arc::new(logging_plugin))         // Priority 1 (runs first)
    .plugin(Arc::new(retry_reflect_plugin))   // Priority 2
    .plugin(Arc::new(guardrail_plugin))       // Priority 3 (runs last)
    .build()?;

अवलोकनीयता

प्लगइन पुनःप्रयास के प्रयासों के लिए ट्रेसिंग स्पैन उत्सर्जित करता है:

WARN adk_retry_reflect: tool call failed, retrying
    tool_name=get_weather attempt=1 max=3 backoff_ms=500
    error="Invalid units"

INFO adk_retry_reflect: retry succeeded
    tool_name=get_weather attempt=2

WARN adk_retry_reflect: circuit breaker opened
    tool_name=broken_api failures=5 reset_ms=60000

संबंधित

• प्लगइन्स — प्लगइन सिस्टम आर्किटेक्चर
• फ़ंक्शन टूल्स — टूल बनाना
• मूल्यांकन — एजेंट की लचीलापन क्षमता का परीक्षण

---

पिछला: ← ACP टूल्स | अगला: एक्शन नोड्स →