Agentes LangChain en 2026: ReAct, LangGraph y Production Patterns — EasyClaw

AgentExecutor frente a LangGraph: qué cambió y por qué es importante

Comprender la ruta de migración requiere comprender por qué se retiró AgentExecutor. No fue arbitrario: tocó límites arquitectónicos fundamentales cuando los desarrolladores intentaron construir sistemas de producción.

La limitación más dolorosa de AgentExecutor fue la imposibilidad de hacer una pausa a mitad de la ejecución y reanudarla más tarde. Cualquier flujo de trabajo real (piense en "redactar un informe, esperar la aprobación humana y luego publicarlo") requiere un estado persistente a través de límites de tiempo. El puntero de control de LangGraph resuelve esto de forma nativa.

El patrón ReAct: razonar + actuar en un bucle

ReAct (Razón + Actuación) es el patrón de activación fundamental detrás de la mayoría de los agentes LangChain. Le indica al LLM que alterne entre dos modos: Thought (razonamiento interno sobre qué hacer a continuación) y Acción (llamar a una herramienta específica con argumentos específicos).

El bucle se ve así en la práctica:

1. Thought: El LLM razona sobre la solicitud del usuario y las herramientas disponibles.
2. Action: El LLM genera una llamada de herramienta estructurada (nombre + argumentos).
3. Observation: La herramienta se ejecuta y devuelve un resultado, adjunto al contexto.
4. Thought again: El LLM razona sobre la observación.
5. Respuesta final: Cuando el LLM determina que tiene suficiente información, genera la respuesta final.

En LangGraph, cada uno de estos pasos es un nodo en un gráfico. La ventaja condicional después del nodo LLM verifica: "¿el modelo llamó a una herramienta o generó una respuesta final?" - y rutas en consecuencia. Esto hace que el bucle ReAct sea explícito e inspeccionable en lugar de implícito dentro de un ejecutor de caja negra.

Los LLM modernos (GPT-4o, Claude 3.7, Gemini 2.5) manejan ReAct de forma nativa a través de sus API de llamada de funciones/uso de herramientas. Ya no es necesario formatear manualmente las cadenas "Thought/Action/Observation"; la capacidad de uso de herramientas del modelo maneja esto a nivel de API. LangGraph envuelve esto limpiamente para que sus nodos permanezcan enfocados en la lógica empresarial.

Building a LangGraph Agent Step by Step

Aquí está el patrón mínimo del agente LangGraph en Python. Cada agente de producción es una variación de este esqueleto.

1. Define State

El Estado es la única fuente de verdad que fluye a través de cada nodo. Utilice TypedDict o un modelo Pydantic:

from typing import Annotated, Sequence
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages
from typing_extensions import TypedDict

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]
    # add any custom fields your agent needs
    context: str
    iteration_count: int

2. Define Tools

Las herramientas son funciones simples de Python decoradas con @tool. La cadena de documentación se convierte en la descripción de la herramienta que ve el LLM:

from langchain_core.tools import tool

@tool
def search_web(query: str) -> str:
    """Search the web for current information about a topic."""
    # your search implementation here
    return results

@tool
def write_file(filename: str, content: str) -> str:
    """Write content to a file on disk."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Written {len(content)} chars to {filename}"

tools = [search_web, write_file]

3. Build the Graph

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)

def agent_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState):
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")

app = graph.compile()

4. Add a Checkpointer para la persistencia

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("./agent_memory.db")
app = graph.compile(checkpointer=checkpointer)

# Now every run is persisted and resumable
config = {"configurable": {"thread_id": "user-session-123"}}
result = app.invoke({"messages": [("human", "Research LangGraph and write a summary")]}, config)

LangGraph in JavaScript / TypeScript: Paridad de funciones completas

A partir de 2026, @langchain/langgraph tiene paridad de funciones completa con el SDK de Python. Si está creando backends Node.js, acciones de servidor Next.js o rutas API de Nuxt, cuenta con soporte completo.

import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Define a tool with Zod schema
const searchWeb = tool(
  async ({ query }) => {
    const results = await yourSearchFunction(query);
    return results;
  },
  {
    name: "search_web",
    description: "Search the web for current information",
    schema: z.object({ query: z.string() }),
  }
);

// State type
interface AgentState {
  messages: BaseMessage[];
}

const llm = new ChatOpenAI({ model: "gpt-4o" }).bindTools([searchWeb]);

// Build graph — identical pattern to Python
const graph = new StateGraph<AgentState>({ channels: messagesStateReducer })
  .addNode("agent", async (state) => ({
    messages: [await llm.invoke(state.messages)],
  }))
  .addNode("tools", new ToolNode([searchWeb]))
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue)
  .addEdge("tools", "agent");

const app = graph.compile();

El SDK JS/TS admite los mismos puntos de control (en memoria para desarrollo, PostgreSQL para producción), la misma API de transmisión (streamEvents) y la misma integración de seguimiento de LangSmith. El modelo mental se transfiere directamente entre idiomas.

Arquitecturas multiagente: orquestadores y subgrafos

Los sistemas de agente único alcanzan sus límites rápidamente: las ventanas de contexto se desbordan, la especialización se ve afectada y las tareas complejas requieren coordinación. En 2026, las implementaciones de producción de LangGraph casi siempre utilizan patrones de múltiples agentes.

Los tres patrones centrales

LangGraph implementa sistemas multiagente a través de composición del subgrafo. Cada agente especializado es un gráfico compilado que se integra como un nodo en el gráfico del orquestador principal. El estado puede fluir entre niveles y cada subgrafo puede tener su propio puntero de control y memoria.

Production Patterns: Lo que las demostraciones de juguetes no te muestran

Hacer que un agente LangGraph trabaje en un cuaderno Jupyter es una cosa. Ejecutarlo de manera confiable a escala es otra. Estos son los patrones que separan el prototipo de la producción.

Error Handling and Retry Logic

Los fallos de las herramientas son inevitables: límites de velocidad, tiempos de espera de la red, resultados con formato incorrecto. LangGraph le ofrece dos palancas: prueba/captura a nivel de nodo que devuelve un mensaje de error al LLM (lo que le permite recuperarse correctamente) y políticas de reintento a nivel de gráfico en los bordes.

Iteration Limits

Configure siempre recursion_limit al compilar. Sin él, un LLM confuso puede repetirse indefinidamente y quemar su presupuesto de API. Un valor predeterminado razonable es 25 iteraciones para la mayoría de las tareas.

app = graph.compile(checkpointer=checkpointer)
# Invoke with recursion limit
result = app.invoke(
    {"messages": [("human", query)]},
    config={"recursion_limit": 25, "configurable": {"thread_id": thread_id}}
)

Interrupciones humanas en el circuito

Las opciones de compilación interrupt_before y interrupt_after de LangGraph le permiten pausar la ejecución en nodos específicos, mostrar el estado actual a un humano, recopilar información y reanudarla. Esto es indispensable para los flujos de trabajo de aprobación, las puertas de revisión de contenido y las llamadas de herramientas de alto riesgo.

Streaming para UX en tiempo real

Para aplicaciones orientadas al usuario, la transmisión no es negociable. astream_events de LangGraph le brinda eventos granulares: qué nodo se está ejecutando, qué herramienta se llamó y salida LLM token por token. Conecte esto a Server-Sent Events (SSE) o WebSockets para obtener progreso en vivo en su interfaz de usuario.

Observability with LangSmith

Configure LANGCHAIN_TRACING_V2=true y cada ejecución de agente obtendrá un seguimiento completo: qué nodos se activaron, qué vio el LLM, qué devolvió cada herramienta, latencia total y costos de token. Así es como se depura el "¿por qué llamó a la herramienta incorrecta?" clase de errores de producción, no declaraciones impresas.

Real-World LangChain Agent Use Cases in 2026

Los patrones anteriores abren una amplia gama de aplicaciones de producción. Estas son las categorías en las que los agentes de LangGraph están aportando valor real hoy en día.

Cómo elegir la arquitectura de agente adecuada para su caso de uso

No todos los problemas necesitan un gráfico complejo de múltiples agentes. Aquí tienes un marco de decisión basado en lo que realmente estás intentando construir.

Una heurística práctica: Comience con el patrón más simple que pueda funcionar, instrumente con LangSmith y luego identifique el cuello de botella.. Los ingenieros que diseñan teniendo en cuenta la complejidad desde el principio casi siempre diseñan demasiado su sistema de primer agente. Los patrones de LangGraph facilitan la transición a arquitecturas más complejas a medida que los requisitos se vuelven claros.

Frequently Asked Questions

Reflexiones finales: LangGraph es el estándar para agentes en 2026

Los "agentes LangChain" que debería crear en 2026 son máquinas de estado LangGraph. La era obsoleta AgentExecutor ha terminado. El estado explícito de LangGraph, el enrutamiento condicional, los puntos de control persistentes y la composición nativa de múltiples agentes no son cosas agradables: son requisitos previos para cualquier cosa en la que confíes en producción.

El patrón ReAct sigue siendo el punto de partida correcto para la mayoría de las tareas. Agregue complejidad de múltiples agentes solo cuando se demuestre que un solo agente alcanza sus límites. Instrumente todo con LangSmith desde el primer día: la depuración sin rastros es la forma más rápida de perder una semana en un problema que tarda 10 minutos en diagnosticarse con visibilidad.

El cambio más importante es conceptual: los agentes LangGraph no son chatbots con herramientas integradas. Son sistemas persistentes y con estado en los que un LLM impulsa el flujo de control. Diseñelos como sistemas distribuidos (con modos de falla, lógica de reintento, límites de estado y observabilidad) y lo recompensarán con una confiabilidad que sorprenderá incluso a los ingenieros experimentados.

Si está creando automatización de contenido, canales de SEO o flujos de trabajo de investigación de varios pasos, EasyClaw es la forma más rápida de ver estos patrones en acción, sin pasar semanas conectando la infraestructura usted mismo.