Letta — OS de memoria para Agent (antes MemGPT)
Letta es un framework de Agent con estado, construido en torno a una memoria paginada estilo MemGPT. Los Agent leen y escriben explícitamente en su propia memoria mediante llamadas a funciones — el modelo de memoria más transparente en producción.
Why Letta
Letta (la empresa detrás del paper open source MemGPT) trata la memoria como una abstracción de sistema operativo. El Agent tiene una pequeña "working memory" que vive en el contexto del LLM, más una "archival memory" más grande que puede paginar dentro/fuera mediante llamadas de función explícitas (memory_search, memory_insert, memory_replace).
Lo que esto te da: auditabilidad. Cada cambio de memoria es una llamada a herramienta en la traza, así que ves exactamente qué eligió el Agent recordar, olvidar o reescribir. Compáralo con el resumen tipo caja negra o la extracción automática — cuando algo sale mal, puedes señalar la llamada exacta que lo hizo.
Lo que te cuesta: más turnos de LLM. El Agent hace llamadas extra para gestionar su propia memoria. Para casos limitados por throughput (cientos de usuarios concurrentes en modelos baratos), el overhead importa. Para Agent autónomos de larga duración donde la sesión de un usuario abarca días o semanas, la transparencia merece la pena.
Quick Start — Letta Server + Python Client
Letta corre como un servidor stateful (FastAPI + Postgres). Los Agent persisten entre reinicios; la memoria es duradera. En la traza verás llamadas a herramientas como core_memory_append — es el Agent decidiendo actualizar su propia memoria. Sin pasada de extracción oculta.
# pip install letta-client
# docker run -p 8283:8283 letta/letta:latest
from letta_client import Letta
client = Letta(base_url="http://localhost:8283")
agent = client.agents.create(
name="assistant",
memory_blocks=[
{"label": "human", "value": "Name: William. Role: founder."},
{"label": "persona", "value": "You are a terse, senior engineer."},
],
model="openai/gpt-4o-mini",
embedding="openai/text-embedding-3-small",
)
resp = client.agents.messages.create(
agent_id=agent.id,
messages=[{"role": "user", "content": "I'm using Nuxt for my new project."}],
)
for m in resp.messages:
print(m.message_type, getattr(m, "content", None))
# Agent will autonomously call core_memory_append / archival_memory_insert
# so "Nuxt" ends up in either working or archival memory — visible in the traceCaracterísticas clave
Bloques core + archival memory
Core memory = en contexto (siempre visible para el Agent, limitado a ~2 KB por bloque). Archival = fuera de contexto, consultable vía llamadas de función. Esa separación es la idea clave de MemGPT.
Actualizaciones de memoria auto-dirigidas
El Agent elige qué recordar. core_memory_append, core_memory_replace, archival_memory_insert y archival_memory_search son herramientas expuestas al LLM — no procesos automáticos en segundo plano.
Servidor de Agent stateful
Los Agent persisten en Postgres. Mata el proceso, reinicia, retoma exactamente donde lo dejaste — incluidos todos los bloques de memoria, estado de conversación y llamadas en vuelo.
Multi-Agent con memoria compartida
Varios Agent pueden compartir bloques de memoria. Útil para patrones manager/worker donde un supervisor lee el mismo contexto que sus subordinados pero mantiene su propio bloque persona.
ADE (Agent Development Environment)
La UI web de Letta te permite inspeccionar los bloques de memoria de un Agent en tiempo real, ver llamadas a herramientas según ocurren y editar la memoria directamente al depurar.
API compatible con OpenAI
Los Agent de Letta pueden invocarse vía un endpoint chat completions estilo OpenAI, lo que los convierte en reemplazos drop-in para llamadas OpenAI sin estado en apps existentes.
Comparación
| Memory Control | State Persistence | Overhead | Best For | |
|---|---|---|---|---|
| Lettaesta | Agent-directed (explicit tools) | Postgres-backed, durable | High (extra turns) | Long-running autonomous agents |
| mem0 | Background extraction | Vector DB of your choice | Low (async pipeline) | Chatbot personalization |
| Zep | Service-managed summarization | Postgres-backed service | Low-medium | Session-based apps |
| MemGPT (research) | Same as Letta (its ancestor) | Research prototype | High | Research, prototyping |
Casos de uso
01. Agent de investigación autónomos
Agent de larga duración que ingieren papers, mantienen hipótesis en core memory y archivan las fuentes. El modelo de memoria explícito es esencial cuando un Agent corre durante horas — necesitas auditar lo que "aprendió".
02. Copilotos de asistente personal
Asistentes que construyen un modelo de su usuario a lo largo de semanas. El estado Postgres persistente de Letta hace que reinicios, migraciones y cambios de infra no borren la relación.
03. Supervisión multi-Agent
El Agent supervisor lee bloques de memoria compartidos escritos por Agent worker. El modelo de bloques compartidos es más limpio que el paso de mensajes para escenarios de coordinación.
Precios y licencia
Letta OSS: Apache 2.0 — self-host vía docker-compose con Postgres. Sin coste de licencia. Pagas tus propias claves de API de LLM y embedding.
Letta Cloud: servicio hospedado con la ADE y Postgres gestionado. Tarificación por uso por Agent activo. Consulta letta.com/pricing.
Modelo de coste: Letta añade overhead por llamadas a herramientas. Presupuesta ~2-3x el coste en Token de una API de chat sin estado para trabajo equivalente, compensado por no necesitar un pipeline aparte de relleno de contexto.
Activos relacionados en TokRepo
Letta — AI Agent Long-Term Memory Framework
Build AI agents with persistent memory using MemGPT architecture. Letta manages context windows automatically with tiered memory for stateful LLM applications.
Letta — Stateful AI Agents with Memory
Letta builds stateful AI agents that learn and self-improve with advanced memory. 21.8K+ stars. CLI, Python/TS SDKs, skills, subagents. Apache 2.0.
Preguntas frecuentes
Letta vs MemGPT — ¿cuál es la relación?+
MemGPT es el paper de investigación de 2023 (UC Berkeley) que introdujo la memoria Agent paginada. Letta es la empresa y el framework open source production-grade construido sobre esas ideas. Si miraste memgpt.ai en 2023 y te preguntas dónde se fue el proyecto — ahora es Letta lo que buscas.
¿Tengo que self-host Postgres?+
Para self-host, sí — Letta necesita una instancia de Postgres. docker-compose lo maneja en local; en producción usa RDS/Supabase/Neon. Si no quieres gestionar Postgres, Letta Cloud lo hace por ti.
¿Los Agent de Letta pueden llamar APIs externas?+
Sí. Las tools son funciones Python normales. Regístralas vía client.tools.create(source_code=...) y el Agent puede llamar tus herramientas personalizadas junto con sus herramientas de memoria. Patrones habituales: búsqueda web, lookups en base de datos, posts en Slack.
¿Qué LLMs funcionan con Letta?+
OpenAI, Anthropic Claude, Google Gemini, Groq, Ollama y cualquier endpoint compatible con OpenAI (incluidos vLLM y LM Studio). Configura por Agent vía el campo model — puedes mezclar (p. ej., modelo barato para operaciones de memoria, Claude para la respuesta principal).
¿Cuándo Letta es excesivo?+
Chatbots simples con sesiones de 10 turnos, o sistemas RAG donde el conocimiento vive en documentos y no en el historial de conversación. En esos casos, mem0 o Zep te llevan al 80 % con el 30 % de la infraestructura.