Topp 15 Python-ramverk för att bygga kompletta agentiska AI-applikationer

Att bygga agentiska AI‑applikationer är nu mycket enklare än för bara några år sedan. I stället för att skapa agentslingor, verktygsintegrationer, minne, hämtning och orkestrering från grunden kan utvecklare använda Python‑ramverk som redan tillhandahåller det mesta av detta.

Jag har använt många av ramverken i den här artikeln för att bygga RAG‑applikationer, autonoma agenter, multiagentsystem och distribuerbara AI‑verktyg.

Jag använder ofta LangChain för flexibla agentarbetsflöden, LlamaIndex och Haystack för datakopplade applikationer, och OpenAI Agents SDK eller Google ADK när jag vill ha snabbare integration med leverantörsmodeller.

Några av dessa ramverk har förbättrats så mycket att en specialbyggd lösning ofta är onödig. Med en API‑nyckel, några modellkrediter och rätt ramverk kan du skapa en agent, koppla den till verktyg eller privat data, testa den och distribuera den via ett API eller ett användargränssnitt.

Den här artikeln jämför 15 Python‑ramverk inom fem kategorier: allmänna agentramverk, officiella agent‑SDK:er, orkestreringsramverk för multiagenter, data- och RAG‑ramverk samt lättviktiga ramverk för öppna modeller.

Varje avsnitt innehåller också ett kort Python‑exempel som du kan kopiera, klistra in och testa för att snabbt förstå hur ramverket fungerar.

Allmänna agentramverk

Dessa ramverk tillhandahåller breda byggblock för att skapa agenter, koppla verktyg, hantera tillstånd och styra flerstegade arbetsflöden.

1. LangChain

För många utvecklare började modern LLM‑apputveckling med LangChain, ett öppet Python‑ramverk utformat för att koppla språkmodeller till extern data, verktyg, API:er och applikationslogik. Det blev ett av de första brett antagna ramverken för att använda OpenAI‑API:et med webbplatser, dokument, vektordatabaser och andra datakällor för att bygga mer kontextmedvetna applikationer.

I dag har LangChain utvecklats till ett komplett ekosystem för att bygga end‑to‑end agentiska AI‑applikationer, inklusive RAG‑system, verktygsanvändande agenter, arbetsflöden, integrationer, övervakning och utvärdering. Jag rekommenderar att du kollar in spåret AI Engineering with LangChain för att lära dig mer.

Följande exempel skapar en enkel LangChain‑agent som kan använda ett dokumentationssökverktyg för att hitta relevant information innan den svarar på en fråga.

# 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

Medan LangChain gör det enkelt att skapa agenter och verktyg, ger LangGraph mer kontroll över hur de agenterna fungerar. Det låter utvecklare strukturera en applikation som en graf av sammankopplade steg, vilket gör det lättare att kontrollera slingor, verktygsanrop, delat tillstånd, mänskliga godkännanden och multiagentarbetsflöden.

Jag tycker att det är särskilt användbart när jag bygger autonoma agenter som upprepade gånger måste bestämma vad de ska göra, välja rätt verktyg, kontrollera resultatet och fortsätta tills uppgiften är klar. LangGraph stöder också persistens, streaming, kontrollpunkter och återhämtning för längre körande applikationer. Vår LangGraph‑guide ger fler detaljer.

Följande exempel skapar en agent som upprepade gånger kan anropa kalkylatorverktyg tills den har tillräcklig information för att svara:

# 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)

Grafen skickar förfrågan till modellen, kör nödvändiga verktyg och loopar tillbaka till modellen tills den producerar ett slutgiltigt svar.

3. Agno

Agno är ett Python‑ramverk för att bygga agenter, multiagentteam och strukturerade arbetsflöden. Det inkluderar även AgentOS, som hjälper utvecklare att exponera agenter via API:er, lagra sessioner och spår, samt hantera dem som produktionsapplikationer. Eftersom det kan köras i din egen infrastruktur behåller organisationer större kontroll över data och säkerhet.

Följande exempel skapar en forskningsagent som kan söka på webben innan den ger ett koncist svar.

# 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,
)

Agenten använder sökverktyget för att hitta aktuell information och strömmar en kort sammanfattning till användaren.

4. Pydantic AI

Pydantic AI är ett Python‑inhemskt ramverk från teamet bakom Pydantic för att bygga agenter och generativa AI‑applikationer. Det känns likt att arbeta med Pydantic‑modeller eller FastAPI eftersom agenter, verktyg, beroenden och utdata definieras med vanliga Python‑funktioner, typhintar, dekoratorer och BaseModel‑klasser. Det använder sedan Pydantic‑validering för att hålla verktygsargument och modellutdata strukturerade och tillförlitliga.

Jag kan rekommendera guiden för Pydantic AI för att lära dig mer om ramverket.

Följande exempel skapar en agent som returnerar en validerad artikelplan som en Pydantic‑modell.

# 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)

Agenten genererar ett ArticlePlan‑objekt och validerar att varje fält matchar den kräva Python‑typen och reglerna innan det returneras.

Officiella agent‑SDK:er

Officiella agent‑SDK:er underhålls av AI‑leverantörer och erbjuder vanligtvis den enklaste integrationen med deras modeller, API:er, verktyg, driftsättningssystem och observabilitetsplattformar.

5. OpenAI Agents SDK

OpenAI Agents SDK är ett lättviktigt, Python‑först‑ramverk för att bygga enkel‑ och multiagentapplikationer. Det tillhandahåller en inbyggd agentslinga, funktionsverktyg, handoffs, skyddsräcken, sessioner, mänskliga godkännanden och spårning utan att lägga till för många abstraktioner.

Jag gillar att använda OpenAI Agents SDK eftersom det är enkelt, snabbt att integrera och lätt att förstå. Jag har byggt många applikationer med det utan större problem. Det skapar också automatiskt spår som kan visas i OpenAI‑panelen, vilket gör det enkelt att inspektera modellsvar, verktygsanrop, handoffs och hela exekveringsflödet.

Följande exempel skapar en historikagent som kan anropa en Python‑funktion för att hämta ett överraskande historiskt faktum.

# 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:et kör agenten, anropar historikverktyget vid behov, returnerar dess resultat till modellen och producerar det slutliga svaret. Hela körningen kan också inspekteras via spårningsvyn.

7. Google Agent Development Kit

Googles Agent Development Kit, eller ADK, är ett öppet ramverk för att bygga, utvärdera och distribuera individuella agenter, verktygsanvändande assistenter, grafarbetsflöden och multiagentsystem. Det fungerar särskilt väl med Gemini‑modeller, men stöder även andra modellleverantörer.

ADK har blivit ett av mina favoritramverk eftersom det är enkelt och fungerar naturligt med Gemini.

Jag har använt det för att bygga flera applikationer utan större problem. Även om jag fortfarande tycker att OpenAI Agents SDK är enklare att integrera och mer flexibelt när det gäller kontroller och inbyggda funktioner, är ADK ett starkt alternativ och särskilt konkurrenskraftigt för Gemini‑baserade applikationer.

Följande exempel skapar en eventassistent som kan anropa en Python‑funktion för att hämta ett events starttid.

# 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],
)

Agenten använder funktionen som ett verktyg när den behöver hämta eventtiden för en viss stad.

8. Claude Agent SDK

Claude Agent SDK är Anthropics Python‑ och TypeScript‑ramverk för att bygga autonoma agenter med samma agentslinga, verktyg och kontexthantering som driver Claude Code. Det är särskilt användbart för agenter som behöver läsa filer, redigera kod, köra kommandon, koppla till MCP‑verktyg och slutföra längre uppgifter.

Anthropic, OpenAI och Google integrerar sina modeller tätt med sina egna agentramverk, vilket gör verktyg, sessioner, spårning och andra avancerade funktioner snabba att sätta upp.

Claude Agent SDK är dock utformat specifikt för Claude snarare än för godtyckliga öppna källkods- eller lokalt hostade modeller. Du kan lära dig mer i vår guide till Claude Agent SDK.

Följande exempel skapar en kodningsagent som granskar en Python‑fil, identifierar buggar och fixar dem automatiskt.

# 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:et kör agentslingan medan Claude läser filen, väljer nödvändiga verktyg, redigerar koden och strömmar sin framfart tills uppgiften är klar.

Orkestreringsramverk för multiagenter

Multiagentramverk koordinerar flera specialiserade agenter, där varje agent tilldelas en särskild roll, ett mål, en verktygsuppsättning eller en fas i ett större arbetsflöde. 

9. CrewAI

CrewAI är ett populärt Python‑ramverk för att bygga multiagentteam. Utvecklare kan skapa agenter med olika roller, mål och uppgifter, och sedan kombinera dem i en grupp som arbetar tillsammans autonomt. Uppgifter kan köras sekventiellt eller via en hierarkisk process där en chef koordinerar och delegerar arbete till de mest lämpliga agenterna.

Följande Python‑exempel skapar en forskare och skribent som samarbetar för att producera en kort rapport.

# 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)

Forskaren slutför den första uppgiften, och skribenten använder dess output som kontext för att skapa slutrapporten.

10. MetaGPT

MetaGPT är ett multiagentramverk som modellerar ett mjukvaruföretag med specialiserade agenter som produktchef, arkitekt, projektledare och ingenjör. Dessa agenter följer strukturerade arbetsmetoder för att omvandla ett kort krav till planer, tekniska designer, dokumentation och fungerande kod. 

Följande exempel skapar ett mjukvaruteam och ber det bygga en enkel kommandoradsbaserad uppgiftshanterare.

# 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")
    )

Agenterna delar upp kraven mellan sina olika roller och samarbetar för att planera och utveckla mjukvaruprojektet. 

11. AgentScope

AgentScope är ett Python‑ramverk för att bygga kontrollerbara och observerbara agenter och multiagentapplikationer. Det tillhandahåller färdiga agenter, verktyg, minne, meddelanderouting, streaming, parallella verktygsanrop, arbetsflöden, spårning och mänsklig intervention. AgentScope Studio kan också användas för att inspektera och visualisera agentkörningar.

Följande exempel skapar en ReAct‑agent som kan skriva och köra Python‑kod för att slutföra en beräkning.

# 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())

Agenten beslutar att anropa verktyget för Python‑exekvering, kör den genererade koden och använder resultatet för att svara användaren.

12. CAMEL-AI

CAMEL-AI är ett öppet Python‑ramverk för att bygga agenter, multiagentsamhällen och rollspelssimuleringar. Det har ett starkt forskningsfokus och erbjuder komponenter för agentsamarbete, verktyg, minne, hämtning, datagenerering och världssimulering. Det stöder också molnmodeller och lokalt hostade modeller via plattformar som Ollama, vLLM och SGLang.

Följande exempel skapar en agent som kan söka på webben innan den svarar på en fråga.

# 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)

Agenten använder DuckDuckGo‑sökning när den behöver aktuell information och returnerar sedan slutsvaret.

Data- och RAG‑agentramverk

Dessa ramverk hjälper till att koppla LLM:er och agenter till dokument, databaser, API:er och andra privata datakällor så att de kan hämta relevant kontext innan de svarar.

13. LlamaIndex

LlamaIndex är ett Python‑ramverk för att bygga kontextmedvetna applikationer över privat eller domänspecifik data. Det tillhandahåller konnektorer, index, hämtare, frågemotorer, agenter och arbetsflöden för applikationer som RAG, företagsök och dokumentassistenter.

LlamaIndex var ett av mina favoritramverk när jag började bygga RAG‑applikationer. Det gör det extremt enkelt att läsa in, indexera och fråga data, och jag tycker ofta att dess kod är enklare och kortare än att bygga samma applikation med LangChain. Du kan gå LlamaIndex‑kursen för att lära dig mer.

Följande exempel läser in dokument från en mapp, skapar ett sökbart index och besvarar en fråga med hjälp av hämtad kontext.

# 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 indexerar filerna i mappen data och hämtar relevant information innan svaret genereras.

14. Haystack

Haystack är ett öppet Python‑ramverk för att bygga produktionsklara RAG‑pipelines, semantiska söksystem, agenter och datafokuserade AI‑applikationer. Dess modulära pipeline‑struktur ger tydlig kontroll över hur information hämtas, läggs till i en prompt och skickas till en modell.

Jag har använt Haystack för att bygga RAG‑ och multiagentapplikationer utan större problem. Även om det är ett allmänt ramverk är det särskilt användbart för applikationer som kopplar LLM:er till dokument, text, söksystem och andra datakällor.

Följande exempel lagrar några dokument, hämtar det mest relevanta och använder det för att besvara en fråga.

# 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 hämtar det matchande dokumentet, lägger till det i prompten och använder GPT‑5.5 för att producera ett förankrat svar.

Lättviktiga ramverk och ramverk för öppna modeller

Dessa ramverk tillhandahåller enklare abstraktioner för att bygga agenter med hostade eller lokalt körande öppna modeller.

15. Hugging Face smolagents

Hugging Face smolagents är ett lättviktigt Python‑ramverk för att bygga agenter med bara lite kod. Dess CodeAgent utför åtgärder genom att skriva Python, medan ToolCallingAgent använder strukturerade verktygsanrop. Det fungerar särskilt bra med Hugging Face‑modeller, Inference Providers och lokalt hostade öppna källkodsmodeller.

Följande exempel skapar en webbsökningsagent och ger den till en manager‑agent som avgör när den ska delegera research.

# 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)

Managern avgör när den behöver aktuell information, delegerar sökningen till den specialiserade webbagenten och producerar sedan slutsvaret.

Snabb jämförelse av ramverk

Tabellen nedan jämför varje ramverks främsta styrka och vilken typ av agentisk AI‑applikation det lämpar sig bäst för.

Avslutande tankar

Om du precis börjar med agentisk AI skulle jag börja med ett officiellt SDK som OpenAI Agents SDK, Google ADK eller Claude Agent SDK. De arbetar nära sina egna modeller och API:er, så uppsättningen är vanligtvis enkel. Du lägger till en API‑nyckel, laddar på med krediter och börjar bygga.

Jag gillar dessa SDK:er eftersom de gör det enkelt att skapa agenter, koppla verktyg och inspektera vad som hände under en körning. Med bara några rader Python kan du bygga en användbar agent eller till och med ett litet multiagentsystem.

När jag behöver mer flexibilitet tittar jag vanligtvis på LangChain eller LangGraph. LangChain är användbart när jag behöver många integrationer, medan LangGraph ger mig mer kontroll över tillstånd, slingor och längre arbetsflöden.

För team av agenter med olika roller är CrewAI ett bra alternativ. För RAG, privata dokument och datakopplade applikationer skulle jag välja LlamaIndex eller Haystack.

Slutligen är smolagents ett bra val när jag vill ha något lättviktigt, enkelt och lätt att använda med öppna eller lokala modeller.

Mitt råd är att börja med det enklaste ramverk som passar ditt projekt. Bygg en liten version, testa den ordentligt och lägg bara till mer komplexitet när du faktiskt behöver det.