Agentes de IA con LangGraph: construyendo sistemas multi-agente paso a paso

Los agentes de IA basados en LLMs tienen un problema fundamental cuando se implementan como cadenas lineales: no manejan bien la incertidumbre, los ciclos o las decisiones condicionales complejas. LangGraph, parte del ecosistema LangChain, resuelve esto modelando el comportamiento del agente como un grafo de estado dirigido donde cada nodo es una función que puede leer y modificar el estado, y las aristas determinan el flujo de ejecución.

Por qué los agentes lineales se quedan cortos

En un agente ReAct clásico, el LLM razona y actúa en un ciclo: piensa, usa una herramienta, observa el resultado, vuelve a pensar. Este patrón funciona para tareas simples pero tiene límites claros: no hay forma de ejecutar herramientas en paralelo, no hay estado persistente entre turnos más allá del contexto del mensaje, y cuando el agente entra en un bucle de error (herramienta falla, LLM intenta lo mismo, falla de nuevo) no hay mecanismo de escape nativo.

LangGraph introduce un StateGraph donde defines explícitamente los nodos (funciones de Python), las aristas (transiciones entre nodos) y las aristas condicionales (transiciones que dependen del estado actual). El flujo de ejecución ya no está implícito en el prompt: está codificado en la estructura del grafo.

Estructura básica de un agente con LangGraph

from langgraph.graph import StateGraph, END
from typing import TypedDict
 
class AgentState(TypedDict):
    messages: list
    tool_calls: list
    final_answer: str | None
 
def call_llm(state: AgentState) -> AgentState:
    # Llamar al LLM con el estado actual
    ...
 
def execute_tools(state: AgentState) -> AgentState:
    # Ejecutar las herramientas solicitadas
    ...
 
def should_continue(state: AgentState) -> str:
    if state["final_answer"]:
        return "end"
    if state["tool_calls"]:
        return "tools"
    return "llm"
 
graph = StateGraph(AgentState)
graph.add_node("llm", call_llm)
graph.add_node("tools", execute_tools)
graph.add_conditional_edges("llm", should_continue, {
    "end": END, "tools": "tools", "llm": "llm"
})
graph.add_edge("tools", "llm")
graph.set_entry_point("llm")
app = graph.compile()

Sistemas multi-agente: el paso siguiente

La propuesta más poderosa de LangGraph es la orquestación de múltiples agentes especializados. En lugar de un agente generalista que intenta hacer todo, defines agentes especializados —uno para búsqueda web, uno para análisis de código, uno para redacción— y un agente supervisor que decide cuál subagente invocar según la tarea.

El patrón supervisor-worker implementado con LangGraph permite:

• Paralelismo real: el supervisor puede invocar varios subagentes simultáneamente
• Especialización: cada subagente tiene su propio conjunto de herramientas y prompt
• Handoff estructurado: el estado se pasa entre agentes con tipado explícito, no como texto libre

Persistencia y human-in-the-loop

LangGraph incluye un sistema de checkpointing que guarda el estado del grafo en cada paso. Esto habilita dos capacidades críticas para producción:

Memoria entre sesiones: el agente puede retomar una conversación donde la dejó, incluso días después, sin perder el contexto de herramientas usadas o decisiones tomadas.

Human-in-the-loop: puedes interrumpir el grafo en cualquier nodo para pedir aprobación humana antes de continuar —especialmente útil cuando el agente está a punto de ejecutar una acción irreversible como enviar un correo o modificar una base de datos.

LangGraph está en desarrollo activo y su API cambia con frecuencia. La versión estable actual (0.2.x) tiene breaking changes respecto a 0.1.x, por lo que fijar la versión en tu requirements.txt es imprescindible en proyectos de producción.