Claude Agent SDK बनाम LangGraph: एजेंट बनाने के लिए कौन-सा चुनें?

Claude Agent SDK और LangGraph के बीच चुनाव एक सवाल पर टिका है: अगला कदम मॉडल तय करे या आपका कोड? Claude Agent SDK आपके एप्लिकेशन को वही एजेंट लूप देता है जो Claude Code के अंदर चलता है, इसलिए Claude खुद अपने टूल और कदम चुनता है। LangGraph इसके बजाय एक स्टेट मशीन देता है। आप नोड और एज बनाते हैं, और हर पड़ाव पर मॉडल काम करता है। दोनों सक्षम AI एजेंट बनाते हैं। बस इस बात पर असहमत हैं कि स्टीयरिंग व्हील किसके हाथ में हो।

यह तुलना कंट्रोल फ़्लो, टूल्स, स्टेट, ह्यूमन अप्रूवल, मॉडल चुनाव और प्रोडक्शन लागत को देखती है, ताकि आप हज़ार लाइनें गलत चीज़ में लिखने से पहले एक चुन सकें।

संक्षिप्त जवाब

अगर आपका एजेंट मुख्य रूप से "एक सक्षम मॉडल को अच्छे टूल दो और उसे काम करने दो" वाला है, तो Claude Agent SDK से शुरू करें। अगर आपका एजेंट तय चरणों, शाखाओं, रीट्राई और ऑडिट पॉइंट्स वाला वर्कफ़्लो है, तो LangGraph से शुरू करें। अपने प्रोजेक्ट को इन दोनों में से किसी एक आकार में रखते ही ज़्यादातर उलझन खत्म हो जाती है।

विस्तार में जाने से पहले यहाँ साथ-साथ तुलना है:

💡 मोटा नियम: उन कदमों की गिनती करें जिन्हें आप पहले से लिख सकते हैं। अगर उन्हें एक नैपकिन पर लिख सकें, तो ग्राफ़ बनाएँ। अगर ईमानदार जवाब यह है कि "यह इस पर निर्भर है कि एजेंट क्या ढूँढता है", तो लूप का इस्तेमाल करें।

हर फ़्रेमवर्क क्या है

Claude Agent SDK का संक्षिप्त परिचय

Anthropic ने इसे पहले Claude Code SDK के रूप में जारी किया था, और बाद में इसका नाम बदलकर Claude Agent SDK कर दिया, क्योंकि लोग इसे कोडिंग से कहीं ज़्यादा कामों के लिए इस्तेमाल करने लगे थे। Python के लिए claude-agent-sdk या TypeScript के लिए @anthropic-ai/claude-agent-sdk इंस्टॉल करते हैं, प्रॉम्प्ट और कुछ विकल्पों के साथ query() को कॉल करते हैं, और एजेंट के काम करते हुए मैसेज स्ट्रीम में वापस पाते हैं।

इसके नीचे वही हार्नेस है जो Claude Code को चलाता है। यह Claude को कॉन्टेक्स्ट भेजता है, जो टूल Claude माँगता है उन्हें चलाता है, नतीजे वापस देता है, और तब तक दोहराता है जब तक Claude तय न कर ले कि काम पूरा हो गया। आपको बिना खुद लिखे ये चीज़ें मिलती हैं:

• बिल्ट-इन टूल्स: Read, Write, Edit, Bash, Glob, Grep, WebSearch और WebFetch
• कॉन्टेक्स्ट मैनेजमेंट: विंडो भरने पर हार्नेस पुरानी बारी को संक्षिप्त कर देता है
• सबएजेंट: अपने प्रॉम्प्ट और टूल सूची वाले विशेष सहायक
• Hooks: किसी टूल कॉल से पहले या बाद में आपका कोड चलता है
• MCP सपोर्ट: डेटाबेस, ब्राउज़र और आंतरिक APIs के लिए Model Context Protocol सर्वर जोड़ें
• Permissions: मोड और नियम जो तय करते हैं कि कौन-से टूल कॉल को अप्रूवल चाहिए
• प्रोजेक्ट निर्देश: CLAUDE.md फ़ाइलें और फ़ाइल सिस्टम से लोड होने वाले skills

LangGraph का संक्षिप्त परिचय

LangGraph LangChain टीम से आता है और लंबे समय तक चलने वाले, स्टेटफ़ुल एजेंटों के लिए बना है। यह 2025 के अंत में 1.0 रिलीज़ तक पहुँचा। आप एक स्टेट स्कीमा परिभाषित करते हैं, नोड्स को सामान्य फ़ंक्शन के रूप में लिखते हैं, उन्हें फ़िक्स्ड या कंडिशनल एज से जोड़ते हैं, और नतीजे को एक रनेबल ग्राफ़ में कंपाइल करते हैं।

यहाँ ग्राफ़ ही उत्पाद है। हर स्टेप साझा स्टेट पढ़ता है और एक अपडेट लौटाता है, इसलिए आप किसी भी पल देख सकते हैं कि रन कहाँ खड़ा है। चेकपॉइंटर हर स्टेप के बाद स्टेट सेव करते हैं, और इसी से रोकना, फिर से शुरू करना और रीप्ले संभव होता है। LangGraph मॉडल-अज्ञेयवादी है: कोई भी चैट मॉडल जिसका LangChain इंटीग्रेशन हो, किसी भी नोड में लग सकता है, और जब आप रनों को देखना चाहें तो LangSmith ट्रेसिंग जोड़ता है।

एजेंट लूप बनाम स्पष्ट ग्राफ़

अगला कदम कौन चुनता है

यहीं असली दोराहा है। SDK में Claude हर टर्न पर अगली चाल चुनता है: कोई और फ़ाइल पढ़ना, कमांड चलाना, वेब सर्च करना या रुकना। LangGraph में एज चुनते हैं, और मॉडल केवल उस नोड के भीतर फ़ैसला करता है जो उसे दिया गया है।

दोनों में से कोई भी तरीका गलत नहीं है। लूप अचानक आने वाली चीज़ों को संभालता है, जैसे कोई बग रिपोर्ट जो असल में कॉन्फ़िग की समस्या निकले। ग्राफ़ प्रक्रिया की गारंटी देता है, जैसे "कार्ड चार्ज करने से पहले पता हमेशा वैलिडेट करें।"

दोनों में एक ही काम

एक सीधा काम लीजिए: एक auth मॉड्यूल का ऑडिट करें और सबसे जोखिम भरे फ़ंक्शन बताएँ। यह Claude Agent SDK से ऐसे दिखता है:

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    options = ClaudeAgentOptions(
        allowed_tools=["Read", "Grep", "Glob"],
        system_prompt="You review code for security risks.",
    )
    async for message in query(
        prompt="Audit the auth module and list the three riskiest functions.",
        options=options,
    ):
        print(message)

asyncio.run(main())

प्रॉम्प्ट कॉपी करें

बस इतना ही प्रोग्राम है। Claude तय करता है कि कौन-सी फ़ाइलें खोलनी हैं, किस क्रम में, और कब उसने पर्याप्त देख लिया है।

अब वही काम LangGraph में, एक गारंटीड रिव्यू स्टेप के साथ। हेल्पर run_audit और passes_checks आपके अपने कोड के प्लेसहोल्डर हैं:

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class State(TypedDict):
    question: str
    report: str
    approved: bool

def audit(state: State) -> dict:
    return {"report": run_audit(state["question"])}

def review(state: State) -> dict:
    return {"approved": passes_checks(state["report"])}

def route(state: State) -> str:
    return "done" if state["approved"] else "retry"

builder = StateGraph(State)
builder.add_node("audit", audit)
builder.add_node("review", review)
builder.add_edge(START, "audit")
builder.add_edge("audit", "review")
builder.add_conditional_edges("review", route, {"done": END, "retry": "audit"})
graph = builder.compile()

प्रॉम्प्ट कॉपी करें

यहाँ प्रक्रिया आपने लिखी है: हर रिपोर्ट की समीक्षा होती है, और असफल समीक्षा हमेशा वापस भेजी जाती है। मॉडल कभी समीक्षा छोड़ नहीं सकता। कीमत है बुनियादी ढाँचे का झंझट: ज़्यादा कोड, ज़्यादा फ़ैसले, और एक ग्राफ़ जिसे संभालना पड़ता है।

मल्टी-एजेंट सेटअप

SDK सौंपने का काम सबएजेंट से करता है। आप हर सहायक को एक विवरण, एक प्रॉम्प्ट और सीमित टूल सूची के साथ परिभाषित करते हैं, और मुख्य एजेंट उन्हें काम सौंपता है। हर सबएजेंट अपने कॉन्टेक्स्ट में चलता है, जिससे पैरेंट की विंडो साफ़ रहती है। इसे सेट करना तेज़ है, और सौंपने के फ़ैसले Claude के पास ही रहते हैं।

LangGraph यही चीज़ सबग्राफ़ या एक सुपरवाइज़र नोड के रूप में मॉडल करता है, जो वर्कर नोड्स को रूट करता है। हैंडऑफ़ साफ़ होते हैं, साझा स्टेट टाइप्ड होता है, और आप हर वर्कर को अकेले टेस्ट कर सकते हैं। जब पाँच एजेंटों को तय क्रम में मिलकर काम करना हो, तो यह स्पष्टता काम आती है। जब एजेंट ढीले-ढाले विशेषज्ञ हों, तो यह कागज़ी कार्रवाई जैसा लग सकता है।

टूल्स, स्टेट और मेमोरी

बिल्ट-इन टूल्स बनाम कस्टम नोड्स

SDK पूरे टूलबॉक्स के साथ आता है, इसीलिए पहले ही दिन यह उत्पादक लगता है। जो एजेंट रिपॉज़िटरी पढ़ सके, फ़ाइलें एडिट कर सके और टेस्ट चला सके, वह allowed_tools देते ही काम करने लगता है। कस्टम टूल इन-प्रोसेस MCP सर्वर या किसी बाहरी MCP सर्वर के ज़रिए जुड़ते हैं। बॉक्स में क्या-क्या रखा है, उतना ही यह भी मायने रखता है कि उसे सीमित करें: Bash ताकतवर है, इसलिए इसे सिर्फ़ उन्हीं एजेंटों को दें जिन्हें इसकी ज़रूरत है।

LangGraph खाली वर्कबेंच से शुरू होता है। टूल ऐसे फ़ंक्शन होते हैं जिन्हें आप नोड के भीतर मॉडल से बाइंड करते हैं, और एक पहले से बना टूल नोड कॉल चलाता है। इसका मतलब है ज़्यादा सेटअप और ज़्यादा आज़ादी: टूल कुछ भी हो सकता है जिसे Python या JavaScript कॉल कर सके, और यह आप तय करते हैं कि हर नोड क्या छू सकता है।

सेशन बनाम चेकपॉइंट

SDK एक सेशन ट्रैक करता है। हर रन की एक ID होती है, और आप उसे बाद में पूरी बातचीत के इतिहास के साथ फिर से शुरू कर सकते हैं, या किसी और दिशा को आज़माने के लिए उसे फ़ोर्क कर सकते हैं। हार्नेस पुरानी बारी को संक्षिप्त करता है, ताकि लंबे काम कॉन्टेक्स्ट में अटक न जाएँ।

LangGraph हर स्टेप के लिए एक चेकपॉइंट ट्रैक करता है, जो थ्रेड के अनुसार समूहित होते हैं। आप क्रैश के बाद थ्रेड फिर से शुरू कर सकते हैं, किसी पिछले स्टेप से रीप्ले कर सकते हैं, या स्टेट में बदलाव करके वहीं से ब्रांच कर सकते हैं। एक अलग स्टोर लंबी अवधि की मेमोरी रखता है जो थ्रेड्स में साझा होती है, जैसे उपयोगकर्ता की पसंद।

💡 फ़र्क: सेशन बातचीत याद रखता है। चेकपॉइंट यह याद रखता है कि वर्कफ़्लो कहाँ खड़ा है। अगर आपके एजेंट को सात में से चौथे स्टेप से किसी दूसरे सर्वर पर फिर से शुरू होना है, तो चेकपॉइंट स्वाभाविक विकल्प है।

ह्यूमन अप्रूवल और कंट्रोल

जो एजेंट पैसे, प्रोडक्शन डेटा या ग्राहक ईमेल को छूते हैं, उन्हें लूप में एक व्यक्ति चाहिए। दोनों टूल इसे अलग-अलग जगहों पर सहारा देते हैं।

Permissions और Hooks

SDK कार्रवाइयों की रखवाली करता है। Permission modes में हर चीज़ से पहले पूछने से लेकर फ़ाइल एडिट अपने-आप स्वीकार करने और केवल-पढ़ने वाले प्लानिंग मोड तक सब शामिल है। आप नाम से टूल की अनुमति या मनाही कर सकते हैं, हर कॉल को मंज़ूरी देने वाला कॉलबैक दे सकते हैं, और hooks लगा सकते हैं जो टूल चलने से पहले चलते हैं और उसे रोक या बदल सकते हैं। ऐसा hook लिखना जो rm -rf वाली कोई भी शेल कमांड मना करे, एक छोटा सा फ़ंक्शन है।

Interrupts और Resume

LangGraph स्टेज की रखवाली करता है। एक नोड interrupt() कॉल करता है, ग्राफ़ रुक जाता है, और चेकपॉइंटर सब कुछ सेव कर लेता है। घंटों या दिनों बाद कोई व्यक्ति जवाब देता है, आप Command के साथ रन फिर से शुरू करते हैं, और वह उसी जगह से आगे बढ़ता है, भले ही किसी दूसरी मशीन पर हो। इससे किसी सीमा से ऊपर के रिफ़ंड जैसी अप्रूवल कतारें बनाना सीधा हो जाता है।

कौन-सा बेहतर है? अगर आपकी चिंता यह है कि एजेंट को क्या करने की अनुमति है, तो SDK के permissions ठीक बैठते हैं। अगर आपकी चिंता यह है कि किसी बिज़नेस प्रक्रिया में इंसान को कब हस्ताक्षर करने होंगे, तो LangGraph के interrupts ठीक बैठते हैं।

मॉडल चुनाव और प्रोडक्शन की असलियत

मॉडल लॉक-इन

Claude Agent SDK Claude मॉडल चलाता है। आप इन तक Anthropic के API से या Amazon Bedrock और Google Vertex AI जैसे क्लाउड प्रदाताओं के ज़रिए पहुँच सकते हैं, लेकिन किसी दूसरे वेंडर का मॉडल नहीं लगा सकते। अगर वैसे भी Claude ही आपकी पसंद है, तो यह एक खूबी है, क्योंकि हार्नेस इस तरह ट्यून किया गया है कि Claude टूल कैसे इस्तेमाल करता है।

LangGraph मॉडल के मामले में तटस्थ है। आप एक नोड को रूटिंग के लिए तेज़ और सस्ते मॉडल पर चला सकते हैं, दूसरे को मज़बूत रीज़निंग मॉडल पर, और कॉन्फ़िग बदलकर किसी को भी बदल सकते हैं। प्रतिबद्ध होने से पहले, PicassoIA पर वही एजेंट प्रॉम्प्ट कई मॉडलों पर चलाएँ: संतुलित कोडिंग और टूल उपयोग के लिए Claude Sonnet 5, कठिन रीज़निंग के लिए Claude Opus 4.7, जटिल कोडिंग कामों के लिए Claude Fable 5, GPT 5.6 Sol, Gemini 3.1 Pro, और Kimi K2.6, जिसे एजेंट बनाने के लिए ख़ास तौर पर पेश किया गया है। अगर कोई एक वेंडर आपके काम में साफ़ तौर पर आगे है, तो लॉक-इन का सवाल अपने-आप सुलझ जाता है।

ऑब्ज़र्वेबिलिटी और डिप्लॉयमेंट

SDK एजेंट Claude Code रनटाइम चलाता है, इसलिए उसे वहीं डिप्लॉय करें जहाँ वह रनटाइम रह सके, आमतौर पर लॉक्ड-डाउन फ़ाइल सिस्टम वाला कंटेनर। चूँकि एजेंट शेल कमांड चला सकता है, सैंडबॉक्सिंग ज़रूरी है, वैकल्पिक नहीं। दृश्यता के लिए आपको मैसेज स्ट्रीम, सेव किए गए ट्रांसक्रिप्ट और हर टूल कॉल लॉग करने वाले hooks मिलते हैं।

LangGraph एजेंट सामान्य सेवाएँ हैं। LangSmith हर नोड को ट्रेस करता है, एक विज़ुअल स्टूडियो आपको स्टेट के माध्यम से स्टेप-दर-स्टेप चलने देता है, और लंबे समय तक चलने वाले ग्राफ़ के लिए होस्टेड डिप्लॉयमेंट विकल्प भी है। चेकपॉइंट के ज़रिए टिकाऊ एक्ज़ीक्यूशन का मतलब है कि रीडिप्लॉय या क्रैश चल रहे रन को नहीं मिटाता।

लागत और लेटेंसी

दोनों इंस्टॉल करने में मुफ़्त हैं। बिल मॉडल टोकन और होस्टिंग का बनता है। जब काम अस्पष्ट हो, तो लूप ज़्यादा महँगे पड़ते हैं, क्योंकि मॉडल तीन फ़ाइलों से काम चल सकने पर भी दस फ़ाइलें खोल सकता है। ग्राफ़ इस पर लगाम लगाने देते हैं: आसान स्टेप छोटे मॉडल को भेजें, recursion limit से रीट्राई सीमित करें, और तय स्टेप्स के लिए मॉडल को पूरी तरह छोड़ दें। दूसरी तरफ़, खुले सिरे वाले काम में लूप अक्सर जल्दी काम का नतीजा दे देता है, क्योंकि पहले ग्राफ़ डिज़ाइन करने की ज़रूरत नहीं होती।

कौन-सा चुनें

Claude Agent SDK कब चुनें

• एजेंट फ़ाइलों, कोड या शेल पर काम करता है, और बिल्ट-इन टूल काम से पहले से मेल खाते हैं
• काम का रास्ता पहले से अनुमान में नहीं आ सकता
• आप Claude के प्रति प्रतिबद्ध हैं और चाहते हैं कि उसका टूल-उपयोग व्यवहार आपके प्रोडक्ट के भीतर हो
• आप एक हफ़्ते के बजाय एक दोपहर में काम करने वाला प्रोटोटाइप चाहते हैं
• आपकी सुरक्षा की कहानी इस पर है कि कौन-सी कार्रवाइयाँ अनुमत हैं, न कि कौन-से स्टेज चलते हैं

LangGraph कब चुनें

• प्रक्रिया में क्रमबद्ध स्टेज, शाखाएँ और रीट्राई हैं जो हर बार होने ही चाहिए
• आपको कई वेंडरों के मॉडल मिलाने या उन्हें आसानी से बदलने की ज़रूरत है
• रनों को कई दिनों तक रोकना है और ठीक वहीं से फिर शुरू करना है जहाँ वे रुके थे
• ऑडिटर हर स्टेप पर स्टेट देखना चाहते हैं
• कई टीमें अलग-अलग एजेंट चलाती हैं जिन्हें एक-दूसरे को काम सौंपना है

दोनों को साथ चलाएँ

ये एक-दूसरे को बाहर नहीं करते। एक आम पैटर्न में LangGraph बाहरी वर्कफ़्लो होता है, जिसमें एक नोड खुले सिरे वाले हिस्से के लिए Claude Agent SDK को कॉल करता है, जैसे "फ़ेल होने वाले टेस्ट ठीक करो।" ग्राफ़ रूटिंग, अप्रूवल और रीट्राई संभालता है। SDK बीच के उलझे हिस्से को संभालता है।

💡 याद रखने योग्य: दोनों प्रोजेक्ट बदलाव तेज़ी से जारी करते हैं। यहाँ दी किसी भी जानकारी पर भरोसा करने से पहले हर एक के रिलीज़ नोट्स देख लें, खासकर विकल्पों के नाम और डिफ़ॉल्ट।

अब आपकी बारी: Picasso IA के साथ बनाएँ

फ़्रेमवर्क की बहस सुलझाने का सबसे अच्छा तरीका है कि किसी छोटी चीज़ पर उसे आज़माया जाए। यही बात विज़ुअल्स पर भी लागू होती है। आपके एजेंट प्रोजेक्ट को README के लिए एक हीरो इमेज, लॉन्च पोस्ट के लिए एक फ़ोटो, या प्रोडक्ट पेज के लिए मूडबोर्ड चाहिए होगा, और Picasso IA यह जल्दी बना देता है।

PicassoIA पर Claude Sonnet 5 के साथ अपना एजेंट प्रॉम्प्ट प्रोटोटाइप करें:

1. Claude Sonnet 5 पेज खोलें।
2. अपना ड्राफ़्ट सिस्टम प्रॉम्प्ट और एक असली काम चिपकाएँ।
3. मॉडल से कहें कि वह क्रम में बताए कि कौन-से टूल कॉल करेगा और क्यों।
4. वही टेक्स्ट Claude Opus 4.7 या Gemini 3.1 Pro पर चलाएँ और योजनाओं की तुलना करें।
5. वह योजना रखें जो उन स्टेप्स से मेल खाती हो जो आप ग्राफ़ में बनाते। इससे पता चलेगा कि कौन-सा फ़्रेमवर्क फ़िट बैठता है।

फिर उसके साथ जाने वाली कोई चीज़ भी बनाएँ। कोई दृश्य बताएँ, जैसे नरम सुबह की रोशनी में व्हाइटबोर्ड के सामने एक सॉफ़्टवेयर टीम, 35mm फ़िल्म पर शूट, और उसे कुछ ही सेकंड में जनरेट करें। picassoia.com/en/all-models पर उपलब्ध हर मॉडल देखें, तीन-चार प्रॉम्प्ट आज़माएँ, और देखें कि एक वाक्य कितनी दूर तक ले जाता है। आपके अगले एजेंट को भी एक अच्छा दिखने वाला लॉन्च चाहिए।