LangGraph en 2026: Un Agente de Soporte Que Sabe Cuándo Preguntar

1. El Problema: Las Demos Olvidan, los Reembolsos No

Un chatbot de soporte sobre una simple llamada al LLM tiene tres fallas fatales. No tiene memoria entre mensajes, así que cada turno empieza de cero. No puede actuar, así que solo habla de reembolsos en vez de procesarlos. Y no sabe escalar, así que la decisión riesgosa — devolver dinero — ocurre sin supervisión o se bloquea por completo.

LangGraph lo resuelve con un grafo explícito: los nodos hacen el trabajo, las aristas deciden qué sigue, un checkpointer recuerda el estado por hilo de conversación y un interrupt pausa la ejecución hasta que un humano aprueba. Esa es la arquitectura que vamos a construir.

2. Conceptos Mínimos: Estado, Nodos, Aristas, Checkpoints

LangGraph es un framework de orquestación de bajo nivel: definís un agente como un grafo en vez de una cadena. Cuatro ideas explican el 90% del framework. Aprendelas y el tutorial se va a leer como Python común.

3. Pasos 1–2: Herramientas y Estado

Instalá los paquetes, definí dos herramientas de soporte y atalas al modelo. La herramienta de reembolso no se ejecuta directo — la va a controlar el nodo de aprobación. El estado es un TypedDict con lista de mensajes acumulativa más un campo de dominio.

pip install langgraph langchain-anthropic
export ANTHROPIC_API_KEY="sk-..."
export LANGSMITH_TRACING="true"   # caja negra activada

from langchain.tools import tool
from langchain.chat_models import init_chat_model

model = init_chat_model("claude-sonnet-4-6", temperature=0)

@tool
def lookup_order(order_id: str) -> str:
    """Look up an order by ID. Returns status and total."""
    return f"Order {order_id}: shipped, total $84.20"

@tool
def issue_refund(order_id: str, amount: float) -> str:
    """Issue a refund. Only runs after human approval."""
    return f"Refunded ${amount:.2f} to order {order_id}"

tools = [lookup_order, issue_refund]
model_with_tools = model.bind_tools(tools)

from typing_extensions import TypedDict, Annotated
from langchain_core.messages import AnyMessage
import operator

class SupportState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    customer_tier: str

4. Pasos 3–4: Nodos, Aristas y el Grafo

Dos nodos (agent + ToolNode prearmado), una función de ruteo, cuatro aristas. El nodo agent llama al modelo atado a herramientas; should_continue manda las llamadas a ejecución y las respuestas planas a END. Compilá primero sin checkpointer para probar el loop, y sumá memoria en el paso siguiente.

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode
from typing import Literal

def agent_node(state: SupportState):
    reply = model_with_tools.invoke(state["messages"])
    return {"messages": [reply]}

def should_continue(state: SupportState) -> Literal["tools", END]:
    if state["messages"][-1].tool_calls:
        return "tools"
    return END

builder = StateGraph(SupportState)
builder.add_node("agent", agent_node)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", should_continue, ["tools", END])
builder.add_edge("tools", "agent")

graph = builder.compile()  # la memoria viene después

from langchain_core.messages import HumanMessage
out = graph.invoke({
    "messages": [HumanMessage(content="Where is order 8821?")],
    "customer_tier": "pro",
})
print(out["messages"][-1].content)

5. Pasos 5–6: Memoria, Compuerta de Aprobación y Tracing

Recompilá con checkpointer, insertá el nodo refund_approval entre herramientas y ejecución, y retomá con Command. Reembolsos de más de $50 frenan para un humano; el resto fluye directo. LangSmith registra ambas mitades del run pausado automáticamente.

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command

def refund_approval(state: SupportState):
    last = state["messages"][-1]
    calls = [c for c in last.tool_calls if c["name"] == "issue_refund"]
    if not calls or calls[0]["args"].get("amount", 0) <= 50:
        return {"messages": []}  # montos chicos pasan directo
    ok = interrupt({  # pausa acá, el payload lo ve el revisor
        "question": "Approve this refund?",
        "order": calls[0]["args"],
        "tier": state["customer_tier"],
    })
    if not ok:
        return {"messages": [HumanMessage(content="Refund declined by reviewer.")]}
    return {"messages": []}

builder.add_node("refund_approval", refund_approval)
builder.add_edge("tools", "refund_approval")
# rewire: tools -> approval -> agent (rebuild + recompile)
checkpointer = InMemorySaver()  # SqliteSaver / PostgresSaver en prod
graph = builder.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "support-123"}}
first = graph.invoke(
    {"messages": [HumanMessage(content="Refund $340 to order 8821")],
     "customer_tier": "pro"},
    config=config,
)
print(first.get("__interrupt__"))  # pausado, esperando un humano
final = graph.invoke(Command(resume=True), config=config)  # aprobar
print(final["messages"][-1].content)

6. Errores Comunes (y el Fix de Una Línea para Cada Uno)

Estas cuatro fallas explican la mayoría de los hilos de soporte de LangGraph que vi. Cada una tiene una causa precisa y un fix de una línea — memorizalos antes de deployar.

7. Cuándo LangGraph Rinde — y Cuándo No

LangGraph es overhead para prompts de un solo tiro y un superpoder para flujos con estado. Usá esta regla para decidir antes de commitear un grafo nuevo a tu codebase.

Fuentes

Cada API de este tutorial sale de la documentación oficial y guías actuales de la comunidad. Verificá antes de deployar — los frameworks se mueven rápido.

• LangGraph Quickstart (Graph API: StateGraph, patrón ToolNode, bind_tools)
• Interrupts: interrupt(), Command(resume=…), patrones de aprobación y revisión
• Persistencia: InMemorySaver, PostgresSaver, SqliteSaver, thread_id
• LangGraph overview: orquestación, ejecución durable, HITL
• Checkpointers: por qué thread_id es requerido, fault tolerance

Conclusión

Ya tenés un agente de soporte que recuerda la conversación, consulta órdenes y se niega a mover dinero sin que un humano diga que sí. Ese loop — estado, herramientas, checkpoint, interrupt, trace — es el template detrás de la mayoría de los agentes productivos que construyo o rescato.

Próximo paso: apuntá el mismo grafo a tus propias herramientas (lookup en Zendesk, reembolso en Stripe en modo test), cambiá InMemorySaver por PostgresSaver y mirá los primeros diez traces en LangSmith. Los traces te van a enseñar más que cualquier tutorial — incluido este.