पूर्ण एजेंटिक AI एप्लिकेशन बनाने के लिए शीर्ष 15 Python फ्रेमवर्क

एजेंटिक AI एप्लिकेशन बनाना अब कुछ साल पहले की तुलना में काफी आसान हो गया है। एजेंट लूप, टूल इंटीग्रेशन, मेमोरी, रिट्रीवल और ऑर्केस्ट्रेशन को शून्य से बनाने की बजाय, डेवलपर्स ऐसे Python फ्रेमवर्क का उपयोग कर सकते हैं जो पहले से ही इनके अधिकतर कॉम्पोनेंट प्रदान करते हैं।

मैंने इस लेख में दिए गए कई फ्रेमवर्क का उपयोग RAG एप्लिकेशन बनाने, स्वायत्त एजेंट, मल्टी-एजेंट सिस्टम, और डिप्लॉय करने योग्य AI टूल्स के लिए किया है।

मैं अक्सर लचीले एजेंट वर्कफ़्लोज़ के लिए LangChain, डेटा-कनेक्टेड एप्लिकेशन के लिए LlamaIndex और Haystack, और जब प्रदाता मॉडलों के साथ तेज़ इंटीग्रेशन चाहिए होता है तो OpenAI Agents SDK या Google ADK का उपयोग करता/करती हूँ।

इनमें से कुछ फ्रेमवर्क इतने बेहतर हो गए हैं कि कस्टम समाधान बनाना अक्सर अनावश्यक हो जाता है। एक API कुंजी, कुछ मॉडल क्रेडिट्स, और सही फ्रेमवर्क के साथ, आप एक एजेंट बना सकते हैं, उसे टूल्स या निजी डेटा से जोड़ सकते हैं, उसका परीक्षण कर सकते हैं, और उसे API या यूज़र इंटरफ़ेस के माध्यम से डिप्लॉय कर सकते हैं।

यह लेख पाँच श्रेणियों में 15 Python फ्रेमवर्क की तुलना करता है: जनरल-परपज़ एजेंट फ्रेमवर्क, आधिकारिक एजेंट SDKs, मल्टी-एजेंट ऑर्केस्ट्रेशन फ्रेमवर्क, डेटा और RAG फ्रेमवर्क, तथा हल्के ओपन-मॉडल फ्रेमवर्क।

हर सेक्शन में एक छोटा Python उदाहरण भी शामिल है जिसे आप कॉपी, पेस्ट, और टेस्ट करके फ्रेमवर्क के काम करने का तरीका जल्दी समझ सकते हैं।

जनरल-परपज़ एजेंट फ्रेमवर्क

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

1. LangChain

कई डेवलपर्स के लिए, आधुनिक LLM एप्लिकेशन विकास की शुरुआत LangChain से हुई, जो एक ओपन-सोर्स Python फ्रेमवर्क है जिसे भाषा मॉडलों को बाहरी डेटा, टूल्स, APIs, और एप्लिकेशन लॉजिक से जोड़ने के लिए डिज़ाइन किया गया है। यह OpenAI API को वेबसाइट्स, दस्तावेज़ों, वेक्टर डेटाबेस, और अन्य डेटा स्रोतों के साथ उपयोग करने के लिए सबसे पहले व्यापक रूप से अपनाए गए फ्रेमवर्क में से एक बना, ताकि अधिक संदर्भ-सचेत एप्लिकेशन बनाए जा सकें।

आज, LangChain एक पूर्ण इकोसिस्टम में विकसित हो गया है जो एंड-टू-एंड एजेंटिक AI एप्लिकेशन—जैसे RAG सिस्टम, टूल-यूज़िंग एजेंट, वर्कफ़्लोज़, इंटीग्रेशन, मॉनिटरिंग, और इवैल्यूएशन—बनाने में मदद करता है। अधिक जानने के लिए मैं AI Engineering with LangChain ट्रैक देखने की सलाह देता/देती हूँ।

निम्न उदाहरण एक सरल LangChain एजेंट बनाता है जो किसी प्रश्न का उत्तर देने से पहले प्रासंगिक जानकारी खोजने के लिए डॉक्यूमेंटेशन सर्च टूल का उपयोग कर सकता है।

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

print(result["messages"][-1].content)

2. LangGraph

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

मैं इसे विशेष रूप से तब उपयोगी पाता/पाती हूँ जब ऐसे स्वायत्त एजेंट बनाने हों जिन्हें बार-बार यह निर्णय लेना हो कि क्या करना है, सही टूल चुनना हो, परिणाम जाँचना हो, और कार्य पूरा होने तक आगे बढ़ना हो। LangGraph लंबे समय तक चलने वाले एप्लिकेशन के लिए परसिस्टेंस, स्ट्रीमिंग, चेकपॉइंट्स, और रिकवरी का भी समर्थन करता है। हमारा LangGraph ट्यूटोरियल अधिक विवरण देता है।

निम्न उदाहरण एक ऐसा एजेंट बनाता है जो पर्याप्त जानकारी मिलने तक कैलकुलेटर टूल्स को बार-बार कॉल कर सकता है:

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

@tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

print(result["messages"][-1].content)

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

3. Agno

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

निम्न उदाहरण एक रिसर्च एजेंट बनाता है जो संक्षिप्त उत्तर देने से पहले वेब पर खोज कर सकता है।

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

एजेंट नवीनतम जानकारी खोजने के लिए सर्च टूल का उपयोग करता है और उपयोगकर्ता को संक्षिप्त सारांश स्ट्रीम करता है।

4. Pydantic AI

Pydantic AI Pydantic टीम का एक Python-नेटिव फ्रेमवर्क है, जो एजेंट और जनरेटिव AI एप्लिकेशन बनाने के लिए है। यह Pydantic मॉडल्स या FastAPI के साथ काम करने जैसा ही महसूस होता है, क्योंकि एजेंट, टूल्स, डिपेंडेंसीज़ और आउटपुट मानक Python फ़ंक्शंस, टाइप हिंट्स, डेकोरेटर, और BaseModel क्लासेस का उपयोग करके परिभाषित किए जाते हैं। फिर यह टूल आर्ग्युमेंट्स और मॉडल आउटपुट को स्ट्रक्चर्ड और विश्वसनीय रखने के लिए Pydantic वैलिडेशन का उपयोग करता है।

फ्रेमवर्क के बारे में अधिक जानने के लिए मैं Pydantic AI ट्यूटोरियल की सिफारिश करता/करती हूँ।

निम्न उदाहरण एक ऐसा एजेंट बनाता है जो एक वैलिडेटेड आर्टिकल प्लान को Pydantic मॉडल के रूप में लौटाता है।

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

एजेंट एक ArticlePlan ऑब्जेक्ट जनरेट करता है और लौटाने से पहले यह वैलिडेट करता है कि हर फ़ील्ड आवश्यक Python प्रकार और नियमों से मेल खाती है।

आधिकारिक एजेंट SDKs

आधिकारिक एजेंट SDKs AI प्रदाताओं द्वारा मेंटेन किए जाते हैं और सामान्यतः उनके मॉडलों, APIs, टूल्स, डिप्लॉयमेंट सिस्टम, और ऑब्ज़र्वेबिलिटी प्लेटफॉर्म्स के साथ सबसे सरल इंटीग्रेशन प्रदान करते हैं।

5. OpenAI Agents SDK

OpenAI Agents SDK एक हल्का, Python-प्रथम फ्रेमवर्क है जो सिंगल-एजेंट और मल्टी-एजेंट एप्लिकेशन बनाने के लिए है। यह बिना ज़्यादा एब्स्ट्रैक्शंस जोड़े इनबिल्ट एजेंट लूप, फ़ंक्शन टूल्स, हैंडऑफ़्स, गार्डरेल्स, सेशंस, मानव अनुमोदन, और ट्रेसिंग प्रदान करता है।

मुझे OpenAI Agents SDK का उपयोग पसंद है क्योंकि यह सरल है, तेज़ी से इंटीग्रेट होता है, और समझने में आसान है। मैंने इसके साथ कई एप्लिकेशन बिना किसी बड़े मुद्दे के बनाए हैं। यह स्वतः ऐसे ट्रेसेज़ भी बनाता है जिन्हें OpenAI डैशबोर्ड में देखा जा सकता है, जिससे मॉडल रिस्पॉन्स, टूल कॉल्स, हैंडऑफ़्स, और संपूर्ण एक्ज़ीक्यूशन फ्लो को निरीक्षण करना आसान हो जाता है।

निम्न उदाहरण एक इतिहास एजेंट बनाता है जो एक आश्चर्यजनक ऐतिहासिक तथ्य प्राप्त करने के लिए Python फ़ंक्शन को कॉल कर सकता है।

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

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

7. Google Agent Development Kit

Google का Agent Development Kit, या ADK, एक ओपन-सोर्स फ्रेमवर्क है जो व्यक्तिगत एजेंट, टूल-यूज़िंग असिस्टेंट्स, ग्राफ़ वर्कफ़्लोज़, और मल्टी-एजेंट सिस्टम बनाने, मूल्यांकन करने, और डिप्लॉय करने के लिए है। यह Gemini मॉडलों के साथ विशेष रूप से अच्छा काम करता है, जबकि अन्य मॉडल प्रदाताओं का भी समर्थन करता है।

ADK मेरे पसंदीदा फ्रेमवर्क में से एक बन गया है क्योंकि यह सरल है और Gemini के साथ स्वाभाविक रूप से काम करता है।

मैंने इससे कई एप्लिकेशन बिना किसी बड़े मुद्दे के बनाए हैं। हालाँकि मुझे अब भी OpenAI Agents SDK इंटीग्रेट करने में आसान और नियंत्रणों व इनबिल्ट फीचर्स के लिहाज से अधिक लचीला लगता है, फिर भी ADK एक मज़बूत विकल्प है और विशेष रूप से Gemini-आधारित एप्लिकेशनों के लिए प्रतिस्पर्धी है।

निम्न उदाहरण एक इवेंट असिस्टेंट बनाता है जो किसी इवेंट के आरंभ समय को प्राप्त करने के लिए Python फ़ंक्शन को कॉल कर सकता है।

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

एजेंट किसी विशेष शहर के लिए इवेंट समय प्राप्त करने की ज़रूरत होने पर इस फ़ंक्शन को एक टूल की तरह उपयोग करता है।

8. Claude Agent SDK

Claude Agent SDK Anthropic का Python और TypeScript फ्रेमवर्क है, जो उसी एजेंट लूप, टूल्स, और कॉन्टेक्स्ट मैनेजमेंट का उपयोग करके स्वायत्त एजेंट बनाने के लिए है जो Claude Code को संचालित करते हैं। यह विशेष रूप से उन एजेंटों के लिए उपयोगी है जिन्हें फ़ाइलें पढ़ने, कोड संपादित करने, कमांड चलाने, MCP टूल्स से कनेक्ट होने, और लंबे कार्य पूरे करने की आवश्यकता होती है।

Anthropic, OpenAI, और Google अपने मॉडलों को अपने स्वयं के एजेंट फ्रेमवर्क के साथ निकटता से एकीकृत करते हैं, जिससे टूल्स, सेशंस, ट्रेसिंग, और अन्य उन्नत सुविधाएँ जल्दी सेटअप हो जाती हैं।

हालाँकि, Claude Agent SDK को विशेष रूप से Claude के लिए डिज़ाइन किया गया है, न कि मनमाने ओपन-सोर्स या लोकल होस्टेड मॉडलों के लिए। आप हमारे Claude Agent SDK ट्यूटोरियल में इसके बारे में अधिक जान सकते हैं।

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

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

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

मल्टी-एजेंट ऑर्केस्ट्रेशन फ्रेमवर्क

मल्टी-एजेंट फ्रेमवर्क कई विशिष्ट एजेंटों का समन्वय करते हैं, जहाँ प्रत्येक एजेंट को बड़े वर्कफ़्लो में एक विशिष्ट भूमिका, लक्ष्य, टूलसेट, या चरण सौंपा जाता है। 

9. CrewAI

CrewAI मल्टी-एजेंट टीम बनाने के लिए एक लोकप्रिय Python फ्रेमवर्क है। डेवलपर्स विभिन्न भूमिकाओं, लक्ष्यों, और कार्यों के साथ एजेंट बना सकते हैं, फिर उन्हें एक क्रू में जोड़ सकते हैं जो स्वतः मिलकर काम करता है। कार्य क्रमिक रूप से चल सकते हैं या एक पदानुक्रमित प्रक्रिया के माध्यम से, जहाँ एक मैनेजर सबसे उपयुक्त एजेंटों को समन्वित और कार्य सौंपता है।

निम्न Python उदाहरण एक रिसर्चर और राइटर बनाता है जो मिलकर एक छोटा रिपोर्ट तैयार करते हैं।

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

रिसर्चर पहला कार्य पूरा करता है, और राइटर उसके आउटपुट को संदर्भ के रूप में उपयोग करके अंतिम रिपोर्ट बनाता है।

10. MetaGPT

MetaGPT एक मल्टी-एजेंट फ्रेमवर्क है जो एक सॉफ्टवेयर कंपनी का मॉडल बनाता है—जैसे प्रोडक्ट मैनेजर, आर्किटेक्ट, प्रोजेक्ट मैनेजर, और इंजीनियर जैसे विशिष्ट एजेंटों के साथ। ये एजेंट संरचित ऑपरेटिंग प्रोसीजर का पालन करते हैं ताकि एक छोटे से रिक्वायरमेंट को योजनाओं, तकनीकी डिज़ाइनों, दस्तावेज़ों, और कार्यशील कोड में बदला जा सके। 

निम्न उदाहरण एक सॉफ्टवेयर टीम बनाता है और उसे एक सरल कमांड-लाइन टास्क मैनेजर बनाने के लिए कहता है।

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

एजेंट अपने-अपने रोल के अनुसार रिक्वायरमेंट्स को बाँटते हैं और सॉफ्टवेयर प्रोजेक्ट की योजना व विकास के लिए सहयोग करते हैं। 

11. AgentScope

AgentScope नियंत्रित और अवलोकनीय एजेंटों तथा मल्टी-एजेंट एप्लिकेशन बनाने के लिए एक Python फ्रेमवर्क है। यह रेडी-मेड एजेंट, टूल्स, मेमोरी, मैसेज रूटिंग, स्ट्रीमिंग, पैरेलल टूल कॉल्स, वर्कफ़्लोज़, ट्रेसिंग, और मानव हस्तक्षेप प्रदान करता है। AgentScope Studio का उपयोग एजेंट के एक्ज़ीक्यूशन का निरीक्षण और विज़ुअलाइज़ेशन करने के लिए भी किया जा सकता है।

निम्न उदाहरण एक ReAct एजेंट बनाता है जो गणना पूरी करने के लिए Python कोड लिख और चला सकता है।

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

एजेंट Python निष्पादन टूल को कॉल करने का निर्णय लेता है, जनरेटेड कोड चलाता है, और परिणाम का उपयोग करके उपयोगकर्ता को उत्तर देता है।

12. CAMEL-AI

CAMEL-AI एजेंट, मल्टी-एजेंट सोसायटीज़, और रोल-प्लेइंग सिमुलेशंस बनाने के लिए एक ओपन-सोर्स Python फ्रेमवर्क है। इसका शोध पर विशेष ध्यान है और यह एजेंट सहयोग, टूल्स, मेमोरी, रिट्रीवल, डेटा जेनरेशन, और वर्ल्ड सिमुलेशन के लिए कॉम्पोनेंट्स प्रदान करता है। यह Ollama, vLLM, और SGLang जैसे प्लेटफॉर्म्स के माध्यम से क्लाउड और लोकल होस्टेड मॉडलों का भी समर्थन करता है।

निम्न उदाहरण एक ऐसा एजेंट बनाता है जो उत्तर देने से पहले वेब पर खोज कर सकता है।

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

एजेंट को जब वर्तमान जानकारी चाहिए होती है तो वह DuckDuckGo सर्च का उपयोग करता है और फिर अंतिम उत्तर लौटाता है।

डेटा और RAG एजेंट फ्रेमवर्क

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

13. LlamaIndex

LlamaIndex निजी या डोमेन-विशिष्ट डेटा पर संदर्भ-सचेत एप्लिकेशन बनाने के लिए एक Python फ्रेमवर्क है। यह RAG, एंटरप्राइज़ सर्च, और दस्तावेज़ सहायक जैसे एप्लिकेशन के लिए कनेक्टर्स, इंडेक्सेस, रिट्रीवर्स, क्वेरी इंजन, एजेंट्स, और वर्कफ़्लोज़ प्रदान करता है।

जब मैंने RAG एप्लिकेशन बनाना शुरू किया, तब LlamaIndex मेरे पसंदीदा फ्रेमवर्क में से एक था। यह डेटा लोड करना, इंडेक्स करना, और क्वेरी करना बेहद आसान बनाता है, और अक्सर मैं पाता/पाती हूँ कि इसका कोड LangChain के साथ वही एप्लिकेशन बनाने की तुलना में सरल और छोटा होता है। अधिक जानने के लिए आप LlamaIndex कोर्स कर सकते हैं।

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

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndex डेटा फ़ोल्डर के अंदर की फ़ाइलों को इंडेक्स करता है और उत्तर जनरेट करने से पहले प्रासंगिक जानकारी रिट्रीव करता है।

14. Haystack

Haystack प्रोडक्शन-रेडी RAG पाइपलाइंस, सेमांटिक सर्च सिस्टम, एजेंट्स, और डेटा-केंद्रित AI एप्लिकेशन बनाने के लिए एक ओपन-सोर्स Python फ्रेमवर्क है। इसकी मॉड्यूलर पाइपलाइन संरचना यह स्पष्ट नियंत्रण देती है कि जानकारी कैसे रिट्रीव की जाए, प्रॉम्प्ट में कैसे जोड़ी जाए, और मॉडल को कैसे भेजी जाए।

मैंने Haystack का उपयोग RAG और मल्टी-एजेंट एप्लिकेशन बनाने में बिना किसी बड़े मुद्दे के किया है। यद्यपि यह एक जनरल-परपज़ फ्रेमवर्क है, यह विशेष रूप से उन एप्लिकेशन के लिए उपयोगी है जो LLMs को दस्तावेज़ों, टेक्स्ट, सर्च सिस्टम, और अन्य डेटा स्रोतों से जोड़ते हैं।

निम्न उदाहरण कुछ दस्तावेज़ स्टोर करता है, सबसे प्रासंगिक दस्तावेज़ रिट्रीव करता है, और उसका उपयोग करके प्रश्न का उत्तर देता है।

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystack मेल खाते दस्तावेज़ को रिट्रीव करता है, उसे प्रॉम्प्ट में जोड़ता है, और GPT-5.5 का उपयोग करके तथ्य-आधारित उत्तर देता है।

हल्के और ओपन-मॉडल फ्रेमवर्क

ये फ्रेमवर्क होस्टेड या लोकल रूप से चलने वाले ओपन मॉडलों के साथ एजेंट बनाने के लिए सरल एब्स्ट्रैक्शंस प्रदान करते हैं।

15. Hugging Face smolagents

Hugging Face smolagents कम कोड में एजेंट बनाने के लिए एक हल्का Python फ्रेमवर्क है। इसका CodeAgent Python लिखकर क्रियाएँ करता है, जबकि ToolCallingAgent स्ट्रक्चर्ड टूल कॉल्स का उपयोग करता है। यह Hugging Face मॉडलों, Inference Providers, और लोकल होस्टेड ओपन-सोर्स मॉडलों के साथ विशेष रूप से अच्छा काम करता है।

निम्न उदाहरण एक वेब-सर्च एजेंट बनाता है और उसे एक मैनेजर एजेंट को देता है जो तय करता है कि कब रिसर्च डेलिगेट करनी है।

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

मैनेजर तय करता है कि कब वर्तमान जानकारी की आवश्यकता है, खोज को विशेषज्ञ वेब एजेंट को सौंपता है, और फिर अंतिम उत्तर तैयार करता है।

त्वरित फ्रेमवर्क तुलना

नीचे दी गई तालिका प्रत्येक फ्रेमवर्क की मुख्य ताकत और वह किस प्रकार के एजेंटिक AI एप्लिकेशन के लिए सबसे उपयुक्त है, इसकी तुलना करती है।

अंतिम विचार

यदि आप एजेंटिक AI की शुरुआत कर रहे हैं, तो मैं OpenAI Agents SDK जैसे किसी आधिकारिक SDK, Google ADK, या Claude Agent SDK से शुरू करूँगा/करूँगी। ये अपने मॉडलों और APIs के साथ निकटता से काम करते हैं, इसलिए सेटअप आमतौर पर सरल होता है। आप एक API कुंजी जोड़ते हैं, कुछ क्रेडिट्स लोड करते हैं, और बनाना शुरू कर देते हैं।

मुझे ये SDKs पसंद हैं क्योंकि वे एजेंट बनाना, टूल्स कनेक्ट करना, और किसी रन के दौरान क्या हुआ इसका निरीक्षण करना आसान बनाते हैं। केवल कुछ पंक्तियों के Python कोड से, आप उपयोगी एजेंट या एक छोटा मल्टी-एजेंट सिस्टम भी बना सकते हैं।

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

विभिन्न भूमिकाओं वाली एजेंट टीमों के लिए CrewAI एक अच्छा विकल्प है। RAG, निजी दस्तावेज़, और डेटा-कनेक्टेड एप्लिकेशन के लिए, मैं LlamaIndex या Haystack चुनूँगा/चुनूँगी।

अंत में, जब मुझे कुछ हल्का, सरल, और ओपन या लोकल मॉडलों के साथ उपयोग में आसान चाहिए, तो smolagents एक अच्छा विकल्प है।

मेरी सलाह है कि अपने प्रोजेक्ट के अनुरूप सबसे सरल फ्रेमवर्क से शुरू करें। एक छोटा संस्करण बनाइए, उसे ठीक से टेस्ट कीजिए, और केवल तब ही अधिक जटिलता जोड़िए जब वास्तव में आवश्यकता हो।