LangGraph: Guía Completa para Flujos de IA Complejos

¿Por qué LangGraph? Límites de las chains lineales

LangChain chains son perfectas para flujos A → B → C. Pero las aplicaciones de producción necesitan:

• Bucles: Reintentar hasta que el resultado sea satisfactorio
• Bifurcaciones: Tomar caminos distintos según el tipo de consulta
• Estado persistente: Mantener contexto a través de múltiples pasos
• Human-in-the-loop: Pausar y esperar aprobación humana
• Múltiples agentes: Coordinación entre agentes especializados

Conceptos clave: State, Nodes, Edges

State: Diccionario tipado que persiste a través de todos los nodos. Es la memoria de trabajo del flujo.

Nodes: Funciones Python que reciben el estado y retornan un estado actualizado. Pueden llamar LLMs, herramientas, bases de datos o cualquier operación.

Edges: Conexiones entre nodos. Pueden ser directas (A siempre va a B) o condicionales (según el estado, va a B, C o D).

Checkpointing: LangGraph puede guardar el estado en Redis o PostgreSQL para pausar, resumir, depurar y hacer rollback a cualquier punto.

Patrón 1: Agente con ciclo de reflexión

El patrón más común: el agente genera una respuesta, la evalúa, y si no es suficientemente buena, la mejora. El grafo tiene 3 nodos: generate → reflect → [si OK: END | si no: generate].

Usado en: generación de código, análisis legal y diagnósticos donde la precisión es crítica.

Patrón 2: Router multi-agente

Un agente router analiza la consulta y la dirige al especialista correcto:

• Consulta sobre facturas → agente_finanzas
• Consulta de RRHH → agente_hr
• Consulta técnica → agente_soporte
• Consulta legal → agente_legal

Human-in-the-Loop: control humano

Para acciones de alto impacto (transferencias, comunicados masivos, cambios críticos), LangGraph soporta pausas para aprobación humana. El flujo llega al nodo esperar_aprobacion, guarda el estado con checkpointing, y espera. Un humano revisa y aprueba. El flujo se resume exactamente donde quedó.

Crítico para compliance en banca, salud y gobierno.

Ejemplo de código

# LangGraph: Agente con ciclo de reflexion
from langgraph.graph import StateGraph, END
from typing import TypedDict
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-4-6")

class AgentState(TypedDict):
    task: str
    draft: str
    iterations: int
    approved: bool

def generate(state: AgentState) -> AgentState:
    response = llm.invoke(f"Completa: {state['task']}")
    return {**state, "draft": response.content, "iterations": state["iterations"] + 1}

def reflect(state: AgentState) -> AgentState:
    feedback = llm.invoke(
        f"Evalua: {state['draft']}\nResponde solo APROBADO o MEJORAR"
    )
    approved = "APROBADO" in feedback.content or state["iterations"] >= 3
    return {**state, "approved": approved}

def route(state: AgentState) -> str:
    return END if state["approved"] else "generate"

graph = StateGraph(AgentState)
graph.add_node("generate", generate)
graph.add_node("reflect", reflect)
graph.set_entry_point("generate")
graph.add_edge("generate", "reflect")
graph.add_conditional_edges("reflect", route, {"generate": "generate", END: END})
app = graph.compile()

result = app.invoke({"task": "Redacta email de bienvenida", "draft": "", "iterations": 0, "approved": False})
print(result["draft"])