LangGraph y Flujos de Trabajo IA - Tutorial de LangChain | TechLead

¿Qué es LangGraph?

LangGraph es la biblioteca de LangChain para construir aplicaciones de IA con estado y múltiples pasos como grafos. Mientras que las cadenas son lineales (A → B → C), los grafos permiten ramificación, bucles y lógica condicional — esenciales para agentes de IA complejos.

🔀 Cadenas vs Grafos

⛓️ Cadenas (Lineales)

Entrada → Prompt → LLM → Salida

Buenas para flujos simples y predecibles

🔀 Grafos (LangGraph)

Nodos → Aristas condicionales → Bucles → Estado

Agentes complejos, razonamiento multi-paso, humano-en-el-bucle

Instalación

npm install @langchain/langgraph @langchain/core @langchain/openai

Conceptos Fundamentales

📌 Estado

Datos compartidos que fluyen por el grafo y persisten entre pasos

⬡ Nodos

Funciones que procesan el estado — cada nodo es un paso del flujo

→ Aristas

Conexiones entre nodos — definen el orden del flujo

⑂ Aristas Condicionales

Enrutamiento dinámico basado en estado — permite lógica de ramificación

Construyendo Tu Primer Grafo

import { StateGraph, Annotation, END, START } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

// 1. Definir el esquema del estado
const EstadoGrafo = Annotation.Root({
  messages: Annotation<string[]>({
    reducer: (current, update) => [...current, ...update],
    default: () => [],
  }),
  pasoActual: Annotation<string>({
    reducer: (_, update) => update,
    default: () => "inicio",
  }),
});

// 2. Definir funciones de nodos
async function analizarEntrada(state: typeof EstadoGrafo.State) {
  const ultimoMensaje = state.messages[state.messages.length - 1];
  return {
    messages: [`Análisis: "${ultimoMensaje}" ha sido analizado.`],
    pasoActual: "analizado",
  };
}

async function generarRespuesta(state: typeof EstadoGrafo.State) {
  const model = new ChatOpenAI({ modelName: "gpt-4" });
  const response = await model.invoke(state.messages.join("\n"));
  return {
    messages: [response.content as string],
    pasoActual: "completado",
  };
}

// 3. Construir el grafo
const workflow = new StateGraph(EstadoGrafo)
  .addNode("analizar", analizarEntrada)
  .addNode("generar", generarRespuesta)
  .addEdge(START, "analizar")
  .addEdge("analizar", "generar")
  .addEdge("generar", END);

// 4. Compilar y ejecutar
const app = workflow.compile();

const resultado = await app.invoke({
  messages: ["Explica Docker en términos simples"],
});

Enrutamiento Condicional

function enrutarPorCategoria(state: typeof EstadoGrafo.State) {
  if (state.categoria.includes("técnico")) return "tecnico";
  if (state.categoria.includes("queja")) return "queja";
  return "general";
}

const workflow = new StateGraph(EstadoGrafo)
  .addNode("clasificar", clasificar)
  .addNode("tecnico", manejarTecnico)
  .addNode("general", manejarGeneral)
  .addNode("queja", manejarQueja)
  .addEdge(START, "clasificar")
  .addConditionalEdges("clasificar", enrutarPorCategoria, {
    tecnico: "tecnico",
    general: "general",
    queja: "queja",
  })
  .addEdge("tecnico", END)
  .addEdge("general", END)
  .addEdge("queja", END);

💡 Puntos Clave

• LangGraph construye flujos de trabajo de IA como grafos dirigidos con estado, nodos y aristas
• Las aristas condicionales permiten enrutamiento dinámico basado en decisiones del LLM
• Los bucles permiten refinamiento iterativo (escribir → revisar → revisar → revisar...)
• El estado persiste entre nodos y puede personalizarse con reductores
• Usa LangGraph cuando las cadenas son demasiado simples — agentes multi-paso, humano-en-el-bucle, ramificación