Introducción a Middlewares en Agentes

Qué es un Middleware

Un middleware es un componente que se interpone entre los pasos de ejecución de un agente, permitiendo interceptar y modificar el flujo de datos. Esta arquitectura proporciona control granular sobre el comportamiento del agente sin necesidad de modificar su lógica central.

Los middlewares resultan útiles para implementar funcionalidades transversales como:

• Gestión del historial: Resumir o recortar conversaciones largas
• Resiliencia: Configurar fallbacks cuando un modelo falla
• Guardrails: Aplicar validaciones de entrada y salida
• Observabilidad: Añadir logging, métricas y trazabilidad

El ciclo de vida del agente

Para entender cómo funcionan los middlewares, es necesario conocer el bucle de ejecución de un agente. El flujo básico sigue estos pasos:

[Inicio] → [Llamada al modelo] → [Ejecución de herramientas] → [Llamada al modelo] → ... → [Fin]

Los middlewares pueden engancharse (hook) en diferentes puntos de este ciclo:

• before_agent: Se ejecuta una vez al iniciar la invocación
• before_model: Se ejecuta antes de cada llamada al modelo
• after_model: Se ejecuta después de cada respuesta del modelo
• after_agent: Se ejecuta una vez al finalizar la invocación

Esta arquitectura permite encadenar múltiples middlewares que se ejecutan en secuencia, donde cada uno puede modificar el estado antes de pasarlo al siguiente.

Añadir middlewares a un agente

Para utilizar middlewares, se pasan como una lista al parámetro middleware de create_agent:

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="gpt-5",
    tools=[...],
    middleware=[
        SummarizationMiddleware(...)
    ]
)

Cuando se configuran varios middlewares, se ejecutan en orden para los hooks "before" y en orden inverso para los hooks "after". Esto garantiza que el último middleware en procesar la entrada sea el primero en procesar la salida.

SummarizationMiddleware

El SummarizationMiddleware gestiona automáticamente el tamaño del historial de conversación. Cuando la conversación supera un límite de tokens, resume los mensajes antiguos y los reemplaza por un resumen compacto.

Este middleware es especialmente útil en:

• Conversaciones largas que pueden exceder la ventana de contexto del modelo
• Diálogos multi-turno con historial extenso
• Aplicaciones donde preservar el contexto completo es importante

Configuración básica

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="gpt-5",
    tools=[weather_tool, calculator_tool],
    middleware=[
        SummarizationMiddleware(
            model="gpt-4o-mini",
            trigger={"tokens": 4000},
            keep={"messages": 20}
        )
    ]
)

Los parámetros principales son:

• model: Modelo a utilizar para generar el resumen. Puede ser diferente al modelo principal del agente, lo que permite usar un modelo más económico para esta tarea
• trigger: Condición que activa la resumización. En este caso, cuando el historial supera los 4000 tokens
• keep: Número de mensajes recientes que se mantienen sin resumir

Funcionamiento interno

Cuando la conversación alcanza el umbral configurado, el middleware ejecuta automáticamente estas acciones:

• 1. Identifica los mensajes que superan el límite
• 2. Genera un resumen utilizando el modelo configurado
• 3. Reemplaza los mensajes antiguos con un mensaje de resumen
• 4. Mantiene los mensajes recientes intactos

A diferencia de un simple recorte de mensajes, la resumización actualiza permanentemente el estado. Los turnos futuros verán el resumen en lugar de los mensajes originales, lo que preserva el contexto sin consumir tokens innecesarios.

# Ejemplo de conversación antes de resumir
# [msg1, msg2, msg3, ..., msg50, msg51, msg52]

# Después de resumir (keep=20)
# [resumen_msg1_a_msg32, msg33, msg34, ..., msg52]

ModelFallbackMiddleware

El ModelFallbackMiddleware proporciona resiliencia automática cuando el modelo principal falla. Configura una cadena de modelos alternativos que se prueban en secuencia hasta que uno responde correctamente.

Este middleware resulta útil para:

• Construir agentes resilientes que soporten caídas de servicio
• Optimización de costes usando modelos más baratos como fallback
• Redundancia entre proveedores (OpenAI, Anthropic, Google, etc.)

Configuración básica

from langchain.agents import create_agent
from langchain.agents.middleware import ModelFallbackMiddleware

agent = create_agent(
    model="gpt-5",
    tools=[...],
    middleware=[
        ModelFallbackMiddleware(
            "gpt-4o-mini",
            "claude-sonnet-4-20250514"
        )
    ]
)

En este ejemplo, si gpt-5 falla, el middleware intentará automáticamente con gpt-4o-mini. Si este también falla, probará con claude-sonnet-4-20250514.

Estrategias de fallback

El orden de los modelos en la configuración define la prioridad de fallback. Puedes diseñar diferentes estrategias según tus necesidades:

Estrategia por coste:

ModelFallbackMiddleware(
    "gpt-4o-mini",      # Modelo económico primero
    "gpt-5"             # Modelo premium como respaldo
)

Estrategia por proveedor:

ModelFallbackMiddleware(
    "gpt-4o",                       # OpenAI como respaldo
    "claude-sonnet-4-20250514"      # Anthropic como segundo respaldo
)

El middleware captura errores de conexión, timeouts y respuestas de error del proveedor. Cuando detecta un fallo, registra el error internamente y reintenta con el siguiente modelo de la lista sin interrumpir la experiencia del usuario.

Combinar múltiples middlewares

Los middlewares se pueden componer para crear comportamientos complejos. Cada middleware se centra en una responsabilidad específica y la combinación produce el efecto deseado:

from langchain.agents import create_agent
from langchain.agents.middleware import (
    SummarizationMiddleware,
    ModelFallbackMiddleware
)

agent = create_agent(
    model="gpt-5",
    tools=[search_tool, calculator_tool],
    middleware=[
        SummarizationMiddleware(
            model="gpt-4o-mini",
            trigger={"tokens": 3000},
            keep={"messages": 15}
        ),
        ModelFallbackMiddleware(
            "gpt-4o-mini",
            "claude-sonnet-4-20250514"
        )
    ]
)

En esta configuración:

• El SummarizationMiddleware mantiene el historial bajo control
• El ModelFallbackMiddleware garantiza la disponibilidad del servicio

El orden de los middlewares en la lista importa. Los hooks before_model se ejecutan en el orden definido (primero resumización, luego fallback), mientras que los hooks after_model se ejecutan en orden inverso.

Esta arquitectura modular permite añadir o quitar funcionalidades sin modificar la lógica del agente, facilitando el mantenimiento y la evolución de aplicaciones basadas en agentes.

Otros middleware

Hemos comentado dos middleware que proporciona LangChain de manera nativa, pero no son los únicos, existen otros:

• HumanInTheLoopMiddleware: Añade supervisión humana a las llamadas de herramientas del agente, pausando la ejecución hasta recibir una decisión de aprobación, edición o rechazo.
• ModelCallLimitMiddleware: Limita el número de llamadas al modelo por ejecución de agente para controlar costes y evitar bucles excesivos.
• ToolCallLimitMiddleware: Restringe la cantidad de ejecuciones de herramientas por conversación, cortando flujos que hacen un uso desmedido de tools.
• PIIMiddleware: Detecta y trata información personal sensible (PII) antes de enviarla al modelo, aplicando redacción o bloqueo según la política definida.
• LLMToolEmulator: Emula la salida de herramientas utilizando un modelo de lenguaje, útil para pruebas sin tocar sistemas externos reales.
• LLMToolSelectorMiddleware: Utiliza un modelo de lenguaje para seleccionar dinámicamente qué subconjunto de herramientas es relevante antes de cada llamada al modelo principal.
• TodoListMiddleware: Proporciona al agente una lista de tareas interna para planificar, desglosar y hacer seguimiento de subtareas durante la ejecución.
• ModelRetryMiddleware: Reintenta automáticamente llamadas al modelo que fallan por errores transitorios, aplicando lógica de reintentos configurable.
• ToolRetryMiddleware: Reintenta ejecuciones de herramientas que devuelven errores recuperables, reduciendo fallos por incidencias puntuales en servicios externos.
• ContextEditingMiddleware / ClearToolUsesEdit: Permiten editar el contexto de la conversación, por ejemplo limpiando usos antiguos de herramientas que ya no aportan información relevante.
• ShellToolMiddleware / HostExecutionPolicy: Controlan cómo se ejecutan comandos de shell desde el agente, definiendo políticas de seguridad sobre qué operaciones y hosts están permitidos.
• FilesystemFileSearchMiddleware: Gestiona el acceso del agente al sistema de archivos, permitiendo buscar y limitar qué ficheros pueden leerse o utilizarse como contexto.