GuidesOneMux

सीमित निष्पादन और विफलता से उबरने के साथ LangGraph Tool Calling

अनिश्चितकालीन निष्पादन के बजाय tool calling, retry budget, मानव अनुमोदन और स्पष्ट recovery paths का उपयोग करके LangGraph production-operations agent बनाएं।

AI

सारांश · TL;DR

Production operations agent को बार-बार अनिश्चितकाल तक retry करने या बिना सोचे-समझे side effects दोहराने की अनुमति नहीं होनी चाहिए। LangGraph निष्पादन को रोकने के लिए graph और persistence model देता है, जबकि आपके workflow में retry budget, idempotency नियम, escalation paths और recovery states तय होने चाहिए। HumanInTheLoopMiddleware जोखिमपूर्ण tool calls पर रोक लगा सकता है और अनुमोदन, संपादन, अस्वीकृति या सीधे जवाब के बाद checkpoint से उन्हें फिर शुरू कर सकता है।

मुख्य बातें

  • Retry करने का निर्णय लेने से पहले अस्थायी और स्थायी विफलताओं में अंतर करें।
  • हर tool के retry budget और graph-स्तर की step limit—दोनों से निष्पादन सीमित रखें।
  • Production संसाधन बनाने, हटाने या बदलने वाले tools के लिए idempotency keys का उपयोग करें।
  • विनाशकारी या बाहरी रूप से दिखाई देने वाली कार्रवाइयों को मानव अनुमोदन के अधीन रखें।
  • Graph state को persist करें, ताकि रुका हुआ workflow शुरुआत से दोबारा शुरू किए बिना आगे बढ़ सके।
इस पृष्ठ पर (9)

डिज़ाइन का निर्णय: अपने-आप retry करें या सोच-समझकर recovery करें?

Production workflow operations के लिए सबसे सुरक्षित डिफ़ॉल्ट यह नहीं है कि “हर विफलता पर retry करें।” इसके बजाय:

  1. केवल उन्हीं errors पर retry करें जिनके अस्थायी होने की संभावना हो।
  2. प्रयासों की छोटी और स्पष्ट सीमा तय करके उसके बाद रुक जाएँ।
  3. जिन कामों के प्रयास पूरे हो चुके हों या जिनका परिणाम अस्पष्ट हो, उन्हें recovery state में भेजें।
  4. ऐसे side effects से पहले अनुमोदन लें जो महँगे या अपरिवर्तनीय हो सकते हैं।

LangGraph इसके लिए अच्छा विकल्प है, क्योंकि workflow इन नतीजों को एक बड़े agent loop के भीतर छिपाने के बजाय graph states के रूप में दिखा सकता है। Model tool calls सुझा सकता है, लेकिन deterministic code तय करता है कि call को चलाना, retry करना, escalate करना या छोड़ना सुरक्षित है या नहीं।

नीचे दिए गए उदाहरण केवल समझाने के लिए हैं। ये किसी परीक्षण किए गए application का हिस्सा नहीं हैं, और आपके इंस्टॉल किए गए LangGraph तथा LangChain versions के अनुसार सटीक APIs अलग हो सकती हैं।

पूर्वापेक्षाएँ

आपको चाहिए:

  • Python और उसके अनुरूप LangGraph तथा LangChain packages।
  • ऐसा chat model जो आपके चुने हुए integration के ज़रिए tool calling का समर्थन करता हो।
  • स्पष्ट input schemas और अनुमानित error types वाले tools।
  • एक checkpointer। प्रयोगों के लिए InMemorySaver उपयुक्त है; LangGraph documentation production के लिए AsyncPostgresSaver या MongoDBSaver जैसे persistent checkpointer की अनुशंसा करता है।
  • हर workflow execution के लिए एक स्थिर thread_id।

Model को production credentials का असीमित access न दें। Authorization, validation, idempotency और retry policy को tools या middleware के भीतर लागू करें।

सीमित और retry योग्य tool परिभाषित करें

पहली सीमा खुद operation के इर्द-गिर्द होनी चाहिए। यह उदाहरण केवल वर्गीकृत अस्थायी error पर retry करता है और budget समाप्त होने पर एक structured result लौटाता है।

from dataclasses import dataclass
from typing import Literal

class TransientOperationError(Exception):
    pass

class PermanentOperationError(Exception):
    pass

@dataclass
class OperationResult:
    status: Literal["succeeded", "needs_recovery", "failed"]
    attempts: int
    message: str


def run_with_budget(operation, *, max_attempts: int) -> OperationResult:
    for attempt in range(1, max_attempts + 1):
        try:
            operation()
            return OperationResult("succeeded", attempt, "Operation completed")
        except PermanentOperationError as exc:
            return OperationResult("failed", attempt, str(exc))
        except TransientOperationError as exc:
            if attempt == max_attempts:
                return OperationResult(
                    "needs_recovery", attempt,
                    f"Retry budget exhausted: {exc}",
                )

    return OperationResult("needs_recovery", max_attempts, "No attempt was made")

वास्तविक operations में retry करने से पहले idempotency key जोड़ें। Deploy request के बाद timeout होने का अर्थ यह नहीं है कि deploy हुआ ही नहीं। बिना key के retry करने पर duplicate job, ticket, payment या change request बन सकता है।

उपयोगी policy table कुछ इस तरह दिखती है:

Failure classAutomatic actionRecovery action
अस्थायी network timeoutतय सीमा के भीतर retry करेंoperation ID के साथ escalate करें
Rate limitprovider के निर्देश के अनुसार retry करेंworkflow को queue में रखें या टालें
अमान्य argumentsretry न करेंagent को validation error लौटाएँ
Permission failureretry न करेंauthorization माँगें या रुक जाएँ
Timeout के बाद अज्ञात परिणामबिना जाँच दोबारा न चलाएँidempotency key से status जाँचें

Tool calling और मानव अनुमोदन जोड़ें

LangChain का create_agent अंदरूनी तौर पर LangGraph execution का उपयोग करता है। दिए गए LangGraph documentation में HumanInTheLoopMiddleware का वर्णन है, जो चुने हुए tool calls को रोक सकता है और persisted state से फिर शुरू कर सकता है।

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="provider:model-name",
    tools=[inspect_job, restart_job, delete_artifact],
    middleware=[
        HumanInTheLoopMiddleware(
            interrupt_on={
                "inspect_job": False,
                "restart_job": {
                    "allowed_decisions": ["approve", "reject"]
                },
                "delete_artifact": {
                    "allowed_decisions": ["approve", "edit", "reject"]
                },
            },
            interrupt_mode="per_call",
        ),
    ],
    checkpointer=InMemorySaver(),
)

यहाँ निरीक्षण बिना समीक्षा के चलता है, जबकि restart और deletion पर निर्णय आने तक विराम लगता है। approve मूल arguments के साथ कार्रवाई करता है, edit निष्पादन से पहले arguments बदलता है, और reject call को छोड़कर agent को अस्वीकृति की जानकारी लौटाता है। Source में “ask user” tool की तरह काम करने के लिए respond का भी उल्लेख है; side effect करने वाले tool को अस्वीकार करने के लिए इसका उपयोग नहीं करना चाहिए, क्योंकि इसे सफल tool result माना जाता है।

Production में in-memory checkpointer की जगह persistent implementation इस्तेमाल करें और agent को स्थिर thread ID के साथ invoke करें:

config = {
    "configurable": {"thread_id": "ops-workflow-1842"}
}

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "Inspect the failed job and restart it if safe.",
            }
        ]
    },
    config=config,
    version="v2",
)

Version v2 में, interrupt हुए result में interrupts collection उपलब्ध होती है। हर अनुरोधित कार्रवाई किसी अधिकृत reviewer को दिखाएँ, फिर दस्तावेज़ित Command decision format का उपयोग करके उसी thread को resume करें।

Retry और अनुमोदन सही क्रम में रखें

Source documentation middleware के एक अहम नियम की ओर ध्यान दिलाता है: per-call review का उपयोग करते समय human-in-the-loop handling को tool retry या error-handling middleware से पहले रखें। अन्यथा retry होने पर reviewer से फिर पूछा जा सकता है, या अमान्य उत्तर को tool failure मानकर retry किया जा सकता है।

अपेक्षित क्रम यह है:

  1. Model tool call का प्रस्ताव देता है।
  2. Policy जाँचती है कि समीक्षा आवश्यक है या नहीं।
  3. Reviewer call को approve, edit या reject करता है।
  4. Tool अपनी सीमित retry policy के साथ चलता है।
  5. सफलता agent को लौटती है; प्रयासों की सीमा समाप्त होने पर recovery शुरू होती है।

ऐसे middleware में side effects न करें जो interrupt resume होने पर फिर चलता है। Documentation विशेष रूप से चेतावनी देता है कि human-review layer से पहले चलने वाला middleware pause होने तक दोबारा प्रवेश किए जाने पर भी सुरक्षित होना चाहिए।

एक और retry के बजाय recovery state जोड़ें

Retry budget समाप्त होने के बाद workflow ID, tool name, प्रयासों की संख्या, idempotency key और आखिरी ज्ञात error वाला operational event दर्ज करें। फिर इन तीन रास्तों में से एक चुनें:

  • सत्यापन: बाहरी system से पूछें कि मूल operation सफल हुआ था या नहीं।
  • Escalate करें: पर्याप्त संदर्भ के साथ operator से अगला कदम तय करने के लिए रुकें।
  • Compensate करें: अलग, स्पष्ट रूप से अनुमोदित corrective operation चलाएँ।

अधूरे error message के आधार पर model से compensating action गढ़ने को न कहें। उसे structured status data दें और उपलब्ध tools सीमित रखें।

Graph-स्तर की execution limit सुरक्षा की दूसरी सीमा है। अपने इंस्टॉल किए गए LangGraph version द्वारा समर्थित limit सेट करें और उसके पूरा होने को चुपचाप जारी रखने के बजाय recovery event मानें। इससे model-tool loop अनियंत्रित production process नहीं बनता।

Troubleshooting checklist

  • Workflow शुरुआत से फिर चल पड़ता है: जाँचें कि persistent checkpointer और वही thread_id इस्तेमाल हो रहे हैं।
  • अस्वीकृत कार्रवाई फिर भी चलती है: जाँचें कि resume decision respond नहीं, बल्कि rejection है।
  • Reviewer को बहुत ज़्यादा अनुरोध दिखते हैं: when predicates में arguments के आधार पर शर्तें जोड़ें, ताकि केवल जोखिमपूर्ण calls पर interrupt हो।
  • Retry से काम दोहर जाता है: idempotency जोड़ें और अज्ञात नतीजों पर retry करने से पहले status-check tool चलाएँ।
  • वही समीक्षा बार-बार दिखाई देती है: middleware का क्रम जाँचें और सुनिश्चित करें कि retry handling approval boundary को गलत तरीके से wrap न करे।
  • Edited call अप्रत्याशित ढंग से काम करती है: edited arguments को स्वयं validate करें; दस्तावेज़ित response schema उनका स्वरूप बताता है, लेकिन ज़रूरी नहीं कि वह business safety लागू करे।

निष्कर्ष

एक भरोसेमंद LangGraph operations agent सीमित workflow होता है, न कि बिना रोक-टोक चलने वाला chatbot। हर tool के लिए retry budget तय करें, failures का वर्गीकरण करें, state persist करें, खतरनाक calls पर रोक रखें और recovery को स्पष्ट branch बनाएँ। इस तरह मानव अनुमोदन workflow में एक नियंत्रित checkpoint बनता है, न कि आपातकालीन उपाय।

स्रोत

सामान्य प्रश्न

क्या LangGraph हर विफल tool call को अपने-आप retry करता है?

ऐसा न मानें। Retry का व्यवहार स्पष्ट रूप से तय करें, errors का वर्गीकरण करें और प्रयासों की अधिकतम संख्या लागू करें। आपके इंस्टॉल किए गए stack में tool retry middleware उपलब्ध हो सकता है, लेकिन उसकी configuration और व्यवहार को version के अनुसार documentation में जाँचना चाहिए।

मानव अनुमोदन के लिए checkpointing क्यों आवश्यक है?

निर्णय लंबित रहने पर interrupt निष्पादन रोक देता है। Checkpointer graph state को सुरक्षित रखता है, ताकि अनुमोदन, संपादन, अस्वीकृति या सीधे जवाब के बाद वही workflow thread फिर शुरू किया जा सके।

किस स्थिति में tool call के लिए मानव समीक्षा आवश्यक है?

उन calls की समीक्षा करें जो production state बदलती हैं, data हटाती हैं, बाहरी संदेश भेजती हैं या जिनकी लागत अथवा दायरा अनिश्चित है। Read-only निरीक्षण अक्सर अपने-आप चल सकता है, बशर्ते उसका authorization और output limit स्पष्ट हो।

Retry budget समाप्त होने पर क्या होना चाहिए?

Recovery path पर जाएँ: बाहरी operation की पुष्टि करें, operator को escalate करें या अलग से अनुमोदित compensating action चलाएँ। जिस operation का परिणाम अज्ञात हो, उसे बिना जाँच दोहराने से बचें।

संबंधित लेख

Guides

LangGraph Agentic RAG: टूल कॉलिंग, स्रोत एट्रिब्यूशन और सीमित निष्पादन

ऐसा LangGraph दस्तावेज़ प्रश्न-उत्तर एजेंट बनाएं जो तय करे कि कब रिट्रीव करना है, संदर्भ का मूल्यांकन करे, कमजोर खोज पर सीमित बार दोबारा प्रयास करे और स्रोत-संबंधित उत्तर दे, बिना अनंत निष्पादन के।

阅读全文 →

Guides

मानव समीक्षा के साथ सीमित LangGraph टूल-कॉलिंग एजेंट बनाएं

स्पष्ट चरण-सीमाओं, जोखिमपूर्ण कार्रवाइयों के लिए मानव अनुमोदन और दोहराए जा सकने वाले टेस्ट केस के साथ LangGraph टूल-कॉलिंग एजेंट का मूल्यांकन करने का व्यावहारिक तरीका।

阅读全文 →

Guides

प्रोडक्शन वर्कफ़्लो संचालन के लिए Gemini 4 Hydrogen बनाम Carbon

कोडिंग, tool calling, structured output और विफलता से उबर सकने वाले प्रोडक्शन वर्कफ़्लो के लिए Gemini 4 Hydrogen और Carbon के बारे में उपलब्ध साक्ष्य क्या कहते हैं।

阅读全文 →

Guides

n8n में रिकवर किया जा सकने वाला डेटा एक्सट्रैक्शन वर्कफ़्लो बनाएं

ऐसा n8n एक्सट्रैक्शन वर्कफ़्लो डिज़ाइन करें जो रिकॉर्ड वैलिडेट करे, अस्थायी विफलताओं पर दोबारा प्रयास करे और अपवादों को मानवीय समीक्षा के लिए भेजे, बिना डुप्लिकेट राइट किए।

阅读全文 →