Os 15 principais frameworks Python para criar aplicações completas de IA agentic

Criar aplicações de IA agentic hoje é muito mais simples do que há alguns anos. Em vez de programar do zero loops de agente, integrações de ferramentas, memória, busca e orquestração, os desenvolvedores podem usar frameworks em Python que já trazem a maior parte desses componentes prontos.

Usei muitos dos frameworks deste artigo para construir aplicações de RAG, agentes autônomos, sistemas multiagentes e ferramentas de IA prontas para deploy.

Costumo usar LangChain para fluxos de trabalho flexíveis com agentes, LlamaIndex e Haystack para apps conectados a dados, e o OpenAI Agents SDK ou Google ADK quando quero integrar mais rápido com os modelos do provedor.

Alguns desses frameworks evoluíram tanto que muitas vezes não é necessário criar uma solução sob medida. Com uma chave de API, alguns créditos de modelo e o framework certo, você cria um agente, conecta a ferramentas ou dados privados, testa e faz o deploy via API ou interface.

Este artigo compara 15 frameworks Python em cinco categorias: frameworks de agentes de uso geral, SDKs oficiais de agentes, frameworks de orquestração multiagente, frameworks de dados e RAG, e frameworks leves para modelos abertos.

Cada seção também inclui um exemplo curto em Python que você pode copiar, colar e testar para entender rapidamente como o framework funciona.

Frameworks de agentes de uso geral

Esses frameworks oferecem blocos de construção amplos para criar agentes, conectar ferramentas, gerenciar estado e controlar fluxos de trabalho em várias etapas.

1. LangChain

Para muitos desenvolvedores, o desenvolvimento moderno de apps com LLM começou com o LangChain, um framework open source em Python pensado para conectar modelos de linguagem a dados externos, ferramentas, APIs e lógica de aplicação. Ele se tornou um dos primeiros frameworks amplamente adotados para usar a API da OpenAI com sites, documentos, bases vetoriais e outras fontes de dados, criando aplicações mais contextuais.

Hoje, o LangChain evoluiu para um ecossistema completo para construir aplicações de IA agentic de ponta a ponta, incluindo sistemas de RAG, agentes que usam ferramentas, workflows, integrações, monitoramento e avaliação. Recomendo conferir a trilha de aprendizado AI Engineering with LangChain para saber mais.

O exemplo a seguir cria um agente simples no LangChain que usa uma ferramenta de busca em documentação para encontrar informações relevantes antes de responder.

# 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

Enquanto o LangChain facilita criar agentes e ferramentas, o LangGraph dá mais controle sobre como esses agentes operam. Ele permite estruturar a aplicação como um grafo de etapas conectadas, o que facilita controlar loops, chamadas de ferramentas, estado compartilhado, aprovações humanas e fluxos multiagentes.

Acho especialmente útil para criar agentes autônomos que precisam decidir repetidamente o que fazer, selecionar a ferramenta certa, checar o resultado e continuar até concluir a tarefa. O LangGraph também oferece persistência, streaming, checkpoints e recuperação para aplicações de execução prolongada. Nosso tutorial de LangGraph traz mais detalhes.

O exemplo abaixo cria um agente que pode chamar ferramentas de calculadora repetidamente até ter informações suficientes para responder:

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

O grafo envia a solicitação para o modelo, executa as ferramentas necessárias e volta ao modelo até produzir a resposta final.

3. Agno

Agno é um framework em Python para construir agentes, times multiagentes e workflows estruturados. Ele também inclui o AgentOS, que ajuda a expor agentes via APIs, armazenar sessões e trilhas, e gerenciá-los como aplicações em produção. Como pode rodar na sua própria infraestrutura, as organizações mantêm maior controle sobre dados e segurança.

O exemplo a seguir cria um agente de pesquisa que pode buscar na web antes de produzir uma resposta objetiva.

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

O agente usa a ferramenta de busca para encontrar informações atuais e transmite um resumo curto para o usuário.

4. Pydantic AI

Pydantic AI é um framework Python-nativo da equipe do Pydantic para criar agentes e aplicações de IA generativa. A experiência lembra trabalhar com modelos Pydantic ou FastAPI, pois agentes, ferramentas, dependências e saídas são definidos com funções Python padrão, type hints, decoradores e classes BaseModel. Depois, o framework usa validação do Pydantic para manter argumentos de ferramentas e saídas do modelo estruturados e confiáveis.

Recomendo o tutorial de Pydantic AI para saber mais sobre o framework.

O exemplo abaixo cria um agente que retorna um plano de artigo validado como um modelo 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)

O agente gera um objeto ArticlePlan e valida que cada campo atende ao tipo e às regras exigidas em Python antes de retornar.

SDKs oficiais de agentes

SDKs oficiais são mantidos pelos provedores de IA e geralmente oferecem a integração mais simples com seus modelos, APIs, ferramentas, sistemas de deploy e plataformas de observabilidade.

5. OpenAI Agents SDK

O OpenAI Agents SDK é um framework leve e Python-first para criar aplicações com um ou vários agentes. Ele oferece loop de agente integrado, function tools, handoffs, guardrails, sessões, aprovações humanas e tracing, sem adicionar abstrações em excesso.

Gosto muito de usar o OpenAI Agents SDK porque é simples, rápido de integrar e fácil de entender. Já construí muitas aplicações com ele sem maiores problemas. Ele também cria traces automaticamente, visíveis no OpenAI Dashboard, facilitando inspecionar respostas do modelo, chamadas de ferramentas, handoffs e todo o fluxo de execução.

O exemplo abaixo cria um agente de história que pode chamar uma função Python para recuperar um fato histórico surpreendente.

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

O SDK executa o agente, chama a ferramenta de história quando necessário, retorna o resultado ao modelo e produz a resposta final. Toda a execução também pode ser inspecionada no visualizador de traces.

7. Google Agent Development Kit

O Agent Development Kit do Google, ou ADK, é um framework open source para criar, avaliar e fazer deploy de agentes individuais, assistentes que usam ferramentas, workflows em grafo e sistemas multiagentes. Ele funciona especialmente bem com modelos Gemini, embora também dê suporte a outros provedores.

O ADK se tornou um dos meus frameworks favoritos porque é simples e funciona naturalmente com o Gemini.

Já o usei para criar várias aplicações sem maiores problemas. Embora eu ainda ache o OpenAI Agents SDK mais fácil de integrar e mais flexível em termos de controles e recursos embutidos, o ADK é uma ótima alternativa — especialmente competitiva para aplicações baseadas em Gemini.

O exemplo abaixo cria um assistente de eventos que pode chamar uma função Python para obter o horário de início de um evento.

# 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],
)
O agente usa a função como ferramenta sempre que precisa obter o horário do evento para uma cidade específica.
8. Claude Agent SDK
O Claude Agent SDK é o framework em Python e TypeScript da Anthropic para criar agentes autônomos com o mesmo loop de agente, ferramentas e gestão de contexto que alimentam o Claude Code. É particularmente útil para agentes que precisam ler arquivos, editar código, executar comandos, conectar-se a ferramentas MCP e concluir tarefas longas.
Anthropic, OpenAI e Google integram seus modelos de perto com seus próprios frameworks de agentes, tornando rápidas a configuração de ferramentas, sessões, tracing e outros recursos avançados.
No entanto, o Claude Agent SDK é projetado especificamente para o Claude, e não para modelos open source arbitrários ou hospedados localmente. Você pode saber mais no nosso tutorial do Claude Agent SDK.
O exemplo a seguir cria um agente de código que revisa um arquivo Python, identifica bugs e os corrige automaticamente.
# 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())
O SDK executa o loop do agente enquanto o Claude lê o arquivo, seleciona as ferramentas necessárias, edita o código e transmite o progresso até concluir a tarefa.
Frameworks de orquestração multiagente
Frameworks multiagentes coordenam vários agentes especializados, com cada agente assumindo um papel, objetivo, conjunto de ferramentas ou etapa específica dentro de um workflow maior. 
9. CrewAI
CrewAI é um framework popular em Python para montar times multiagentes. Os desenvolvedores criam agentes com papéis, objetivos e tarefas diferentes e os combinam em uma equipe que trabalha de forma autônoma. As tarefas podem rodar de forma sequencial ou por um processo hierárquico em que um gerente coordena e delega o trabalho aos agentes mais adequados.
O exemplo em Python abaixo cria um pesquisador e um redator que colaboram para produzir um relatório curto.
# 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)
O pesquisador conclui a primeira tarefa, e o redator usa sua saída como contexto para criar o relatório final.
10. MetaGPT
MetaGPT é um framework multiagente que modela uma empresa de software usando agentes especializados como product manager, arquiteto, project manager e engenheiro. Esses agentes seguem procedimentos operacionais estruturados para transformar um requisito curto em planos, designs técnicos, documentação e código funcionando. 
O exemplo abaixo cria uma equipe de software e pede para construir um gerenciador de tarefas em linha de comando.
# 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")
    )
Os agentes dividem os requisitos entre seus diferentes papéis e colaboram para planejar e desenvolver o projeto de software. 
11. AgentScope
AgentScope é um framework em Python para construir agentes controláveis e observáveis e aplicações multiagentes. Ele oferece agentes prontos, ferramentas, memória, roteamento de mensagens, streaming, chamadas de ferramentas em paralelo, workflows, tracing e intervenção humana. O AgentScope Studio também pode ser usado para inspecionar e visualizar a execução dos agentes.
O exemplo seguinte cria um agente ReAct que consegue escrever e executar código Python para concluir um cálculo.
# 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())
O agente decide chamar a ferramenta de execução em Python, roda o código gerado e usa o resultado para responder ao usuário.
12. CAMEL-AI
CAMEL-AI é um framework open source em Python para criar agentes, sociedades multiagentes e simulações de role-playing. Tem forte foco em pesquisa e oferece componentes para colaboração entre agentes, ferramentas, memória, recuperação, geração de dados e simulação de mundos. Também dá suporte a modelos na nuvem e locais por meio de plataformas como Ollama, vLLM e SGLang.
O exemplo abaixo cria um agente que pode pesquisar na web antes de responder a uma pergunta.
# 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)
O agente usa a busca do DuckDuckGo quando precisa de informações atuais e depois retorna a resposta final.
Frameworks de dados e RAG
Esses frameworks conectam LLMs e agentes a documentos, bancos de dados, APIs e outras fontes de dados privadas para recuperar contexto relevante antes de responder.
13. LlamaIndex
LlamaIndex é um framework em Python para criar aplicações conscientes de contexto sobre dados privados ou de domínio específico. Ele oferece conectores, índices, recuperadores, mecanismos de consulta, agentes e workflows para aplicações como RAG, busca corporativa e assistentes de documentos.
O LlamaIndex foi um dos meus frameworks favoritos quando comecei a construir aplicações de RAG. Ele torna carregar, indexar e consultar dados extremamente simples, e muitas vezes acho seu código mais direto e curto do que construir o mesmo app com LangChain. Você pode fazer o curso de LlamaIndex para aprender mais.
O exemplo a seguir carrega documentos de uma pasta, cria um índice pesquisável e responde a uma pergunta usando o contexto recuperado.
# 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)
O LlamaIndex indexa os arquivos dentro da pasta data e recupera informações relevantes antes de gerar a resposta.
14. Haystack
Haystack é um framework open source em Python para construir pipelines de RAG prontos para produção, sistemas de busca semântica, agentes e aplicações de IA orientadas a dados. Sua estrutura modular de pipeline dá controle claro sobre como a informação é recuperada, adicionada ao prompt e enviada ao modelo.
Usei o Haystack para criar aplicações de RAG e multiagente sem grandes problemas. Embora seja um framework de uso geral, ele é especialmente útil para apps que conectam LLMs a documentos, texto, sistemas de busca e outras fontes de dados.
O exemplo abaixo armazena alguns documentos, recupera o mais relevante e o usa para responder a uma pergunta.
# 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)
O Haystack recupera o documento correspondente, o adiciona ao prompt e usa o GPT-5.5 para produzir uma resposta fundamentada.
Frameworks leves e com modelos abertos
Esses frameworks oferecem abstrações mais simples para criar agentes com modelos abertos hospedados ou locais.
15. Hugging Face smolagents
Hugging Face smolagents é um framework leve em Python para criar agentes com pouca quantidade de código. O CodeAgent executa ações escrevendo Python, enquanto o ToolCallingAgent usa chamadas de ferramentas estruturadas. Ele funciona especialmente bem com modelos do Hugging Face, Inference Providers e modelos open source hospedados localmente.
O exemplo abaixo cria um agente de busca na web e o entrega a um agente gerente que decide quando delegar a pesquisa.
# 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)
O gerente decide quando precisa de informações atuais, delega a busca ao agente especialista e então produz a resposta final.
Comparativo rápido entre frameworks
A tabela abaixo compara o principal ponto forte de cada framework e o tipo de aplicação de IA agentic para o qual ele é mais indicado.





Framework


Ponto forte


Escolha quando




LangChain


Grande ecossistema de integrações


Você precisa de integrações amplas, ferramentas e flexibilidade




LangGraph


Orquestração com grafo e estado


Você precisa de loops controlados, execução durável e workflows complexos




Agno


Plataforma completa de agentes


Você quer criar, auto-hospedar e gerenciar serviços de agentes




Pydantic AI


Desenvolvimento Python com tipos seguros


Você precisa de ferramentas validadas, dependências e saídas estruturadas




OpenAI Agents SDK


Desenvolvimento simples e tracing


Você usa principalmente modelos OpenAI e quer integração rápida




Google ADK


Desenvolvimento nativo para Gemini


Você usa Gemini, Google Cloud ou workflows multiagentes




Claude Agent SDK


Ferramentas para computador, arquivos e comandos


Você está criando agentes de código, pesquisa ou de longa duração com o Claude




CrewAI


Times de agentes por papel


Vários agentes especializados precisam colaborar em um projeto




MetaGPT


Simulação de empresa de software


Você quer que agentes planejem e gerem projetos de software completos




AgentScope


Agentes observáveis e controláveis


Você precisa de agentes rastreáveis ou aplicações multiagentes




CAMEL-AI


Pesquisa e simulação multiagente


Você estuda role-playing, sociedades de agentes ou grandes sistemas de agentes




LlamaIndex


Aplicações conectadas a dados e conscientes de contexto


Seus agentes precisam recuperar e raciocinar sobre documentos privados




Haystack


Pipelines de RAG modulares e transparentes


Você precisa de controle sobre recuperação, prompting e fluxo de dados




smolagents


Agentes leves com modelos abertos


Você quer mínimas abstrações, agentes que escrevem código ou suporte a modelos locais





Considerações finais
Se você está começando com IA agentic, eu começaria por um SDK oficial como o OpenAI Agents SDK, Google ADK ou Claude Agent SDK. Eles trabalham de perto com seus próprios modelos e APIs, então a configuração costuma ser simples. Você adiciona uma chave de API, carrega alguns créditos e começa a construir.
Gosto desses SDKs porque facilitam criar agentes, conectar ferramentas e inspecionar o que aconteceu durante a execução. Com poucas linhas de Python, dá para criar um agente útil ou até um pequeno sistema multiagente.
Quando preciso de mais flexibilidade, geralmente recorro ao LangChain ou LangGraph. O LangChain é útil quando preciso de muitas integrações, enquanto o LangGraph me dá mais controle de estado, loops e workflows longos.
Para times de agentes com papéis diferentes, o CrewAI é uma boa opção. Para RAG, documentos privados e apps conectados a dados, eu escolheria LlamaIndex ou Haystack.
Por fim, o smolagents é uma ótima escolha quando quero algo leve, simples e fácil de usar com modelos abertos ou locais.
Meu conselho é começar pelo framework mais simples que atenda ao seu projeto. Construa uma versão pequena, teste bem e só aumente a complexidade quando realmente precisar.