मुख्य कंटेंट तक स्किप करें

ओपन-सोर्स AI एजेंट फ्रेमवर्क

उन्नत

एक बार जब आप हाथ से कुछ एजेंट बना लेते हैं, तो वही प्लंबिंग बार-बार दिखाई देती है: एक लूप जो मॉडल को कॉल करता है, उसने जो टूल माँगा उसे चलाता है, परिणाम वापस फ़ीड करता है, और जब काम पूरा हो जाता है तो रुक जाता है। एजेंट फ्रेमवर्क उस प्लंबिंग को पैकेज कर देते हैं — साथ ही स्टेट, मेमोरी और मल्टी-एजेंट समन्वय — ताकि आपको कम ग्लू कोड लिखना पड़े। यह पेज मुख्य ओपन-सोर्स विकल्पों का एक टिकाऊ, प्रोवाइडर-न्यूट्रल नक्शा है, वे वास्तव में आपको क्या देते हैं, और कैसे चुनें। इनमें से लगभग सभी मॉडल-एग्नॉस्टिक हैं: वे Claude, GPT, Gemini और लोकल ओपन-वेट मॉडल के साथ काम करते हैं।

What you'll learn
  • जानें कि एक एजेंट फ्रेमवर्क आपको हाथ से बनाए लूप के मुकाबले क्या देता है — और क्या नहीं
  • तीन आर्किटाइप पहचानें: स्टेटफुल ग्राफ, रोल-आधारित क्रू, और मिनिमल लूप
  • किसी एक को चुनने के लिए एक दोहराने योग्य प्रक्रिया का उपयोग करें — नियंत्रण के बदले जटिलता का व्यापार करते हुए
  • याद रखें कि ये ज़्यादातर मॉडल-एग्नॉस्टिक हैं — फ्रेमवर्क शायद ही आपको एक प्रोवाइडर से बाँधता है

एक एजेंट फ्रेमवर्क वास्तव में आपको क्या देता है​

ब्रांडिंग को हटा दें तो एक फ्रेमवर्क आपको चार चीज़ों में से कुछ उपसमूह पेश कर रहा है:

  • ऑर्केस्ट्रेशन — कंट्रोल लूप। क्रमिक चरण, शाखाएँ, पुनः प्रयास, लूप-जब-तक-पूरा-न-हो, और (बढ़ती हुई मात्रा में) ड्यूरेबल एग्ज़ीक्यूशन जो क्रैश से बच जाता है और वहीं से फिर शुरू होता है जहाँ रुका था।
  • टूल्स — एक ऐसे फ़ंक्शन को घोषित करने का एक मानक तरीका जिसे मॉडल कॉल कर सकता है, उसके आर्गुमेंट को वैलिडेट करता है, उसे चलाता है, और परिणाम लौटाता है। वही describe→call→execute→return लूप जिसे आप टूल यूज़ से पहले से जानते हैं।
  • मेमोरी और स्टेट — बातचीत का इतिहास, स्क्रैचपैड तथ्य, और पुनर्प्राप्त किए गए दस्तावेज़ टर्न-दर-टर्न रखने के लिए कोई जगह, ताकि एजेंट चरणों के बीच स्मृति-रहित न हो।
  • मल्टी-एजेंट — कई विशेषज्ञ एजेंटों के पैटर्न जो एक-दूसरे को काम सौंपते हैं: एक सुपरवाइज़र जो वर्कर्स को काम सौंपता है, या साथी जो किसी काम पर सहयोग करते हैं। (अवधारणात्मक रूप से Claude Code के सबएजेंट जैसा ही विचार।)

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

तीन आर्किटाइप​

फ्रेमवर्क उतने भिन्न नहीं होते जितना उनकी मार्केटिंग सुझाती है। वास्तव में तीन ही आकार हैं, और अधिकांश परियोजनाएँ इनमें से किसी एक का रूपांतर हैं:

  • स्टेटफुल ग्राफ / वर्कफ़्लो। आप एजेंट को नोड्स और एजेस (या चरण और ट्रांज़िशन) के एक स्पष्ट ग्राफ के रूप में मॉडल करते हैं। अधिकतम नियंत्रण, निरीक्षण-योग्य स्टेट, लंबे समय तक चलने वाले और ह्यूमन-इन-द-लूप फ्लो के लिए अच्छा। शुरुआत में सीखने को ज़्यादा। → LangGraph, LlamaIndex Workflows।
  • रोल-आधारित क्रू। आप एजेंटों का वर्णन भूमिका के अनुसार करते हैं ("शोधकर्ता", "लेखक", "समीक्षक") और उन्हें सहयोग करने या एक प्रक्रिया चलाने देते हैं। एक मल्टी-एजेंट टीम को व्यक्त करने में तेज़; आप उच्च-स्तरीय अमूर्तन के बदले कुछ सूक्ष्म नियंत्रण का व्यापार करते हैं। → CrewAI, और AutoGen की संवादात्मक मल्टी-एजेंट शैली।
  • मिनिमल लूप / कम अमूर्तन। मॉडल की मूल टूल-कॉलिंग पर एक पतली परत, जिसमें कुछ एजेंटों के बीच हैंडऑफ़ हों और बहुत कुछ नहीं। शुरू से अंत तक पढ़ने में आसान, हटाने में आसान। → OpenAI Agents SDK (प्रायोगिक Swarm का प्रोडक्शन उत्तराधिकारी), और आपके खुद के लिखे सादे लूप।
Pro tip
  • सबसे सरल चीज़ से शुरुआत करें जो काम करती है — अक्सर एक सादा टूल-कॉलिंग लूप एक भारी फ्रेमवर्क को हरा देता है।

एक त्वरित दौरा (प्रतिबद्ध होने से पहले पोज़िशनिंग की पुष्टि करें)​

ये जानने योग्य ओपन परियोजनाएँ हैं। नाम केवल इसलिए दिए गए क्योंकि प्रत्येक का असली repo सत्यापित किया गया था; हर अस्थिर चीज़ ऊपर दिए गए VerifyNote के पीछे रहती है।

  • LangGraph — ग्राफ के रूप में मॉडल किए गए स्टेटफुल, लंबे समय तक चलने वाले एजेंटों के लिए एक निम्न-स्तरीय ऑर्केस्ट्रेशन फ्रेमवर्क; ड्यूरेबल एग्ज़ीक्यूशन और ह्यूमन-इन-द-लूप प्रथम-श्रेणी के हैं। स्टैंडअलोन या व्यापक LangChain पारिस्थितिकी तंत्र के साथ उपयोग करने योग्य। मॉडल-एग्नॉस्टिक।
  • LlamaIndex — एक डेटा/RAG फ्रेमवर्क के रूप में शुरू हुआ (कनेक्टर, इंडेक्स, रिट्रीवल) और अब एजेंटों के लिए एक इवेंट-चालित Workflows परत भी देता है। तब मज़बूत जब आपका एजेंट मूल रूप से आपके दस्तावेज़ों पर रिट्रीवल हो।
  • Microsoft AutoGen — संवादात्मक मल्टी-एजेंट सिस्टम के लिए एक फ्रेमवर्क। 2026 के मध्य तक यह मेंटेनेंस मोड में है; Microsoft नई परियोजनाओं को एक एकीकृत उत्तराधिकारी (Microsoft Agent Framework, AutoGen + Semantic Kernel का विलय) की ओर निर्देशित करता है। शुरू करने से पहले वर्तमान स्थिति जाँचें।
  • CrewAI — एक रोल-आधारित फ्रेमवर्क: एजेंटों को भूमिका और लक्ष्य के अनुसार परिभाषित करें, उन्हें Crews (स्वायत्त सहयोग) या Flows (इवेंट-चालित नियंत्रण) में व्यवस्थित करें। एक मल्टी-एजेंट टीम तक तेज़ रास्ता।
  • OpenAI Agents SDK — हैंडऑफ़ के साथ मल्टी-एजेंट वर्कफ़्लो के लिए एक जानबूझकर हल्का, कम-अमूर्तन वाला फ्रेमवर्क। नाम के बावजूद यह प्रोवाइडर-एग्नॉस्टिक है (इसके docs 100+ LLM के समर्थन का उल्लेख करते हैं), और यह प्रायोगिक Swarm का प्रोडक्शन-रेडी उत्तराधिकारी है।
  • सादा एजेंट लूप — कोई फ्रेमवर्क बिल्कुल नहीं: मॉडल की मूल टूल-कॉलिंग के इर्द-गिर्द आपका खुद का while लूप। सरल एजेंटों के लिए सही डिफ़ॉल्ट, और वह चीज़ जिसे ऊपर का हर फ्रेमवर्क अंततः लपेट रहा है।

एक फ्रेमवर्क कैसे चुनें​

Guided walkthrough1 of 6
  1. एजेंट क्या करता है इस पर एक वाक्य, साथ ही गैर-समझौता योग्य बातें: लेटेंसी, लागत की सीमा, डेटा प्राइवेसी, क्या रन को क्रैश से बचना चाहिए, और क्या किसी मनुष्य को चरणों को अनुमोदित करना चाहिए।

वह चीज़ जिसे हर फ्रेमवर्क लपेटता है​

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

# Provider-neutral agent loop — the core every framework wraps.
# `model_call` and `run_tool` are yours; swap in Claude, GPT, Gemini, or a local model.

def agent_loop(task, tools, max_steps=10):
    messages = [{"role": "user", "content": task}]

    for _ in range(max_steps):
        # 1. Ask the model what to do next (it sees the tool schemas).
        response = model_call(messages, tools=tools)

        # 2. No tool requested → the model is done. Return its answer.
        if not response.tool_calls:
            return response.text

        # 3. Run each requested tool and feed results back in.
        messages.append(response.as_message())
        for call in response.tool_calls:
            result = run_tool(call.name, call.arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })

    return "Stopped: hit max_steps without finishing."

अगर आप इसे पढ़ सकते हैं, तो आप समझते हैं कि इस पेज पर मौजूद हर फ्रेमवर्क अंदरूनी तौर पर क्या कर रहा है। ग्राफ स्पष्ट स्टेट और शाखा जोड़ते हैं; क्रू भूमिकाएँ और प्रत्यायोजन जोड़ते हैं; मिनिमल SDK सुव्यवस्थित हैंडऑफ़ जोड़ते हैं — लेकिन दिल की धड़कन हमेशा यही लूप है।

मिनिमल एजेंट सिस्टम प्रॉम्प्ट (ऊपर के लूप के साथ जोड़ी बनाता है)

You are a task-completing agent with access to tools.

Loop:
1. Think briefly about the next single step toward the goal.
2. If a tool would help, call exactly ONE tool with valid arguments.
3. When you have enough to answer, stop calling tools and give the final answer.

Rules:
- Prefer the fewest tool calls that get the job done.
- If a tool fails, read the error and adjust — do not repeat the same call.
- Never invent tool results; use only what tools actually returned.
- If the goal is impossible with the available tools, say so and stop.

Goal: {one-sentence task}

हाइप पर एक टिप्पणी​

यहाँ कोई भी फ्रेमवर्क "सबसे अच्छा" नहीं है — वह सवाल ही ग़लत है। ग्राफ फ्रेमवर्क नियंत्रण और टिकाऊपन पर जीतते हैं; क्रू फ्रेमवर्क एक टीम को तेज़ी से व्यक्त करने पर जीतते हैं; मिनिमल वाले पठनीयता और कम लॉक-इन पर जीतते हैं; और एक सादा लूप उससे कहीं ज़्यादा बार जीतता है जितना फ्रेमवर्क README स्वीकार करते हैं। सही चुनाव सबसे छोटा टूल है जो आपके सबसे कठिन चरण को स्पष्ट बनाता है। मॉडल चुनने की तरह, अपने खुद के काम को — किसी स्टार गिनती को नहीं — तय करने दें। वही अनुशासन जो आप इवैल्स के साथ लगाते, यहाँ भी लागू होता है: प्रोटोटाइप बनाएँ, असली मामलों पर मापें, एक निकास रैंप रखें।

खुद को जाँचें

0/3
  1. आपका एजेंट एक मॉडल कॉल करता है, एक अकेला सर्च टूल चलाता है, और एक जवाब लौटाता है। सही शुरुआती बिंदु क्या है?
  2. आपको एक ऐसे एजेंट की ज़रूरत है जो लंबे समय तक चले, क्रैश से बच कर फिर शुरू हो, और किसी मनुष्य को कुछ चरण अनुमोदित करने दे। कौन-सा आर्किटाइप सबसे अच्छा बैठता है?
  3. एक साथी कहता है 'OpenAI Agents SDK का मतलब है कि हम GPT में लॉक हो गए हैं।' क्या यह सही है?
एजेंट फ्रेमवर्क — मूल विचार
कार्ड पलटने के लिए Enter या Space दबाएँ। कार्ड बदलने के लिए बाएँ और दाएँ तीर कुंजियों का उपयोग करें।शब्द दिखाया गया।
1 / 6
Key takeaways
  • एक एजेंट फ्रेमवर्क ऑर्केस्ट्रेशन, टूल्स, मेमोरी, और मल्टी-एजेंट समन्वय को पैकेज करता है — इसे तभी अपनाएँ जब अन्यथा आपको ये चारों खुद बनाने पड़ते।
  • तीन आर्किटाइप पूरे क्षेत्र को कवर करते हैं: स्टेटफुल ग्राफ (नियंत्रण/टिकाऊपन), रोल-आधारित क्रू (तेज़ टीमें), और मिनिमल लूप (पठनीयता, कम लॉक-इन)।
  • इनमें से लगभग सभी मॉडल-एग्नॉस्टिक हैं — ये Claude, GPT, Gemini, और लोकल मॉडलों पर चलते हैं; मानने के बजाय प्रति परियोजना सत्यापित करें।
  • कोई भी फ्रेमवर्क सार्वभौमिक रूप से 'सबसे अच्छा' नहीं है; सबसे छोटा टूल चुनें जो आपके सबसे कठिन चरण को स्पष्ट बनाए, और एक निकास रैंप रखें।
  • सादा टूल-कॉलिंग लूप ईमानदार डिफ़ॉल्ट है — और यही वह चीज़ है जिसे हर फ्रेमवर्क लपेटता है।
  • मेंटेनेंस स्थिति बदलती है (जैसे AutoGen → एक उत्तराधिकारी); प्रतिबद्ध होने से पहले पुष्टि करें कि परियोजना उसके अपने repo पर सक्रिय रूप से मेंटेन की जा रही है।

स्रोत और आगे पढ़ना​

  • LangGraph — GitHub — स्टेटफुल, लंबे समय तक चलने वाले एजेंटों के लिए निम्न-स्तरीय ऑर्केस्ट्रेशन फ्रेमवर्क।
  • LangGraph अवलोकन — LangChain docs — अवधारणाएँ, ड्यूरेबल एग्ज़ीक्यूशन, और ह्यूमन-इन-द-लूप।
  • LangChain — GitHub — व्यापक पारिस्थितिकी तंत्र जिसके साथ LangGraph एकीकृत होता है।
  • LlamaIndex — GitHub — एजेंटों के लिए इवेंट-चालित Workflows परत वाला डेटा/RAG फ्रेमवर्क।
  • LlamaIndex docs — RAG, क्वेरी इंजन, एजेंट, और Workflows।
  • Microsoft AutoGen — GitHub — संवादात्मक मल्टी-एजेंट फ्रेमवर्क (मेंटेनेंस स्थिति जाँचें)।
  • Microsoft Agent Framework — GitHub — एजेंट बनाने और ऑर्केस्ट्रेट करने के लिए एकीकृत उत्तराधिकारी (AutoGen + Semantic Kernel)।
  • CrewAI — GitHub — Crews और Flows वाला रोल-आधारित मल्टी-एजेंट फ्रेमवर्क।
  • CrewAI docs — एजेंट, टास्क, क्रू, फ्लो, और टूल।
  • OpenAI Agents SDK — GitHub — हैंडऑफ़ के साथ हल्का, प्रोवाइडर-एग्नॉस्टिक मल्टी-एजेंट फ्रेमवर्क।
  • OpenAI Agents SDK docs — न्यूनतम-अमूर्तन वाला एजेंट मॉडल।
  • OpenAI Swarm — GitHub — प्रायोगिक पूर्ववर्ती जिसे Agents SDK प्रतिस्थापित करता है (शैक्षिक, अब अधिक्रमित)।

आगे​

  • मॉडल चुनने का प्रोवाइडर-न्यूट्रल तरीका → एक मॉडल चुनना
  • वह लूप जिसे ये फ्रेमवर्क लपेटते हैं → टूल यूज़
  • Claude Code के तरीके से मल्टी-एजेंट → सबएजेंट
  • उम्मीदवारों की वास्तव में तुलना कैसे करें → इवैल्स