Lección 1 de 20 · Lectura y práctica
Configuración del entorno y primeros pasos con LangGraph
Concepto claveLangGraph es un framework para construir agentes de IA que pueden tomar decisiones secuenciales, mantener memoria entre interacciones y utilizar herramientas externas. Piensa en un agente como un asistente virtual.
Del concepto a la práctica
Taller de esta lección
La configuración útil no consiste en instalar muchas piezas, sino en fijar un experimento reproducible: estado pequeño, entradas conocidas y una ruta observable. Para empezar, separa el entorno de ejecución de la lógica del grafo y registra el estado inicial.
Ejemplo resuelto
from typing import TypedDict
class Estado(TypedDict):
consulta: str
eventos: list[str]
def registrar(s: Estado):
return {"eventos": s["eventos"] + ["recibida"]}
estado = {"consulta": "saldo", "eventos": []}
print(registrar(estado)["eventos"])
# ['recibida']En un entorno virtual de práctica con LangGraph instalado, conecta realmente ambos nodos. TypedDict expresa tipos para las herramientas de desarrollo; no valida entradas en runtime.
from langgraph.graph import StateGraph, START, END
def clasificar(s: Estado):
return {"eventos": s["eventos"] + ["clasificada"]}
builder = StateGraph(Estado)
builder.add_node("registrar", registrar)
builder.add_node("clasificar", clasificar)
builder.add_edge(START, "registrar")
builder.add_edge("registrar", "clasificar")
builder.add_edge("clasificar", END)
grafo = builder.compile()
resultado = grafo.invoke({"consulta": "factura", "eventos": []})
assert resultado["consulta"] == "factura"
assert resultado["eventos"] == ["recibida", "clasificada"]No hay un reducer acumulativo en eventos: cada nodo devuelve la lista nueva completa. Con operator.add como reducer devolverías solo el evento nuevo, para no duplicar el historial. Registra versiones y usa un directorio de laboratorio sin credenciales.
Pruébalo
Crea un estado con
consultayeventos.Ejecuta un nodo que añada
clasificada.Conserva la entrada original y muestra la lista final.
Compara el resultado con la ruta esperada.
Un error frecuente es guardar variables de configuración dentro del estado de negocio. Corrígelo manteniendo configuración y datos de ejecución en estructuras separadas.
Comprueba tu resultado
Usa la consulta "factura". La lista debe quedar exactamente ['recibida', 'clasificada']; la consulta debe seguir siendo factura.

Mapa de prácticaUn agente mantiene un estado y utiliza herramientas dentro de límites definidos. El resultado de cada herramienta actualiza ese estado para decidir el siguiente paso. Las acciones de alto impacto deben pasar por una revisión humana antes de ejecutarse.
Ver la infografía en tamaño completo ↗Concepto clave
LangGraph es un framework para construir agentes de IA que pueden tomar decisiones secuenciales, mantener memoria entre interacciones y utilizar herramientas externas. Piensa en un agente como un asistente virtual que no solo responde preguntas, sino que planifica acciones, recuerda conversaciones pasadas y ejecuta tareas usando APIs o bases de datos.
La arquitectura se basa en grafos dirigidos donde los nodos representan estados o acciones, y las aristas definen transiciones condicionales. Esto permite modelar flujos complejos como: "si el usuario pide un informe, primero consulta la base de datos, luego formatea los datos, y finalmente envía un correo". La memoria se implementa como un estado persistente que se actualiza en cada paso, permitiendo al agente aprender del contexto.
"LangGraph transforma prompts estáticos en procesos dinámicos que pueden adaptarse en tiempo real."
Cómo funciona en la práctica
Para configurar el entorno, sigue estos pasos:
- Instala LangGraph y dependencias:
pip install langgraph langchain-openai - Configura tu API key de OpenAI en variables de entorno.
- Crea un archivo Python con la estructura básica de un agente.
Ejemplo de código inicial:
from langgraph.graph import StateGraph, END
from typing import TypedDict
class AgentState(TypedDict):
message: str
memory: list
tools_used: list
def process_input(state: AgentState):
# Lógica para procesar entrada
return {"memory": state["memory"] + [state["message"]]}
graph = StateGraph(AgentState)
graph.add_node("procesar", process_input)
graph.add_edge("procesar", END)
graph.set_entry_point("procesar")
app = graph.compile()Este código define un grafo simple que procesa un mensaje y lo almacena en memoria. El estado AgentState incluye campos para el mensaje, la memoria y las herramientas usadas.
Caso de estudio
Imagina un agente para soporte técnico que usa herramientas y memoria. El agente debe:
- Recordar problemas previos del usuario (memoria).
- Consultar una base de conocimientos (herramienta).
- Decidir si escalar a un humano (decisión condicional).
Implementación clave:
| Paso | Acción | Herramienta |
|---|---|---|
| 1 | Recibir consulta | Ninguna |
| 2 | Buscar en memoria | Base de datos local |
| 3 | Si no hay solución, buscar en KB | API de conocimientos |
| 4 | Decidir escalar | Lógica condicional |
El grafo controla este flujo, actualizando la memoria después de cada paso para evitar repeticiones.
Errores comunes
- No inicializar memoria correctamente: Olvidar definir un estado inicial puede causar errores en tiempo de ejecución. Siempre prueba con un estado vacío.
- Mal manejo de herramientas asíncronas: Si usas APIs externas, asegúrate de manejar tiempos de espera y fallos con
try-except. - Grafos cíclicos infinitos: Diseña transiciones que siempre lleven a un nodo final o condición de salida.
- Ignorar el costo computacional: Agregar muchas herramientas o nodos puede ralentizar el agente. Optimiza con caching.
Checklist de dominio
- ¿Puedes instalar LangGraph y configurar un entorno de desarrollo?
- ¿Entiendes cómo definir un estado personalizado con
TypedDict? - ¿Sabes agregar nodos y aristas a un grafo?
- ¿Puedes implementar una herramienta simple (ej., consultar una API)?
- ¿Comprendes cómo la memoria persiste entre llamadas?
- ¿Eres capaz de depurar un grafo que falla en tiempo de ejecución?
- ¿Puedes explicar la diferencia entre un nodo y una herramienta en LangGraph?
Construye un agente de recordatorios con memoria y herramientas
Crea un agente que gestione recordatorios usando LangGraph. Sigue estos pasos:
- Configura un entorno virtual e instala LangGraph y una biblioteca para fechas (ej.,
datetime). - Define un estado con campos para:
tarea(string),fecha(datetime),memoria(lista de tareas completadas). - Implementa dos nodos: uno para agregar una tarea a la memoria, y otro para listar tareas pendientes (usando la fecha actual como filtro).
- Añade una herramienta que use una API ficticia para enviar un correo de recordatorio (simula la llamada con una función que imprima en consola).
- Conecta los nodos en un grafo donde, después de agregar una tarea, se decida si enviar un recordatorio basado en la fecha.
- Prueba el agente con al menos tres tareas diferentes y verifica que la memoria persista.
Entrega el código completo y una explicación de cómo el grafo maneja las decisiones.
Pistas
- Usa
StateGraphpara definir el grafo yadd_nodepara cada función. - Para la decisión condicional, investiga el método
add_conditional_edgesen la documentación. - Simula la herramienta de correo con un
printpara evitar dependencias externas.
Evalua tu comprension
Completa el quiz interactivo de arriba para ganar XP.
Sigue con LangGraph para Automatización: Memoria, Estado y Decisiones
Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.
Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.