LangGraph en español: tutorial de agentes multi-agente

¿Por qué LangGraph existe si ya tenemos LangChain?

LangChain fue diseñado en 2022 para cadenas lineales: un prompt entra, pasa por un modelo de lenguaje, y sale una respuesta. Este patrón funciona perfectamente para chatbots, sistemas de preguntas y respuestas, y pipelines RAG (Retrieval-Augmented Generation). Pero cuando intentas construir un agente que necesita tomar decisiones, volver atrás, ejecutar bucles o coordinar múltiples sub-agentes, la arquitectura lineal de LangChain se queda corta.

LangGraph nació para resolver exactamente este problema. En lugar de cadenas lineales, LangGraph trabaja con grafos dirigidos: estructuras donde los nodos son funciones (agentes o herramientas) y las aristas son las conexiones entre ellos, que pueden ser condicionales. Esto permite crear flujos con bifurcaciones («si el cliente dice que sí, agenda reunión; si dice que no, envía follow-up»), bucles («sigue intentando hasta que el resultado sea satisfactorio») y paralelismo («investiga al prospecto mientras redactas el email»).

El propio Harrison Chase, fundador de LangChain, lo ha dicho públicamente: «Usa LangChain para RAG y cadenas simples. Usa LangGraph para cualquier cosa que necesite agentes.» Y los números lo confirman: LangGraph tiene 24.000 estrellas en GitHub, 4,2 millones de descargas mensuales en PyPI, y LangChain acaba de recaudar 125 millones de dólares en su Serie B centrada en posicionar LangGraph como la plataforma de referencia para ingeniería de agentes.

Los 5 conceptos clave que necesitas entender

Antes de escribir una sola línea de código, necesitas entender cinco conceptos que son la base de todo lo que construirás con LangGraph.

1. StateGraph (Grafo de Estado). Es el contenedor principal de tu agente. Define un estado compartido — un diccionario de Python que todos los nodos del grafo pueden leer y modificar. Por ejemplo, en un agente de investigación, el estado podría incluir la consulta del usuario, los documentos encontrados, el borrador del informe y el estado de revisión. Cada nodo lee el estado actual, hace su trabajo, y devuelve una versión actualizada del estado.

2. Nodos. Son funciones de Python que procesan y modifican el estado. Cada nodo tiene una responsabilidad específica: uno podría buscar información en la web, otro analizar los resultados, otro redactar un resumen, y otro verificar la calidad del resumen. Los nodos son donde ocurre el trabajo real del agente.

3. Edges (Aristas). Son las conexiones entre nodos que definen el flujo de ejecución. Las aristas pueden ser normales (siempre van al mismo nodo siguiente) o condicionales (una función decide a qué nodo ir según el estado actual). Las aristas condicionales son lo que hace a LangGraph tan potente: permiten que el agente tome decisiones dinámicas sobre qué hacer a continuación.

4. Checkpointing. LangGraph puede guardar el estado del grafo en cualquier punto de la ejecución. Esto permite reanudar un agente desde donde se quedó después de un fallo, hacer rollback a un estado anterior si algo salió mal, o pausar la ejecución para esperar input humano. Los checkpoints se almacenan en memoria, SQLite, PostgreSQL o Redis según tus necesidades.

5. Human-in-the-Loop. Uno de los diferenciadores clave de LangGraph frente a otros frameworks. Puedes configurar puntos de interrupción donde el agente pausa automáticamente y espera la aprobación de un humano antes de continuar. Esto es esencial para acciones con consecuencias irreversibles como enviar emails a clientes, realizar pagos o modificar bases de datos de producción.

Instalación y configuración paso a paso

LangGraph se instala con pip como cualquier paquete de Python. Necesitas Python 3.9 o superior y una clave API de al menos un proveedor de modelos de lenguaje (OpenAI, Anthropic o Google).

# Instalar LangGraph y el provider de OpenAI
pip install langgraph langchain-openai

# O si prefieres Claude de Anthropic
pip install langgraph langchain-anthropic

# O si prefieres Gemini de Google
pip install langgraph langchain-google-genai

# Configurar la clave API (elige uno)
export OPENAI_API_KEY="tu-clave-openai"
export ANTHROPIC_API_KEY="tu-clave-anthropic"
export GOOGLE_API_KEY="tu-clave-google"

Para verificar que todo funciona correctamente, ejecuta este script mínimo que crea un agente de una sola línea:

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Crear un agente ReAct básico
model = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(model, tools=[])

# Probarlo
result = agent.invoke({"messages": [("user", "¿Qué es un agente IA?")]})
print(result["messages"][-1].content)

Si obtienes una respuesta coherente, tu instalación funciona correctamente. Ahora podemos construir algo más interesante.

Tu primer agente con LangGraph: investigador web

Vamos a construir un agente que recibe un tema, busca información en la web, analiza los resultados y genera un informe estructurado. Este ejemplo muestra los conceptos fundamentales: estado compartido, múltiples nodos, aristas condicionales y tool use.

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
import operator

# 1. Definir el estado compartido
class ResearchState(TypedDict):
    topic: str
    search_results: list[str]
    draft: str
    quality_score: int
    final_report: str

# 2. Crear el modelo
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 3. Definir los nodos (funciones)
def search_node(state: ResearchState) -> ResearchState:
    """Busca información sobre el tema"""
    topic = state["topic"]
    # En producción, aquí usarías Tavily, SerpAPI o similar
    response = llm.invoke(
        f"Busca y resume los 5 datos más importantes sobre: {topic}"
    )
    return {"search_results": [response.content]}

def write_node(state: ResearchState) -> ResearchState:
    """Redacta un borrador del informe"""
    results = state["search_results"]
    response = llm.invoke(
        f"Escribe un informe profesional basado en estos datos:
{results}"
    )
    return {"draft": response.content}

def review_node(state: ResearchState) -> ResearchState:
    """Evalúa la calidad del borrador"""
    draft = state["draft"]
    response = llm.invoke(
        f"Evalúa este informe del 1 al 10. "
        f"Responde SOLO con un número:
{draft}"
    )
    score = int(response.content.strip())
    return {"quality_score": score}

def finalize_node(state: ResearchState) -> ResearchState:
    """Publica el informe final"""
    return {"final_report": state["draft"]}

# 4. Definir la lógica condicional
def should_revise(state: ResearchState) -> str:
    if state["quality_score"] >= 7:
        return "finalize"  # Calidad suficiente
    return "search"  # Necesita más investigación

# 5. Construir el grafo
graph = StateGraph(ResearchState)

# Añadir nodos
graph.add_node("search", search_node)
graph.add_node("write", write_node)
graph.add_node("review", review_node)
graph.add_node("finalize", finalize_node)

# Añadir aristas
graph.set_entry_point("search")
graph.add_edge("search", "write")
graph.add_edge("write", "review")
graph.add_conditional_edges("review", should_revise, {
    "finalize": "finalize",
    "search": "search",  # Bucle: vuelve a investigar
})
graph.add_edge("finalize", END)

# 6. Compilar y ejecutar
app = graph.compile()
result = app.invoke({"topic": "Tendencias en agentes IA 2026"})
print(result["final_report"])

Este ejemplo ilustra las tres características que hacen único a LangGraph. Primero, el estado compartido (ResearchState) que todos los nodos pueden leer y modificar. Segundo, la arista condicional en el nodo de revisión que decide si el informe es suficientemente bueno o necesita más investigación. Tercero, el bucle que permite al agente iterar hasta alcanzar la calidad deseada, algo imposible con LangChain.

LangGraph vs CrewAI vs AutoGen vs OpenAI Agents SDK

La elección del framework correcto depende de tu caso de uso, tu nivel técnico y tus requisitos de producción. Esta comparativa te ayudará a decidir.

Recomendación práctica: Si estás empezando y quieres un prototipo rápido, usa CrewAI. Si necesitas control total y planeas llevar el agente a producción, usa LangGraph. Si ya usas Microsoft 365 y Azure, considera AutoGen (ahora fusionado con Semantic Kernel). Si quieres guardrails nativos y handoffs elegantes, prueba el OpenAI Agents SDK.

Patrones avanzados que debes conocer

Patrón Supervisor. Un agente coordinador decide qué agente especializado debe ejecutar cada sub-tarea. El supervisor analiza la solicitud del usuario, la descompone en pasos, y asigna cada paso al agente más adecuado. Este patrón es ideal cuando tienes agentes con habilidades complementarias: uno busca información, otro la analiza, otro la formatea.

Patrón Map-Reduce. El mismo trabajo se distribuye entre múltiples instancias del mismo agente que trabajan en paralelo. Cada instancia procesa una parte de los datos y al final se combinan los resultados. Útil para procesar grandes volúmenes: analizar 100 currículos, revisar 50 contratos, o clasificar 1.000 tickets de soporte.

Patrón Plan-and-Execute. El agente primero crea un plan completo con todos los pasos necesarios, y después ejecuta cada paso uno por uno. Después de cada paso, el agente evalúa si el plan original sigue siendo válido o necesita ajustes. Este patrón reduce los errores en tareas largas porque el agente tiene una visión global antes de empezar a actuar.

Patrón Reflexión. Después de generar un resultado, el agente lo evalúa críticamente y decide si es suficientemente bueno o necesita mejorarlo. Este es el patrón que usamos en nuestro ejemplo del investigador web: el nodo de revisión evalúa la calidad y, si no es suficiente, el agente vuelve a investigar. La reflexión es lo que permite a los agentes mejorar iterativamente sin intervención humana.

Recursos para seguir aprendiendo

La documentación oficial de LangGraph en python.langchain.com/docs/langgraph es el punto de partida más completo, con tutoriales paso a paso y ejemplos funcionales. LangSmith (smith.langchain.com) es la plataforma de monitorización y debugging donde puedes visualizar exactamente qué decide tu agente en cada paso. Para cursos estructurados, DeepLearning.AI ofrece un curso gratuito sobre Building Agentic RAG Systems que cubre LangGraph en profundidad.

Si prefieres aprender con código real, el repositorio de ejemplos de LangGraph en GitHub contiene implementaciones completas de todos los patrones mencionados: supervisor, map-reduce, plan-and-execute y reflexión. Cada ejemplo incluye comentarios detallados y se puede ejecutar directamente.

Preguntas frecuentes

Continuar profundizando en agentes IA

• Los mejores agentes de IA gratis 2026 — alternativas a LangGraph para empezar sin código
• Multi-agente: patrones para orquestar equipos de agentes — la teoría detrás de LangGraph
• CrewAI vs AutoGen vs LangGraph: comparativa definitiva — qué framework elegir según tu caso

Datos verificados 2026

• Los agentes IA autónomos han evolucionado para incluir capacidades de memoria y planificación, lo que permite una mayor autonomía en tareas complejas (fuente: Stanford HAI).
• LangGraph y LangChain son considerados los frameworks más robustos para el desarrollo de sistemas multi-agente en 2026 (fuente: OpenAI).
• Claude Opus 4.7 ha demostrado un contexto de 200k tokens, superando a sus predecesores en eficiencia y capacidad (fuente: Anthropic).
• El uso de patrones agénticos como ReAct y Chain-of-Thought ha mejorado significativamente la toma de decisiones en sistemas LLM (fuente: MIT CSAIL).
• Los sistemas multi-agente han adoptado arquitecturas de debate y enjambre para optimizar la colaboración entre agentes (fuente: Google DeepMind).
• El AI Act de la UE establece un marco regulatorio que impactará la implementación de IA autónoma en Europa a partir de 2026 (fuente: AI Index Report).
• Las tarifas por uso de API han variado, con precios que oscilan entre $0.25 y $15 por cada millón de tokens procesados (fuente: Cohere).

Daniel Bellido

Consultor de inteligencia artificial especializado en agentes autónomos y automatización empresarial. Ayudo a pymes y empresas españolas a implementar soluciones de IA agentica con herramientas como n8n, Make, LangChain y AutoGPT. Analizo plataformas, flujos de trabajo y casos de uso reales para que cualquier empresa pueda dar el salto a la IA en 2026.

See Full Bio