Primer módulo del Curso completo de LangGraph. Vamos desde cero: no necesitas haber tocado LangGraph antes, pero sí ayuda saber qué es un LLM (si no, pasa antes por Cómo funciona la IA). Este módulo es conceptual: entender qué problema resuelve LangGraph antes de escribir una sola línea. El código empieza en el Módulo 2.

La tesis del módulo

LangGraph te devuelve el control del flujo. En vez de dejar que el LLM decida todo de una vez, modelas tu agente como un grafo: tú defines los pasos, las decisiones y qué información viaja entre ellos. El modelo piensa; tú orquestas.

El problema: las cadenas lineales se quedan cortas

La forma clásica de usar un LLM es una cadena (chain): entra un prompt, sale una respuesta. Entrada → paso 1 → paso 2 → salida. Una línea recta.

Eso funciona para tareas simples. Pero un agente de verdad necesita cosas que una línea recta no da:

Ciclos — “intenta, evalúa el resultado, y si no sirve, vuelve a intentar”. Una cadena no puede volver atrás.
Ramas — “si el usuario pregunta por facturas, ve por aquí; si es soporte técnico, por allá”.
Estado que persiste — recordar lo que pasó en pasos anteriores (o en conversaciones anteriores).
Puntos de control humano — pausar y esperar una aprobación antes de ejecutar algo sensible.

Cuando intentas forzar todo esto en una cadena lineal, terminas con código frágil lleno de if anidados. LangGraph nace justo para esto: es la librería del ecosistema LangChain pensada para construir aplicaciones con estado, ciclos y control de flujo explícito.

La idea central: tu agente es un grafo

Un grafo (glosado en el glosario) es simplemente nodos conectados por flechas. En LangGraph:

Pieza	Qué es	Analogía
Nodo (node)	Una función que hace un trabajo (llamar al LLM, usar una tool, transformar datos)	Una estación de trabajo
Arista (edge)	Una flecha que dice “después de este nodo, ve a este otro”	El riel que conecta estaciones
Estado (state)	La información que viaja por el grafo y todos los nodos leen y actualizan	La cinta transportadora con la pieza que se va armando

Piénsalo como un diagrama de flujo con memoria. Cada nodo recibe el estado actual, hace lo suyo, y devuelve una actualización del estado. Las aristas deciden a dónde va la pieza después.

START ──► ┌────────┐     ┌────────────┐     ┌───────┐
          │ agente │ ──► │ ¿decisión? │ ──► │ final │ ──► END
          └────────┘     └─────┬──────┘     └───────┘
               ▲               │
               └───────────────┘
                  reintentar

Esa flecha que vuelve hacia atrás —el ciclo— es lo que una cadena lineal no puede hacer y lo que convierte a un grafo en un agente.

LangGraph vs LangChain: no compiten

Es la confusión más común. No es “LangGraph o LangChain”:

LangChain te da los ladrillos: conectores a modelos, tools, parsers, integraciones.
LangGraph te da la arquitectura para orquestar esos ladrillos con estado y control de flujo.

Usas LangChain dentro de los nodos de tu grafo LangGraph. Uno no reemplaza al otro.

¿Cuándo usar LangGraph y cuándo no?

No todo necesita un grafo. Sé honesto con la complejidad de tu caso:

Sí conviene LangGraph:

El agente debe decidir entre varios caminos según el contexto.
Necesitas ciclos (reintentos, refinamiento, bucles de razonamiento y acción).
Quieres memoria persistente entre pasos o entre sesiones.
Necesitas human-in-the-loop (aprobaciones, correcciones).
Vas a producción y quieres trazabilidad y capacidad de retomar ejecuciones.

No hace falta (todavía):

Una sola llamada al LLM con un prompt. Usa LangChain directo.
Un flujo lineal fijo de 2-3 pasos sin decisiones ni estado. Una cadena basta.

Regla práctica: si puedes dibujar tu solución como una lista de pasos, una cadena alcanza. Si necesitas dibujarla como un diagrama con flechas que se ramifican o vuelven atrás, es LangGraph.

Errores comunes

Tratar LangGraph como un reemplazo de LangChain. No compiten: LangChain da los ladrillos (modelos, tools, parsers) y LangGraph la arquitectura para orquestarlos. Los nodos de tu grafo usan LangChain adentro.
Armar un grafo para una sola llamada al modelo. Si tu solución se dibuja como una lista de pasos, una cadena alcanza. El grafo se justifica cuando hay decisiones, ciclos o pausas.
Pedirle al LLM que decida todo el flujo. El punto de LangGraph es lo contrario: tú defines los caminos posibles y el modelo elige dentro de ellos. Un agente sin estructura es un prompt largo con esperanza.
Creer que el estado es la memoria del modelo. El modelo no recuerda nada entre llamadas: lo que viaja entre nodos es el estado que tú definiste, y lo que persiste entre turnos es lo que tú guardaste (módulo 6).
Saltarse los módulos sin LLM. Los módulos 2 a 4 construyen grafos con funciones normales de Python a propósito: si no entiendes la mecánica de estado y aristas sin el modelo, con el modelo tampoco la vas a entender.

La frase para llevarse

“Una cadena ejecuta pasos; un grafo toma decisiones. LangGraph es lo que convierte una secuencia en un agente.”

Qué viene

En el Módulo 2 construimos tu primer grafo funcional en Python: StateGraph, definir el estado, escribir nodos y conectarlos. De la teoría al código.

Material relacionado

Glosario de LangGraph — todos los términos del curso en simple
Chatbot, workflow o agente — el espectro de autonomía
Cómo funciona un agente por dentro — el harness que rodea al modelo

LangGraph — Módulo 1: qué es y por qué existe