Cómo crear un AI agent con LangGraph: tutorial paso a paso

LangGraph es el framework de bajo nivel de LangChain para crear AI agents con estado como un grafo explícito de nodos y aristas, que le da control directo sobre cómo un agent se ramifica, se pausa y conserva el estado a lo largo de una tarea de larga duración. Es el camino de código al que recurren los equipos cuando un trabajo necesita lógica condicional, flujos de aprobación de varios pasos o una memoria que sobreviva días en lugar de una sola conversación. Esta guía explica qué es realmente LangGraph, cómo instalarlo, un recorrido completo de construcción con dos ejemplos funcionales y cuándo es la plataforma adecuada frente a las alternativas.

Qué es realmente LangGraph

LangGraph es un framework de orquestación de bajo nivel y un runtime para crear, administrar y desplegar agents con estado y de larga duración. Es independiente de las abstracciones de más alto nivel de LangChain: LangChain le da modelos, herramientas y patrones de agent prediseñados; LangGraph le da el runtime basado en grafos que hay debajo, donde usted define los nodos como pasos de cómputo, las aristas como los caminos entre ellos y un objeto de estado compartido que fluye a lo largo de toda la ejecución. Es una decisión de diseño deliberada: valores predeterminados razonables cuando no necesita mucho control, un grafo explícito cuando sí lo necesita.

El uso real en producción respalda la propuesta. El artículo de LangChain sobre LangGraph en producción nombra como usuarios en producción a Uber (migraciones de código a gran escala en su plataforma para desarrolladores), LinkedIn (un reclutador con AI que automatiza la búsqueda de candidatos y la mensajería), Replit (un sistema multi-agent con revisión de intervención humana) y Elastic (que orquesta una red de agents para la detección de amenazas en tiempo real). El copilot de administración de propiedades de AppFolio, también creado con LangGraph, ahorró a sus administradores de propiedades más de 10 horas a la semana y duplicó la precisión de sus decisiones, un resultado concreto y no una vaga afirmación de adopción.

Ese tipo de despliegue se está volviendo la norma, no la excepción. Gartner proyecta que el 40% de las aplicaciones empresariales incluirá AI agents específicos para tareas a finales de 2026, frente a menos del 5% en 2025, y una parte significativa de ese cambio ocurre en frameworks creados específicamente para sistemas multi-agent como LangGraph, donde un grafo puede modelar un orquestador que transfiere trabajo a varios nodos especializados en lugar de un solo modelo que lo hace todo en una única pasada.

El vocabulario de LangGraph, asociado a los 6 componentes básicos

Si leyó cómo crear un AI agent, conoce los seis bloques que todo agent necesita: Rol, Herramientas, Reglas, Manual de escenarios, Lógica de decisión y Barreras de protección. LangGraph da a cada uno un lugar concreto en el código.

Nada de esto es exclusivo de LangGraph en términos conceptuales. Lo que LangGraph añade es un grafo explícito e inspeccionable en lugar de un ciclo de caja negra, que es exactamente el tipo de control que AI agents no-code frente a código dice que debería buscar cuando la lógica de un trabajo se vuelve realmente personalizada.

Instalación de LangGraph

pip install -U langgraph langchain

langgraph es la biblioteca central del grafo y del runtime. langchain añade create_agent, el punto de entrada de alto nivel actual para un agent estándar con llamada de herramientas, que se ejecuta sobre LangGraph internamente. Defina como variable de entorno una clave de API de su proveedor de modelos y ya puede construir.

El camino rápido: create_agent

Para un solo agent que únicamente necesita un modelo, algunas herramientas y un system prompt, no hace falta tocar el grafo directamente:

from langchain.agents import create_agent

def get_account_status(company: str) -> str:
    """Look up a customer account's status by company name."""
    return f"{company}: active, plan tier Growth, renewal in 45 days."

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[get_account_status],
    system_prompt="You are a support assistant. Answer only from tool results, never guess.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the status of Acme Corp's account?"}]}
)
print(result["messages"][-1].content)

Es la misma mecánica de cómo usan herramientas los AI agents en la que se apoya toda plataforma: describir una función, dejar que el modelo decida cuándo llamarla y devolverle el resultado. create_agent reemplazó al antiguo ayudante create_react_agent de LangGraph como punto de partida recomendado: la misma idea, con una API más limpia.

Un nivel más bajo: un grafo personalizado con enrutamiento condicional

El camino rápido cubre mucho terreno, pero no puede expresar "haga X y luego pase a un paso de revisión humana solo si se detecta un riesgo". Para eso, usted construye el grafo directamente. Este es un flujo simplificado de revisión de contratos, muy parecido al plan de construcción del AI Contract Review Agent: analiza un contrato y luego lo envía a un revisor humano o lo aprueba automáticamente según lo que encuentre el análisis.

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver

class ReviewState(TypedDict):
    contract_text: str
    risk_flagged: bool
    summary: str

def analyze_contract(state: ReviewState) -> dict:
    # call the model here to extract terms and set risk_flagged
    return {"risk_flagged": True, "summary": "Non-standard liability cap on page 4."}

def route_on_risk(state: ReviewState) -> str:
    return "human_review" if state["risk_flagged"] else "auto_approve"

def human_review(state: ReviewState) -> dict:
    return {"summary": state["summary"] + " Routed to legal for review."}

def auto_approve(state: ReviewState) -> dict:
    return {"summary": state["summary"] + " Auto-approved, no flags."}

graph = StateGraph(ReviewState)
graph.add_node("analyze", analyze_contract)
graph.add_node("human_review", human_review)
graph.add_node("auto_approve", auto_approve)

graph.add_edge(START, "analyze")
graph.add_conditional_edges("analyze", route_on_risk, {
    "human_review": "human_review",
    "auto_approve": "auto_approve",
})
graph.add_edge("human_review", END)
graph.add_edge("auto_approve", END)

app = graph.compile(checkpointer=InMemorySaver())

add_conditional_edges es el bloque de lógica de decisión hecho literal: después de que se ejecuta analyze, route_on_risk inspecciona el estado y envía la ejecución por uno de dos caminos con nombre. Es una ramificación que un ciclo lineal de llamada de herramientas no puede expresar con claridad, y es la razón por la que los equipos recurren a LangGraph cuando aparecen sistemas multi-agent o flujos de aprobación de varios pasos.

Persistencia y memoria

El argumento checkpointer de compile() es lo que hace que un grafo se pueda reanudar en lugar de no tener estado. InMemorySaver, mostrado arriba, sirve para pruebas locales pero desaparece cuando el proceso se reinicia. Los grafos en producción usan en su lugar un backend persistente: los guardadores de checkpoints de SQLite o Postgres se distribuyen como paquetes instalables aparte, y se identifican con un thread_id para que el estado de una ejecución específica pueda recargarse y continuar días después. Es la misma distinción entre memoria de trabajo y memoria persistente que se explica en general en memoria de AI agents: un checkpointer es la respuesta concreta de LangGraph a la memoria persistente.

Intervención humana con interrupciones

La función interrupt() de LangGraph pausa la ejecución del grafo en un punto específico y espera una entrada externa antes de reanudar, exactamente lo que el nodo human_review anterior necesita en una implementación real en lugar de la lógica provisional mostrada. Una persona (u otro sistema) revisa el estado pausado y responde, y el grafo se reanuda desde ese mismo punto usando el estado del checkpoint en lugar de empezar de nuevo. Es el mecanismo concreto detrás de los puntos de aprobación que se explican en general en intervención humana en AI agents: el grafo no adivina cuándo debe intervenir una persona, usted integra esa decisión directamente en la lógica de enrutamiento.

Barreras de protección y pruebas antes del lanzamiento

Una arista condicional es tan buena como la lógica que decide hacia dónde enrutar, así que valide esa lógica antes de que toque contratos, tickets o registros reales. Añada verificaciones explícitas dentro de un nodo (rechace o reintente un resultado que no cumpla una regla que usted defina) en lugar de confiar solo en el criterio del modelo, la disciplina que se explica en barreras de protección para AI agents. Y no dé un grafo por terminado después de una sola prueba limpia. Cómo evaluar y probar AI agents explica cómo armar un conjunto de pruebas real a partir de casos históricos, incluidos los desordenados que deberían enrutarse a revisión humana, antes de que cualquier agent de LangGraph toque volumen de producción.

Costo y límites

LangGraph en sí es gratuito y de código abierto. Lo que usted paga es el uso de la API del LLM, y un grafo con más nodos y más ramas hace más llamadas al modelo que un solo agent bien delimitado que haga el mismo trabajo, el mismo equilibrio que se explica en sistemas multi-agent. Si prefiere no alojar ni monitorear el grafo por su cuenta, LangChain también ofrece LangGraph Platform, una opción de despliegue alojado de pago con persistencia y observabilidad integradas; ejecutarlo por su cuenta no cuesta nada más allá de su propia infraestructura y las llamadas al modelo.

El límite real no es el precio, sino que LangGraph no ofrece un constructor visual ni conectores de aplicaciones prediseñados. Cada integración, cada política de reintentos y cada pieza de manejo de errores es código que usted escribe, que es el intercambio directo por el control que un grafo le da frente a la lógica acotada de una plataforma no-code.

Cuándo elegir LangGraph frente a las alternativas

Datos clave

• LangGraph es un framework de orquestación y runtime de bajo nivel, de código abierto, para agents con estado, independiente de las abstracciones de más alto nivel de LangChain pero complementario a ellas.
• Entre los usuarios en producción documentados están Uber, LinkedIn, Replit y Elastic; el copilot de AppFolio creado con LangGraph ahorró a los administradores de propiedades más de 10 horas a la semana y duplicó la precisión de las decisiones.
• create_agent en el paquete langchain es el punto de entrada de alto nivel recomendado actualmente, que reemplaza al antiguo ayudante create_react_agent y se ejecuta sobre LangGraph.
• StateGraph con add_conditional_edges es lo que permite a un agent ramificarse según su propio resultado, la mecánica detrás de los flujos de aprobación y de la lógica de decisión de varios pasos.
• Un checkpointer (en memoria para pruebas, SQLite o Postgres para producción) hace que un grafo se pueda reanudar entre sesiones, identificado por thread_id.

A dónde ir a continuación

LangGraph es un camino de código hacia un agent funcional, no el único. Cómo crear un AI agent con CrewAI explica un framework más basado en roles para trabajo multi-agent, y si todavía está decidiendo entre escribir código o usar un constructor visual, cómo elegir una plataforma de AI agents recorre esa decisión entre opciones no-code, de frameworks y administradas. Cuando un grafo funcione de forma confiable en las pruebas, desplegar AI agents en producción explica el lanzamiento y el plan de reversión antes de que toque volumen real. El resumen de herramientas para desarrolladores y la guía de compra de asistentes de programación con AI son buenas siguientes paradas para escribir y mantener el código más rápido.