Diseño de sistemas de memoria para agentes: de la sesión a la memoria a largo plazo

Hablamos todo el día con un agente de IA: arquitectura, stack, riesgos. Al día siguiente abro la misma conversación y pregunta: «¿Sobre qué le gustaría hablar?»

Preferencias, conclusiones, seguimiento — todo perdido. No es falta de capacidad del agente, es diseño: el LLM es stateless por defecto; cada petición empieza en blanco salvo que construyas memoria. Muchos equipos lo descubren tras el despliegue, con quejas de «¿por qué preguntas otra vez?» y «¿qué pasó con lo acordado?».

Este artículo comparte un blueprint completo: tipos de memoria, pipeline en cinco fases, elección de framework y control de costos.

Capítulo 1: ¿Por qué un agente necesita memoria?

El LLM tiene «memoria de pez dorado». Una petición, una respuesta, fin. La siguiente petición vuelve a estado limpio. No es defecto: diseño para inferencia independiente y salidas predecibles.

En escenarios de agente es un desastre.

Un agente de soporte: el usuario dice «quiero cambiar la dirección». El agente pide la nueva. El usuario: «la del almacén de la vez pasada». El agente no sabe de qué almacén hablas.

Peor aún: Context Rot — el contexto crece, se llena de ruido. Una pregunta simple obliga a buscar en decenas de turnos. Según el blog de Redis, el esquema de contexto completo lleva la latencia p95 a 17,12 s y multiplica el gasto en tokens por 14.

La brecha de costo es brutal: contexto completo ~$1M/mes vs memoria selectiva ~$100K/mes. Diez veces.

La tensión: quieres que recuerde todo, pero no puedes meterlo todo en la ventana de contexto. Solución: un sistema de memoria.

Resuelve tres problemas:

Continuidad entre sesiones: si hoy prefiere respuestas en chino, debe recordarlo mañana y el mes que viene.

Experiencia personalizada: hábitos, contexto de negocio e historial distintos por usuario; el agente «reconoce» a cada uno.

Recuperación tras fallos: si el agente falla a mitad de tarea, reinicia donde quedó, no desde cero.

Capítulo 2: Cuatro tipos de memoria

La memoria tiene capas y roles. La ciencia cognitiva distingue trabajo, episódica, semántica y largo plazo — el diseño del agente puede copiar ese modelo.

Memoria de trabajo (Working Memory)

Es la «cabeza» de la sesión actual: lo que acabas de decir, progreso de la tarea, resultados intermedios.

Vultr - Servidor cloud NVMe de alto rendimiento, 32 ubicaciones globales, despliegue Docker con un clic

Ver precios →Anuncio

Vive en la ventana de contexto. Ciclo de vida corto: al cerrar la conversación se vacía.

Implementación típica: Redis o KV Store + Checkpointer que guarda snapshots. MemorySaver de LangGraph es un ejemplo: tras cada nodo guarda estado en memoria o BD.

Memoria episódica (Episodic Memory)

Registro de «qué pasó»: preguntas, respuestas, decisiones, en orden temporal.

Persiste entre sesiones. Mañana puedes consultar eventos de ayer.

Almacenamiento: flujos de eventos (Redis Streams) o BD temporal. Optimización clave: compresión por resumen — el LLM condensa eventos largos conservando lo esencial.

Memoria semántica (Semantic Memory)

«Qué se sabe»: hechos abstractos — «prefiere chino», «sede en Shanghái», «producto A cuesta 500 CNY».

No importa cuándo ni de qué chat se aprendió.

Vector DB (Pinecone, Weaviate, Milvus) + grafo de conocimiento. Índices HNSW o IVF. El grafo guarda relaciones: usuario A prefiere B, empresa C está en D.

Memoria a largo plazo (Long-Term Memory)

«Quién es el usuario»: perfil, preferencias, conocimiento de dominio estable en todas las sesiones.

PostgreSQL, MongoDB o servicios cloud (AnalyticDB, PolarDB). Recuperación: búsqueda semántica + RAG con filtro por user_id.

Pirámide: trabajo abajo (rápida, efímera); largo plazo arriba (persistente, recuperación más lenta). El agente consulta según la tarea.

Capítulo 3: Pipeline en cinco fases

No basta con guardar el chat. Hace falta extracción, consolidación, almacenamiento, recuperación y olvido.

Fase 1: Extracción (Extraction)

No todo merece memoria. «Hola», «gracias», «un momento» son ruido.

Tarea: identificar información valiosa. LLM para clasificar + reglas de filtrado.

# Pseudocódigo de extracción
def extract_memories(conversation):
    candidates = []
    for message in conversation:
        # Clasificación LLM: ¿merece memoria?
        classification = llm.classify(message, "memory_candidate")
        if classification == "worth_remembering":
            candidates.append(message)
    # Filtrado por reglas: eliminar ruido obvio
    candidates = filter_noise(candidates)
    return candidates

Fase 2: Consolidación (Consolidation)

Puede haber duplicados. «Prefiere chino» en tres chats no necesita tres copias.

Tarea: fusionar, actualizar memorias viejas, construir tríos del grafo.

Ejemplo:

• Antigua: «Prefiere respuestas en chino»
• Nueva: «Prefiere chino conciso»
• Resultado: «Prefiere respuestas concisas en chino»

# Pseudocódigo de consolidación
def consolidate_memories(new_memories, existing_memories):
    for new in new_memories:
        similar = find_similar(new, existing_memories)
        if similar:
            merged = llm.merge(new, similar)
            update_memory(similar.id, merged)
        else:
            add_memory(new)

Fase 3: Almacenamiento (Storage)

Decisiones: formato e índice.

Por tipo: trabajo → KV; episódica → flujo de eventos; semántica → vector DB; largo plazo → relacional.

Índices: HNSW (100K-1M, alto recall, más RAM) vs IVF (1M-100M, eficiente, precisión algo menor). Según Redis, HNSW suele ganar en recall a igual latencia; IVF ahorra memoria a gran escala.

Fase 4: Recuperación (Retrieval)

Cuando el agente necesita memoria, la recupera.

Mejor que solo vectores: recuperación híbrida — vectores + texto completo + filtros por atributos.

Pregunta «¿cuál era la dirección del almacén?»:

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

1. Vector: similitud semántica («dirección almacén», «logística»)
2. Filtro: solo memorias de este usuario
3. Orden temporal: las más recientes primero

# Pseudocódigo de recuperación híbrida
def retrieve_memories(query, user_id):
    vector_results = vector_db.search(query, top_k=20)
    filtered = [m for m in vector_results if m.user_id == user_id]
    sorted_results = sort_by_time(filtered, descending=True)
    return sorted_results[:5]

Fase 5: Olvido (Forgetting)

Crucial. Sin olvido, el almacén crece y el ruido ahoga lo útil.

Decaimiento temporal: importancia baja con el tiempo.

Eliminación por importancia: frecuencia de acceso, feedback, validaciones.

Riesgo: error de una sola vez solidificado — el usuario dice algo falso y el agente lo guarda como hecho. Solución: validación en consolidación o marcado «pendiente de confirmación» para baja confianza.

Capítulo 4: Frameworks — Mem0 vs Zep vs LangMem vs LangChain

Hay frameworks maduros; la pregunta es cuál elegir.

Árbol de decisión

Q1: ¿Necesitas grafo de conocimiento?
    → Sí → Mem0 Pro o Zep
    → No → Q2

Q2: ¿Servicio gestionado?
    → Sí → Mem0 (simple) o MemoClaw (sin API Key)
    → No → Q3

Q3: ¿Usas LangGraph?
    → Sí → LangMem (integración nativa)
    → No → Implementación propia (Checkpointer + vector DB)

Escenarios

Atención al cliente → Mem0

Preferencias, pedidos, quejas. El grafo modela «usuario A compró B», «usuario A reclamó C». Versión gestionada ahorra operaciones; Pro aporta grafo.

Agente de diagnóstico médico → Zep

Relaciones complejas y línea temporal — síntomas, medicación, resultados. Zep destaca en hechos temporales (Temporal Facts).

Agente interno → LangMem

Si ya usas LangGraph, LangMem es lo más directo: Checkpointer y almacenamiento integrados.

Prototipo rápido → MemoClaw

Prueba memoria sin registrar cuentas ni API Keys: store/recall. Para prototipo; producción puede pedir más.

Ecosistema Mem0

Según el blog de Mem0 (inicios 2026), integra 21 frameworks — OpenAI, LangChain, LlamaIndex, CrewAI, AutoGen, etc.

Capítulo 5: Producción — costos y rendimiento

Que el demo funcione no implica producción. Tres frentes: velocidad, costo, seguridad.

Índices: precisión vs escala

FLAT: búsqueda exhaustiva, precisión perfecta, lento. Datos pequeños (miles) o máxima exactitud.

HNSW: grafo jerárquico, alto recall, rápido. 100K-1M vectores; varios GB por millón.

IVF: índice invertido por buckets. 1M-100M; eficiente en RAM, recall algo menor.

Regla: poco dato → FLAT/HNSW; mucho dato → IVF. Alta precisión (salud) → HNSW aunque cueste velocidad.

Latencia: de segundos a milisegundos

Cada capa suma delay. Contexto completo → p95 ~17 s por procesar contexto enorme antes de inferir.

Alibaba Cloud - Opción preferida para desarrolladores, 15 % de descuento exclusivo en Lighthouse

Obtener 15% dto. →Anuncio

Optimización: recuperación rápida antes de inferir. Redis unifica vector, eventos y KV en submilisegundos.

Evita «doble LLM»: recuperar → LLM ordena resultados → LLM responde. Mejor inyectar resultados y una sola inferencia.

Costos: el secreto del factor 10

Tres palancas:

Memoria selectiva: solo lo valioso; filtrar ruido en extracción.

Compresión por resumen: miles de tokens de chat → cientos en resumen.

Olvido inteligente: decaimiento + eliminación por importancia.

Mem0 estima pasar de $1M a $100K/mes en tokens y almacenamiento.

Seguridad: aislamiento

Aislamiento: memorias por usuario; filtro estricto por user_id. Nunca mezclar A y B.

Anti-envenenamiento: entradas maliciosas; baja confianza → «pendiente», no escritura directa en largo plazo.

Desensibilización: teléfonos, IDs antes de guardar; restaurar con control de permisos.

Consistencia: bloqueos + reflexión

Multi-instancia: A actualiza, B lee viejo.

Bloqueo distribuido + versiones: lock al actualizar; lectura de última versión.

Reflexión periódica: LLM revisa contradicciones y obsolescencia. AnalyticDB de Alibaba lo incorpora.

Conclusión

La memoria no es «opcional»; es lo que separa un agente de una API de LLM. Sin memoria, cada chat es un primer encuentro — sin comprensión profunda ni coherencia en tareas largas.

Pero no es instalar y olvidar. ¿Grafo? ¿Servicio gestionado? ¿Stack actual? Con respuestas claras, la elección de framework se simplifica.

Si dudas, empieza con LangMem o Mem0 open source — poca inversión, efecto visible. Domina trabajo y luego expande a episódica y largo plazo.