La pieza busca ayudar a elegir stack o ruta tecnica con menos ruido.
Util para comparar proveedores, agentes, prompts o setups de inferencia.
Se revisa cuando cambian capacidades, precio, APIs o tradeoffs de implementacion.
Se combinan documentacion de producto, release notes, tradeoffs tecnicos y evaluacion de desk.
El problema central: Los LLMs tienen memoria de pez. Cada conversación comienza desde cero. Para agentes que aprenden del uso, esto es inaceptable. En 2026 tenemos soluciones maduras — pero elegir la correcta importa más de lo que parece.
Por qué la memoria importa en agentes 2026
Un agente sin memoria es un asistente que olvida tu nombre cada vez que entras. Para tareas simples, suficiente. Para flujos de trabajo donde el contexto acumulado es valioso —historial de decisiones, preferencias del usuario, conocimiento aprendido de documentos— necesitas arquitectura de memoria explícita.
En 2026, el ecosistema ha madurado considerablemente. Ya no necesitas construir tu propio sistema desde cero.
Los cuatro tipos de memoria para agentes
Antes de elegir herramientas, entiende qué tipo de memoria necesitas:
Memoria episódica: Recuerda conversaciones y eventos pasados. “La semana pasada me dijiste que preferías TypeScript sobre Python.”
Memoria semántica: Conocimiento factual almacenado. Documentos, PDFs, wikis que el agente puede consultar.
Memoria procedimental: Cómo hacer cosas. SOP aprendidos, flujos de decisión, patrones efectivos.
Memoria de trabajo: Estado de la tarea actual. Lo que el modelo tiene en contexto en este momento.
Las mejores soluciones de 2026
Mem0 — El estándar de facto para memoria episódica
Mem0 ha emergido en 2026 como la solución más adoptada para dar memoria long-term a agentes. Funciona extrayendo automáticamente hechos relevantes de cada conversación y almacenándolos en una base vectorial.
from mem0 import Memory
m = Memory()
# Después de cada turno de conversación:
result = m.add(
messages=[{"role": "user", "content": "Prefiero respuestas en bullet points."},
{"role": "assistant", "content": "Entendido, usaré formato de lista."}],
user_id="usuario-123"
)
# En la próxima sesión, el agente recupera contexto:
memories = m.search(query="preferencias de formato", user_id="usuario-123")
# → "El usuario prefiere respuestas en bullet points"Ventajas: API simple, extracción automática, filtrado por relevancia. Limitaciones: Las memorias extraídas pueden perder matices. No ideal para documentos técnicos extensos.
Precio: Plan gratuito (1K memorias), $49/mes para uso profesional.
Zep — Memoria estructurada para aplicaciones empresariales
Zep va más allá de Mem0 añadiendo grafos de conocimiento, análisis de sentimiento y resúmenes automáticos de sesión. Más potente, más complejo.
from zep_cloud.client import Zep
client = Zep(api_key="...")
# Añadir sesión completa con metadata
session = client.memory.add_session(
session_id="sesion-2026-03-06",
user_id="usuario-123",
metadata={"context": "análisis financiero", "project": "Q1-report"}
)
# Búsqueda semántica con filtros de metadata
results = client.memory.search_sessions(
text="decisiones sobre inversión en renta fija",
user_id="usuario-123",
metadata_filter={"project": "Q1-report"}
)Cuándo elegir Zep: Aplicaciones empresariales donde necesitas auditabilidad, separación por proyecto y análisis del historial de conversaciones.
Base vectorial directa (Qdrant/Chroma) — Máximo control
Para equipos con capacidad técnica que quieren control total sobre qué se almacena y cómo se recupera:
from qdrant_client import QdrantClient
from openai import OpenAI
qdrant = QdrantClient(url="http://localhost:6333")
openai = OpenAI()
def save_memory(text: str, user_id: str, memory_type: str):
embedding = openai.embeddings.create(
input=text, model="text-embedding-3-small"
).data[0].embedding
qdrant.upsert(
collection_name="agent_memory",
points=[{
"id": hash(text + user_id),
"vector": embedding,
"payload": {
"text": text,
"user_id": user_id,
"type": memory_type,
"timestamp": datetime.now().isoformat()
}
}]
)
def retrieve_memory(query: str, user_id: str, limit: int = 5):
query_embedding = openai.embeddings.create(
input=query, model="text-embedding-3-small"
).data[0].embedding
return qdrant.search(
collection_name="agent_memory",
query_vector=query_embedding,
query_filter={"must": [{"key": "user_id", "match": {"value": user_id}}]},
limit=limit
)Ventajas: Control total, sin coste de servicio externo, customizable. Limitaciones: Debes gestionar la extracción de hechos, la limpieza y la gestión del ciclo de vida.
Memex (paper de investigación) — La frontera académica
El paper Memex(RL): Scaling Long-Horizon LLM Agents via Indexed Experience Memory publicado este mes propone una arquitectura donde los agentes indexan su propia experiencia de ejecución de tareas y la recuperan en contextos similares futuros. Aún en investigación, pero implementaciones open-source están apareciendo.
Comparativa directa
| Solución | Tipo | Precio | Complejidad | Mejor para |
|---|---|---|---|---|
| Mem0 | Servicio gestionado | Freemium | Baja | Apps de chat con usuarios |
| Zep | Servicio gestionado | $49/mes+ | Media | Empresarial con auditoría |
| Qdrant + custom | Self-hosted | Infraestructura | Alta | Máximo control |
| Redis + embeddings | Self-hosted | Infraestructura | Media | Estado estructurado |
| LangGraph + checkpointer | Framework | Libre | Media | Agentes con estado de tarea |
Patrones de implementación recomendados
Patrón 1: Memoria en capas
No uses solo un tipo de memoria. Combínalos:
class AgentMemory:
def __init__(self):
self.working = {} # Dict en memoria RAM — contexto actual
self.episodic = Mem0() # Conversaciones pasadas
self.semantic = QdrantDB() # Documentos y conocimiento
async def get_context(self, query: str, user_id: str) -> str:
# Recupera de las tres capas y combina
episodes = self.episodic.search(query, user_id, limit=3)
docs = self.semantic.search(query, limit=5)
state = self.working.get(user_id, {})
return format_context(episodes, docs, state)Patrón 2: Compresión progresiva
Las conversaciones largas se comprimen en resúmenes estructurados en lugar de descartarse:
# Después de cada 20 turnos de conversación
if len(conversation) > 20:
summary = await claude.messages.create(
model="claude-haiku-4-5-20251001",
max_tokens=500,
messages=[{"role": "user",
"content": f"Resume los hechos clave de esta conversación en JSON estructurado: {conversation}"}]
)
save_to_long_term_memory(summary, user_id)
conversation = conversation[-5:] # Mantén solo los últimos 5 turnos en contextoEl problema de la degradación de memoria
Un aspecto poco discutido: las memorias acumuladas sin gestión se degradan en utilidad con el tiempo. Una memoria de “el usuario prefiere Python” puede quedar obsoleta si el usuario migra a TypeScript. Necesitas:
- TTL (Time-to-Live): Las memorias “de preferencia” expiran y se revalidan
- Contradicción handling: Si el usuario dice algo que contradice una memoria, actualiza
- Relevance decay: Memorias más antiguas tienen menor peso en la recuperación
Mem0 en su versión 2.0 (febrero 2026) añade gestión automática de contradicciones. Para implementaciones custom, debes construirlo tú.
Conclusión: qué elegir
Para proyectos nuevos y equipo pequeño: Empieza con Mem0. API simple, funciona bien para el 80% de casos de uso. Puedes migrar cuando crezcas.
Para producción empresarial: Zep si necesitas auditabilidad y separación por proyecto. Qdrant self-hosted si tienes data sensible que no puede salir de tu infraestructura.
Para agentes de larga duración y tareas complejas: LangGraph con PostgreSQL checkpointer para estado de tarea, Qdrant para semántica, Mem0 para episódica. El stack completo.
La memoria no es una feature más — es la diferencia entre un asistente que se siente genérico y uno que genuinamente conoce tu forma de trabajar.
Publicado: marzo 2026. Código verificado con Mem0 2.0, LangGraph 0.2, Qdrant 1.8 y Python 3.12.