Memoria para agentes: patrones que funcionan de verdad en producción

Todo framework de agentes promete memoria.

"Memoria persistente entre sesiones." "Aprendizaje a largo plazo." "Agentes que recuerdan."

Y luego intentas usarlo en producción.

Tu agent olvida contexto crítico a mitad de una conversación. La memoria se infla hasta que las respuestas se arrastran. El agente "recuerda" cosas que nunca ocurrieron. La recuperación saca memorias irrelevantes y se pierde las obvias.

He construido sistemas de memoria para agentes de resolución de disputas que manejan más de 15.000 casos, IA de marketing que mantiene la voz de marca a través de miles de interacciones, y asesores financieros que rastrean carteras complejas de clientes.

Esto es lo que aprendí: la memoria del agente es un problema de sistemas, no un interruptor de funcionalidad. Los frameworks te dan primitivas. Hacer que funcionen requiere arquitectura.

Por qué la memoria es difícil

Primero, entendamos por qué esto es más difícil de lo que parece.

La arquitectura de memoria que funciona

Después de construir varios sistemas en producción, he convergido en una arquitectura por capas:

Cada capa sirve a un propósito distinto. Cada una tiene características diferentes de almacenamiento, recuperación y ciclo de vida.

Capa 1: Memoria de trabajo

La memoria de trabajo es lo que está en el prompt ahora mismo. Es la conciencia inmediata del agente.

El patrón: Ventana deslizante + resumen

class WorkingMemory:
    def __init__(self, max_turns: int = 10, max_tokens: int = 4000):
        self.max_turns = max_turns
        self.max_tokens = max_tokens
        self.turns = []
        self.summary = ""

    def add_turn(self, role: str, content: str):
        self.turns.append({"role": role, "content": content})

        # If exceeding limits, summarize older turns
        if len(self.turns) > self.max_turns:
            self._compress()

    def _compress(self):
        # Summarize oldest turns
        old_turns = self.turns[:5]
        new_summary = llm.summarize(old_turns)

        # Update summary and remove old turns
        self.summary = f"{self.summary}\n{new_summary}"
        self.turns = self.turns[5:]

Idea clave: No simplemente trunques los mensajes antiguos—resúmelos. Pierdes detalle pero preservas lo importante.

Capa 2: Memoria a corto plazo

La memoria a corto plazo conecta sesiones. Es lo que el agente recuerda de más temprano hoy, ayer, esta semana.

El patrón: Caché con decaimiento temporal

class ShortTermMemory:
    def __init__(self, redis_client, decay_hours: int = 72):
        self.redis = redis_client
        self.decay_hours = decay_hours

    def store(self, user_id: str, key: str, value: dict):
        memory_key = f"stm:{user_id}:{key}"
        value["timestamp"] = time.time()
        value["access_count"] = 0
        self.redis.setex(
            memory_key,
            timedelta(hours=self.decay_hours),
            json.dumps(value)
        )

    def retrieve(self, user_id: str, key: str) -> dict | None:
        data = self.redis.get(f"stm:{user_id}:{key}")

        if data:
            value = json.loads(data)
            # Boost TTL on access (frequently accessed = more important)
            value["access_count"] += 1
            self.redis.setex(...)  # Extend TTL
            return value
        return None

Idea clave: Usa TTLs y patrones de acceso para decaer naturalmente las memorias irrelevantes. Las memorias que no se acceden se desvanecen.

Capa 3: Memoria a largo plazo

La memoria a largo plazo es conocimiento persistente. Perfiles de usuario, preferencias aprendidas, relaciones entre entidades.

El patrón: Híbrido estructurado + no estructurado

La memoria a largo plazo necesita tanto almacenamiento estructurado (para recuperación confiable) como almacenamiento no estructurado (para búsqueda semántica).

Idea clave: Usa el grafo para relaciones explícitas y consultas estructuradas. Usa vectores para similitud semántica. Necesitas ambos.

Capa 4: Memoria episódica

La memoria episódica almacena interacciones pasadas específicas—conversaciones memorables, decisiones clave, eventos importantes.

El patrón: Almacenamiento selectivo con scoring de importancia

No puedes almacenar cada interacción. Necesitas decidir qué vale la pena recordar.

Idea clave: No todas las interacciones merecen ser memorias. Puntúa la importancia y sé selectivo.

Errores comunes (y cómo evitarlos)

Consideraciones de rendimiento

La memoria añade latencia. Así es como se gestiona: