01 / 10
LangGraph para Dummies

Agentes con carriles, no con magia.

LangGraph te deja dibujar el camino que seguirá tu agente: qué hace, qué recuerda y cuándo decide.

Input→Nodo→Decisión→Fin
Desliza hacia arriba ↓
02 / 10
La idea mental

Piensa en un diagrama de flujo que puede pensar.

🧠

Estado

La mochila con los datos que viajan por todo el flujo.

⚙️

Nodos

Funciones: llamar al LLM, buscar datos, usar una tool, validar…

↪️

Edges

Las carreteras que conectan nodos. Algunas son condicionales.

Si tu flujo es solo “prompt → respuesta”, probablemente no necesitas LangGraph.
03 / 10
1 · State

Primero define qué sabe tu flujo.

Cada nodo recibe el estado y devuelve únicamente lo que quiere actualizar.

Ejemplo mínimo
from typing_extensions import TypedDict

class State(TypedDict):
    pregunta: str
    respuesta: str

Traducción: “Mi grafo transporta una pregunta y una respuesta”. Nada más.

04 / 10
2 · Nodes

Un nodo es solo una función.

Puede ser determinista o llamar a un modelo, una API o una herramienta.

def responder(state: State):
    pregunta = state["pregunta"]

    # Aquí podrías llamar a un LLM
    texto = f"Respuesta a: {pregunta}"

    return {"respuesta": texto}
Input entra. Algo ocurre. Estado sale.
05 / 10
3 · Graph

Ahora dibuja la carretera.

START
↓
responder()
↓
END
from langgraph.graph import StateGraph, START, END

g = StateGraph(State)
g.add_node("responder", responder)
g.add_edge(START, "responder")
g.add_edge("responder", END)

graph = g.compile()
06 / 10
4 · Run

Compilas una vez. Invocas cuando quieras.

result = graph.invoke({
    "pregunta": "¿Qué es RAG?",
    "respuesta": ""
})

print(result["respuesta"])

¿Qué hace LangGraph?

Recorre START → responder → END y va transportando el estado entre nodos.

¿Dónde está la IA?

Dentro de tus nodos. LangGraph no es el LLM: es el orquestador.

07 / 10
El superpoder

El grafo puede elegir camino.

clasificar()
↓
si necesita datos
buscar()
si ya sabe
responder()
def ruta(state):
    return "buscar" if necesita_datos(state) else "responder"

g.add_conditional_edges(
    "clasificar", ruta,
    {"buscar": "buscar", "responder": "responder"}
)
08 / 10
Persistencia

¿Y si quiero que recuerde?

Compila con un checkpointer. LangGraph guarda snapshots del estado por conversación.

from langgraph.checkpoint.memory import InMemorySaver

memory = InMemorySaver()
graph = g.compile(checkpointer=memory)

config = {"configurable": {"thread_id": "user-42"}}
graph.invoke(input, config)
Producción: usa persistencia durable. InMemorySaver es perfecto para aprender y probar.
09 / 10
Cuándo usarlo

LangGraph brilla cuando el agente deja de ser lineal.

✓
Loops“Busca → evalúa → vuelve a buscar si falta algo”.
✓
Tools + decisionesEl modelo decide cuándo consultar APIs o sistemas.
✓
Human-in-the-loopPausar, pedir aprobación y continuar después.
✓
Flujos largosPersistencia, reanudación y control explícito.
10 / 10
Chuleta final

Solo recuerda estas 5 piezas.

1
State¿Qué datos viajan?
2
Nodes¿Qué acciones existen?
3
Edges¿Qué conecta con qué?
4
Conditions¿Quién decide el siguiente paso?
5
Checkpoint¿Debe recordar y reanudarse?
LangGraph = estado + funciones + caminos.

Referencia: documentación oficial de LangGraph / LangChain. Conceptos simplificados deliberadamente para una primera toma de contacto.