Los 15 mejores frameworks de Python para crear aplicaciones de IA agentica de principio a fin

Crear aplicaciones de IA agentica ahora es mucho más sencillo que hace unos años. En lugar de programar desde cero los bucles del agente, las integraciones con herramientas, la memoria, la recuperación y la orquestación, los desarrolladores pueden usar frameworks de Python que ya incluyen la mayor parte de estos componentes.

He utilizado muchos de los frameworks de este artículo para crear aplicaciones RAG, agentes autónomos, sistemas multiagente y herramientas de IA listas para desplegar.

A menudo uso LangChain para flujos de trabajo de agentes flexibles, LlamaIndex y Haystack para aplicaciones conectadas a datos, y el OpenAI Agents SDK o Google ADK cuando quiero integrar más rápido con los modelos del proveedor.

Algunos de estos frameworks han mejorado tanto que muchas veces no merece la pena crear una solución a medida. Con una clave de API, algunos créditos de modelo y el framework adecuado, puedes crear un agente, conectarlo a herramientas o datos privados, probarlo y desplegarlo a través de una API o una interfaz de usuario.

Este artículo compara 15 frameworks de Python en cinco categorías: frameworks de agentes de propósito general, SDK oficiales de agentes, frameworks de orquestación multiagente, frameworks de datos y RAG, y frameworks ligeros con modelos abiertos.

Cada sección incluye también un breve ejemplo en Python que puedes copiar, pegar y probar para entender rápidamente cómo funciona el framework.

Frameworks de agentes de propósito general

Estos frameworks aportan piezas de construcción amplias para crear agentes, conectar herramientas, gestionar el estado y controlar flujos de trabajo de varios pasos.

1. LangChain

Para muchos desarrolladores, el desarrollo moderno de aplicaciones con LLM empezó con LangChain, un framework open-source de Python diseñado para conectar modelos de lenguaje con datos externos, herramientas, APIs y lógica de aplicación. Fue uno de los primeros frameworks adoptados de forma masiva para usar la API de OpenAI con sitios web, documentos, bases de datos vectoriales y otras fuentes de datos para crear aplicaciones más conscientes del contexto.

Hoy, LangChain ha evolucionado hasta convertirse en un ecosistema completo para crear aplicaciones de IA agentica de principio a fin, incluidos sistemas RAG, agentes que usan herramientas, workflows, integraciones, monitorización y evaluación. Te recomiendo echar un vistazo al itinerario de aprendizaje AI Engineering with LangChain para saber más.

El siguiente ejemplo crea un agente sencillo de LangChain que puede usar una herramienta de búsqueda en la documentación para encontrar información relevante 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

Aunque LangChain facilita la creación de agentes y herramientas, LangGraph ofrece más control sobre cómo operan esos agentes. Permite estructurar una aplicación como un grafo de pasos conectados, lo que facilita controlar bucles, llamadas a herramientas, estado compartido, aprobaciones humanas y flujos de trabajo multiagente.

Lo encuentro especialmente útil para construir agentes autónomos que deben decidir repetidamente qué hacer, elegir la herramienta adecuada, comprobar el resultado y continuar hasta completar la tarea. LangGraph también admite persistencia, streaming, checkpoints y recuperación para aplicaciones de ejecución prolongada. Nuestro tutorial de LangGraph ofrece más detalles.

El siguiente ejemplo crea un agente que puede llamar repetidamente a herramientas de calculadora hasta tener suficiente información 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)

El grafo envía la petición al modelo, ejecuta las herramientas necesarias y vuelve al modelo hasta producir una respuesta final.

3. Agno

Agno es un framework de Python para crear agentes, equipos multiagente y flujos de trabajo estructurados. También incluye AgentOS, que ayuda a exponer agentes mediante APIs, almacenar sesiones y trazas y gestionarlos como aplicaciones en producción. Al poder ejecutarse en tu propia infraestructura, las organizaciones mantienen un mayor control sobre sus datos y su seguridad.

El siguiente ejemplo crea un agente de investigación que puede buscar en la web antes de producir una respuesta concisa.

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

El agente utiliza la herramienta de búsqueda para encontrar información actual y envía al usuario un resumen breve en streaming.

4. Pydantic AI

Pydantic AI es un framework nativo de Python del equipo detrás de Pydantic para crear agentes y aplicaciones de IA generativa. Se siente similar a trabajar con modelos de Pydantic o FastAPI porque agentes, herramientas, dependencias y salidas se definen con funciones de Python estándar, type hints, decoradores y clases BaseModel. Luego usa validación de Pydantic para mantener estructurados y fiables los argumentos de las herramientas y las salidas del modelo.

Te recomiendo el tutorial de Pydantic AI para aprender más sobre el framework.

El siguiente ejemplo crea un agente que devuelve un plan de artículo validado como un modelo de 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)

El agente genera un objeto ArticlePlan y valida que cada campo cumpla el tipo y las reglas de Python requeridas antes de devolverlo.

SDK oficiales de agentes

Los SDK oficiales de agentes son mantenidos por los proveedores de IA y suelen ofrecer la integración más sencilla con sus modelos, APIs, herramientas, sistemas de despliegue y plataformas de observabilidad.

5. OpenAI Agents SDK

OpenAI Agents SDK es un framework ligero y Python-first para crear aplicaciones de agente único y multiagente. Incluye un bucle de agente integrado, herramientas de funciones, handoffs, guardrails, sesiones, aprobaciones humanas y trazas sin añadir demasiadas abstracciones.

Me encanta usar el OpenAI Agents SDK porque es simple, rápido de integrar y fácil de entender. He creado muchas aplicaciones con él sin grandes problemas. Además, crea automáticamente trazas que pueden verse en el panel de OpenAI, lo que facilita inspeccionar respuestas del modelo, llamadas a herramientas, handoffs y todo el flujo de ejecución.

El siguiente ejemplo crea un agente de historia que puede llamar a una función de Python para recuperar un dato histórico sorprendente.

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

El SDK ejecuta el agente, llama a la herramienta de historia cuando es necesario, devuelve su resultado al modelo y produce la respuesta final. Toda la ejecución también puede inspeccionarse en el visor de trazas.

7. Google Agent Development Kit

Agent Development Kit de Google, o ADK, es un framework open-source para crear, evaluar y desplegar agentes individuales, asistentes que usan herramientas, workflows en grafo y sistemas multiagente. Funciona especialmente bien con modelos Gemini, aunque también admite otros proveedores de modelos.

ADK se ha convertido en uno de mis frameworks favoritos porque es simple y funciona de forma natural con Gemini.

Lo he utilizado para crear varias aplicaciones sin grandes problemas. Aunque sigo encontrando el OpenAI Agents SDK más fácil de integrar y más flexible en cuanto a controles y funciones integradas, ADK es una alternativa sólida y especialmente competitiva para aplicaciones basadas en Gemini.

El siguiente ejemplo crea un asistente de eventos que puede llamar a una función de Python para recuperar la hora de inicio de un 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],
)

El agente utiliza la función como herramienta siempre que necesite recuperar la hora del evento para una ciudad concreta.

8. Claude Agent SDK

El Claude Agent SDK es el framework en Python y TypeScript de Anthropic para crear agentes autónomos usando el mismo bucle de agente, herramientas y gestión de contexto que impulsa Claude Code. Es especialmente útil para agentes que necesitan leer archivos, editar código, ejecutar comandos, conectar herramientas MCP y completar tareas de larga duración.

Anthropic, OpenAI y Google integran sus modelos estrechamente con sus propios frameworks de agentes, lo que hace que herramientas, sesiones, trazas y otras funciones avanzadas sean rápidas de configurar.

Sin embargo, Claude Agent SDK está diseñado específicamente para Claude en lugar de modelos open-source arbitrarios o alojados localmente. Puedes saber más en nuestro tutorial de Claude Agent SDK.

El siguiente ejemplo crea un agente de programación que revisa un archivo de Python, identifica errores y los corrige automáticamente.

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

El SDK ejecuta el bucle del agente mientras Claude lee el archivo, selecciona las herramientas necesarias, edita el código y transmite su progreso hasta completar la tarea.

Frameworks de orquestación multiagente

Los frameworks multiagente coordinan varios agentes especializados, asignando a cada uno un rol, objetivo, conjunto de herramientas o etapa dentro de un flujo de trabajo mayor. 

9. CrewAI

CrewAI es un framework popular de Python para crear equipos multiagente. Los desarrolladores pueden definir agentes con distintos roles, objetivos y tareas, y combinarlos en un equipo que trabaje de forma autónoma. Las tareas pueden ejecutarse de forma secuencial o mediante un proceso jerárquico en el que un mánager coordina y delega el trabajo en los agentes más adecuados.

El siguiente ejemplo en Python crea un investigador y un redactor que colaboran para producir un informe breve.

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

El investigador completa la primera tarea y el redactor utiliza su salida como contexto para crear el informe final.

10. MetaGPT

MetaGPT es un framework multiagente que modela una empresa de software mediante agentes especializados como un product manager, un arquitecto, un project manager y un ingeniero. Estos agentes siguen procedimientos operativos estructurados para transformar un requisito breve en planes, diseños técnicos, documentación y código funcional. 

El siguiente ejemplo crea un equipo de software y le pide que construya un gestor de tareas simple por consola.

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

Los agentes se reparten los requisitos según sus roles y colaboran para planificar y desarrollar el proyecto de software. 

11. AgentScope

AgentScope es un framework de Python para crear agentes controlables y observables y aplicaciones multiagente. Ofrece agentes listos para usar, herramientas, memoria, enrutado de mensajes, streaming, llamadas paralelas a herramientas, workflows, trazas e intervención humana. AgentScope Studio también permite inspeccionar y visualizar la ejecución de los agentes.

El siguiente ejemplo crea un agente ReAct que puede escribir y ejecutar código Python para completar un 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())

El agente decide llamar a la herramienta de ejecución de Python, ejecuta el código generado y usa el resultado para responder al usuario.

12. CAMEL-AI

CAMEL-AI es un framework open-source de Python para crear agentes, sociedades multiagente y simulaciones de roles. Tiene un fuerte enfoque de investigación y ofrece componentes para colaboración entre agentes, herramientas, memoria, recuperación, generación de datos y simulación de mundos. También admite modelos en la nube y modelos alojados localmente mediante plataformas como Ollama, vLLM y SGLang.

El siguiente ejemplo crea un agente que puede buscar en la web antes de responder una pregunta.

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

El agente usa la búsqueda de DuckDuckGo cuando necesita información actual y luego devuelve la respuesta final.

Frameworks de datos y RAG

Estos frameworks ayudan a conectar LLMs y agentes con documentos, bases de datos, APIs y otras fuentes de datos privadas para que puedan recuperar contexto relevante antes de responder.

13. LlamaIndex

LlamaIndex es un framework de Python para crear aplicaciones conscientes del contexto sobre datos privados o de dominio específico. Ofrece conectores, índices, recuperadores, motores de consulta, agentes y workflows para aplicaciones como RAG, búsqueda empresarial y asistentes de documentos.

LlamaIndex fue uno de mis frameworks favoritos cuando empecé a crear aplicaciones RAG. Cargar, indexar y consultar datos es extremadamente fácil, y a menudo su código me resulta más simple y corto que construir la misma aplicación con LangChain. Puedes hacer el curso de LlamaIndex para saber más.

El siguiente ejemplo carga documentos de una carpeta, crea un índice buscable y responde a una pregunta usando el 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)

LlamaIndex indexa los archivos dentro de la carpeta data y recupera información relevante antes de generar la respuesta.

14. Haystack

Haystack es un framework open-source de Python para crear pipelines RAG listos para producción, sistemas de búsqueda semántica, agentes y aplicaciones de IA centradas en datos. Su estructura modular de pipeline ofrece un control claro sobre cómo se recupera la información, cómo se añade al prompt y cómo se envía a un modelo.

He usado Haystack para crear aplicaciones RAG y multiagente sin grandes problemas. Aunque es un framework de propósito general, es especialmente útil para aplicaciones que conectan LLMs con documentos, texto, sistemas de búsqueda y otras fuentes de datos.

El siguiente ejemplo almacena algunos documentos, recupera el más relevante y lo usa para responder a una pregunta.

# 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 recupera el documento coincidente, lo añade al prompt y usa GPT-5.5 para producir una respuesta fundamentada.

Frameworks ligeros y con modelos abiertos

Estos frameworks ofrecen abstracciones más simples para crear agentes con modelos abiertos hospedados o locales.

15. Hugging Face smolagents

Hugging Face smolagents es un framework ligero de Python para crear agentes con muy poco código. Su CodeAgent actúa escribiendo Python, mientras que ToolCallingAgent usa llamadas estructuradas a herramientas. Funciona especialmente bien con modelos de Hugging Face, Inference Providers y modelos open-source alojados localmente.

El siguiente ejemplo crea un agente de búsqueda web y se lo asigna a un agente mánager que decide cuándo delegar la investigación.

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

El mánager decide cuándo necesita información actual, delega la búsqueda en el agente web especialista y luego produce la respuesta final.

Comparativa rápida de frameworks

La siguiente tabla compara el principal punto fuerte de cada framework y el tipo de aplicación de IA agentica para la que resulta más adecuado.

Reflexiones finales

Si estás empezando con la IA agentica, yo comenzaría con un SDK oficial como OpenAI Agents SDK, Google ADK o Claude Agent SDK. Están muy alineados con sus propios modelos y APIs, así que la configuración suele ser simple. Añades una clave de API, cargas algunos créditos y te pones a construir.

Me gustan estos SDK porque facilitan crear agentes, conectar herramientas e inspeccionar qué ha pasado durante una ejecución. Con solo unas pocas líneas de Python, puedes crear un agente útil o incluso un pequeño sistema multiagente.

Cuando necesito más flexibilidad, normalmente recurro a LangChain o LangGraph. LangChain me resulta útil cuando necesito muchas integraciones, mientras que LangGraph me da más control sobre el estado, los bucles y workflows más largos.

Para equipos de agentes con distintos roles, CrewAI es una buena opción. Para RAG, documentos privados y aplicaciones conectadas a datos, elegiría LlamaIndex o Haystack.

Por último, smolagents es una buena elección cuando quiero algo ligero, sencillo y fácil de usar con modelos abiertos o locales.

Mi consejo es empezar con el framework más simple que se ajuste a tu proyecto. Construye una versión pequeña, pruébala a fondo y solo añade más complejidad cuando realmente la necesites.