LangChain por dentro: análisis del repo, create_agent, middleware y cuándo usarlo

Por qué analizamos LangChain

Este análisis lo ha elegido la comunidad de IAcademy por votación. Y tiene sentido: langchain-ai/langchain es uno de los repositorios de inteligencia artificial más seguidos de GitHub, con más de 148.000 estrellas, casi 25.000 forks y unas 3.700 personas que han contribuido. Su paquete principal supera los 170 millones de descargas al mes en PyPI.

Pero la popularidad no responde a la pregunta que importa: ¿te conviene LangChain para tu agente? En este artículo lo analizamos por dentro, con el código de la versión 1.x en la mano, y te damos un veredicto con sus pros y sus contras. Si buscas un tutorial paso a paso desde cero, tienes la guía de LangChain en español; si dudas entre frameworks, la comparativa LangChain vs LlamaIndex.

Qué es LangChain hoy

LangChain es un framework de código abierto, con licencia MIT, para construir agentes y aplicaciones con modelos de lenguaje. Su propuesta es ofrecer piezas con una interfaz común (modelos, herramientas, prompts, recuperadores de documentos, bases vectoriales) que encajan entre sí, de modo que puedes cambiar una sin reescribir el resto.

El repositorio nació el 17 de octubre de 2022, semanas antes del lanzamiento de ChatGPT, y exactamente tres años después, el 17 de octubre de 2025, publicó la versión 1.0, que reorganizó el proyecto alrededor de los agentes. Hoy se presenta como «The agent engineering platform»: ya no habla de cadenas, habla de agentes.

Las cifras del repositorio

La lectura es doble. Lo bueno: el proyecto está muy vivo, los fallos se corrigen rápido y los modelos nuevos llegan enseguida. Lo menos bueno: con ese ritmo de versiones, tienes que fijar las versiones en tu proyecto y leer las notas antes de actualizar.

Cómo está organizado el repositorio

Todo el código vive en la carpeta libs/, que es un monorepo con varios paquetes independientes:

• core (langchain-core): las abstracciones comunes: mensajes, herramientas, prompts, recuperadores, runnables. Se descarga casi tanto como el paquete principal porque muchas librerías se apoyan en él.
• langchain_v1 (langchain): el paquete que instalas, con los agentes, init_chat_model y el middleware. Depende de LangGraph.
• partners: integraciones oficiales con proveedores como OpenAI, Anthropic, DeepSeek, Mistral, Groq, Ollama, Hugging Face, OpenRouter o Qdrant.
• text-splitters: utilidades para trocear documentos antes de indexarlos.
• langchain (langchain-classic): el código anterior a la v1, para no romper proyectos antiguos.

Es la gran lección de la versión 1: un núcleo pequeño y estable, y todo lo demás en paquetes que instalas solo si los necesitas.

Tu primer agente con create_agent

La pieza central de LangChain 1.x es una función: create_agent. Recibe el modelo (como texto "proveedor:modelo"), una lista de herramientas, que son funciones de Python con su descripción, y las instrucciones del sistema.

from langchain.agents import create_agent

def tiempo(ciudad: str) -> str:
    """Devuelve el tiempo actual de una ciudad."""
    return f"En {ciudad} hace sol y 22 grados"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[tiempo],
    system_prompt="Eres un asistente breve y preciso.",
)

agent.invoke({"messages": [{"role": "user", "content": "¿Qué tiempo hace en Madrid?"}]})

El agente razona, decide llamar a tiempo, lee el resultado y responde. Por debajo, create_agent construye un grafo de LangGraph, el motor que gestiona los pasos, el estado y la memoria. Dos parámetros más que conviene conocer: response_format, para recibir la respuesta como datos estructurados con los campos que tú definas, y checkpointer, para que el agente recuerde la conversación y pueda retomar un trabajo.

Middleware: lo que separa una demo de producción

Lo más interesante de la v1 está en libs/langchain_v1/langchain/agents/middleware/. Un middleware se coloca entre el agente y el modelo, o entre el agente y sus herramientas, y controla lo que ocurre. Algunos de los que vienen de serie:

• HumanInTheLoopMiddleware: detiene el agente antes de una herramienta delicada hasta que una persona la aprueba.
• PIIMiddleware: detecta datos personales (correos, tarjetas, IP, URL o tipos propios) y los tapa, bloquea o enmascara.
• SummarizationMiddleware: resume la conversación cuando crece demasiado.
• ModelFallbackMiddleware y ModelRetryMiddleware: cambian de modelo o reintentan si falla.
• ToolCallLimitMiddleware y ModelCallLimitMiddleware: ponen tope a las llamadas para que un bucle no dispare el coste.

from langchain.agents.middleware import (
    HumanInTheLoopMiddleware, PIIMiddleware, ToolCallLimitMiddleware,
)

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[buscar_cliente, enviar_email],
    middleware=[
        HumanInTheLoopMiddleware(interrupt_on={"enviar_email": True}),
        PIIMiddleware("email", strategy="redact"),
        ToolCallLimitMiddleware(run_limit=10),
    ],
)

Si ninguno encaja, puedes escribir el tuyo con los ganchos before_model, after_model, wrap_model_call o wrap_tool_call: por ejemplo, para registrar el coste de cada paso o bloquear una herramienta fuera del horario laboral.

Herramientas por MCP

El repositorio incluye un módulo langchain.mcp con un MCPAdapter que conecta uno o varios servidores MCP y convierte sus herramientas en herramientas normales de create_agent. También permite que el agente se detenga y pida un dato que falta (elicitation).

from langchain.agents import create_agent
from langchain.mcp import MCPAdapter

async with MCPAdapter("https://tu-servidor/mcp") as adapter:
    agent = create_agent("anthropic:claude-sonnet-5", await adapter.list_tools())
    result = await agent.ainvoke({"messages": [...]})

Ojo: el módulo está en beta y emite un LangChainBetaWarning al importarlo. Úsalo para prototipos y proyectos internos antes de apoyar en él algo crítico.

Cambiar de modelo o usar uno local

Cambiar de proveedor es cambiar un texto: "openai:...", "anthropic:..." u "ollama:qwen3". Con Ollama, el agente funciona igual pero los datos no salen de tu equipo ni de tu servidor. Para empresas con datos de clientes, sanitarios o de la administración, combinar un modelo local con PIIMiddleware da dos capas de protección compatibles con el RGPD. Eso sí: un modelo pequeño no razona como los grandes de pago, así que mide cuántas tareas completa bien antes de decidir.

LangChain, LangGraph o Deep Agents

La regla práctica: empieza por LangChain; si te falta control, baja a LangGraph; si la tarea es larga y abierta, sube a Deep Agents. Como comparten motor, moverse entre capas no obliga a rehacer el proyecto.

Lo que no te cuentan

1. Para una llamada simple, sobra. Si solo vas a preguntarle algo a un modelo, usa el cliente del proveedor.
2. Cambia muy rápido. Fija versiones y lee las notas de cada versión.
3. Muchos tutoriales están desfasados. Si ves cadenas por todas partes, es código anterior a la v1 (hoy en langchain-classic).
4. Necesitas trazas. LangSmith es la herramienta oficial, de pago a partir de cierto uso; Langfuse u OpenTelemetry son alternativas abiertas.
5. Mide el coste por tarea. Cada paso del agente es una llamada al modelo: un agente mal diseñado puede gastar diez veces más de lo previsto.

Preguntas frecuentes

¿LangChain es gratis?

Sí. El framework es de código abierto con licencia MIT y puedes usarlo en productos comerciales. Pagas los modelos que conectes y, si lo usas, LangSmith a partir de cierto volumen.

¿Puedo usar LangChain con modelos locales?

Sí. Con el paquete langchain-ollama basta con indicar "ollama:<modelo>" en create_agent. Los datos no salen de tu infraestructura.

¿Qué diferencia hay entre LangChain y LangGraph?

LangGraph es el motor de bajo nivel para orquestar agentes paso a paso. LangChain 1.x se apoya en él y ofrece create_agent y el middleware para montar un agente completo con menos código.

¿Sigue funcionando el código de LangChain 0.x?

El código antiguo se trasladó a langchain-classic. Para proyectos nuevos, usa la API de la v1.

Veredicto

Si vas a construir un agente con herramientas, memoria y control humano, LangChain 1.x es hoy una de las opciones más sólidas: un núcleo estable, middleware listo para producción, MCP en camino y libertad para usar modelos locales. Si solo necesitas una llamada a un modelo, no lo necesitas.

Tu reto: crea un agente con create_agent, conéctalo a un modelo local con Ollama y ponle un límite de llamadas con ToolCallLimitMiddleware. Y cuéntanos en los comentarios del vídeo qué le pediste.