Топ‑15 фреймворков на Python для создания полноценных агентных ИИ‑приложений

Создавать агентные ИИ‑приложения теперь гораздо проще, чем несколько лет назад. Вместо того чтобы писать с нуля циклы агента, интеграции с инструментами, память, поиск и оркестрацию, разработчики могут использовать Python‑фреймворки, которые уже предоставляют большинство этих компонентов.

Многие фреймворки из этой статьи применялись для создания RAG‑приложений, автономных агентов, мультиагентных систем и развёртываемых ИИ‑инструментов.

Часто используется LangChain для гибких агентных процессов, LlamaIndex и Haystack для приложений, работающих с данными, а OpenAI Agents SDK или Google ADK — когда нужна быстрая интеграция с моделями провайдеров.

Некоторые из этих фреймворков настолько продвинулись, что необходимость в самописных решениях возникает всё реже. Имея API‑ключ, немного кредитов на модели и подходящий фреймворк, вы можете создать агента, подключить его к инструментам или закрытым данным, протестировать и развернуть через API или пользовательский интерфейс.

В этой статье сравниваются 15 Python‑фреймворков в пяти категориях: универсальные агентные фреймворки, официальные SDK для агентов, фреймворки оркестрации мультиагентов, фреймворки для данных и RAG, а также лёгкие фреймворки с открытыми моделями.

Каждый раздел включает короткий пример на Python, который можно скопировать, вставить и запустить, чтобы быстро понять принцип работы фреймворка.

Универсальные агентные фреймворки

Эти фреймворки предоставляют широкие строительные блоки для создания агентов, подключения инструментов, управления состоянием и контроля многошаговых процессов.

1. LangChain

Для многих разработчиков современная разработка приложений на базе LLM началась с LangChain — открытого Python‑фреймворка, созданного для подключения языковых моделей к внешним данным, инструментам, API и логике приложений. Он стал одним из первых широко принятых фреймворков для использования OpenAI API вместе с сайтами, документами, векторными базами и другими источниками данных для создания более контекстных приложений.

Сегодня LangChain превратился в полноценную экосистему для создания сквозных агентных ИИ‑приложений, включая 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, помогающую публиковать агентов через API, хранить сессии и трейсы и управлять ими как продакшн‑приложениями. Поскольку он может работать на вашей инфраструктуре, организации получают больший контроль над данными и безопасностью.

Ниже пример исследовательского агента, который ищет информацию в интернете и затем формирует краткий ответ.

# 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 — нативный для Python фреймворк от команды Pydantic для создания агентов и генеративных ИИ‑приложений. По ощущениям он напоминает работу с моделями 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, прежде чем вернуть его.

Официальные SDK для агентов

Официальные SDK поддерживаются ИИ‑провайдерами и обычно обеспечивают самую простую интеграцию с их моделями, API, инструментами, системами развёртывания и платформами наблюдаемости.

5. OpenAI Agents SDK

OpenAI Agents SDK — это лёгкий фреймворк с приоритетом Python для создания одноагентных и мультиагентных приложений. Предоставляет встроенный цикл агента, функциональные инструменты, передачи задач, защитные механизмы, сессии, подтверждения человеком и трейсинг без избыточных абстракций.

OpenAI Agents SDK нравится за простоту, скорость интеграции и понятность. На нём удалось создать множество приложений без серьёзных проблем. Он также автоматически создаёт трейсы, которые видны в OpenAI Dashboard, что упрощает анализ ответов модели, вызовов инструментов, передач задач и всего хода выполнения.

Ниже создаётся агент‑историк, который может вызывать функцию на 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

Agent Development Kit от Google (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 — Python‑ и TypeScript‑фреймворк от Anthropic для создания автономных агентов с тем же циклом агента, инструментами и управлением контекстом, что и в 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

Эти фреймворки помогают подключать LLM и агентов к документам, базам данных, API и другим закрытым источникам, чтобы извлекать релевантный контекст перед ответом.

13. LlamaIndex

LlamaIndex — Python‑фреймворк для создания контекстных приложений поверх закрытых или предметно‑ориентированных данных. Предоставляет коннекторы, индексы, ретриверы, движки запросов, агентов и рабочие процессы для приложений наподобие RAG, корпоративного поиска и помощников по документам.

LlamaIndex был одним из любимых фреймворков в начале работы над RAG‑приложениями. Он крайне упрощает загрузку, индексацию и запрос данных, и часто его код оказывается проще и короче, чем при создании того же в 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 индексирует файлы в папке data и извлекает релевантную информацию перед генерацией ответа.

14. Haystack

Haystack — открытый Python‑фреймворк для создания готовых к продакшну RAG‑конвейеров, систем семантического поиска, агентов и data‑ориентированных ИИ‑приложений. Его модульная структура пайплайнов даёт чёткий контроль над тем, как информация извлекается, добавляется в промпт и передаётся модели.

Haystack применялся для создания RAG‑ и мультиагентных приложений без серьёзных проблем. Хотя это и универсальный фреймворк, он особенно полезен для приложений, которые подключают LLM к документам, тексту, поисковым системам и другим источникам данных.

Следующий пример сохраняет несколько документов, извлекает наиболее релевантный и использует его для ответа на вопрос.

# 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 и локально размещёнными открытыми моделями.

Следующий пример создаёт агента для веб‑поиска и передаёт его менеджеру‑агенту, который решает, когда делегировать исследование.

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

Менеджер решает, когда нужна актуальная информация, делегирует поиск специализированному веб‑агенту и затем формирует финальный ответ.

Быстрое сравнение фреймворков

Таблица ниже сравнивает основную сильную сторону каждого фреймворка и тип агентных ИИ‑приложений, для которых он подходит лучше всего.

Заключение

Если вы только начинаете работать с агентным ИИ, стоит стартовать с официального SDK, например OpenAI Agents SDK, Google ADK или Claude Agent SDK. Они тесно интегрированы со своими моделями и API, поэтому настройка обычно проста: добавить API‑ключ, пополнить кредиты и начинать разработку.

Эти SDK удобны тем, что упрощают создание агентов, подключение инструментов и анализ хода выполнения. Всего несколькими строками Python можно собрать полезного агента или даже небольшой мультиагентный комплекс.

Когда нужна большая гибкость, обычно выбираются LangChain или LangGraph. LangChain полезен при необходимости множества интеграций, а LangGraph даёт больше контроля над состоянием, циклами и длинными процессами.

Для команд агентов с разными ролями хорошо подходит CrewAI. Для RAG, закрытых документов и приложений, работающих с данными, — LlamaIndex или Haystack.

Наконец, smolagents — удачный выбор, когда нужно что‑то лёгкое, простое и удобное для открытых или локальных моделей.

Совет: начните с самого простого фреймворка, подходящего под ваш проект. Соберите небольшой прототип, тщательно протестируйте и добавляйте сложность только тогда, когда это действительно необходимо.