Letta — OS mémoire pour Agent (anciennement MemGPT)
Letta est un framework d'Agent avec état, construit autour d'une mémoire paginée de style MemGPT. Les Agent lisent et écrivent explicitement dans leur propre mémoire via des appels de fonctions — le modèle mémoire le plus transparent en production.
Why Letta
Letta (l'entreprise derrière l'article open source MemGPT) traite la mémoire comme une abstraction de type système d'exploitation. L'Agent dispose d'une petite « working memory » qui reste dans le contexte LLM, plus une « archival memory » plus large qu'il peut paginer entrant/sortant via des appels de fonctions explicites (memory_search, memory_insert, memory_replace).
Ce que cela apporte : l'auditabilité. Chaque changement de mémoire est un appel d'outil dans la trace, vous voyez donc exactement ce que l'Agent a choisi de retenir, d'oublier ou de réécrire. À comparer aux résumés boîte noire ou à l'extraction automatique — quand quelque chose tourne mal, vous pouvez pointer du doigt l'appel d'outil exact qui en est responsable.
Ce que cela coûte : plus de tours LLM. L'Agent fait des appels supplémentaires pour gérer sa propre mémoire. Pour des cas limités par le débit (des centaines d'utilisateurs concurrents sur modèles bon marché), le surcoût compte. Pour des Agent autonomes long terme où la session d'un utilisateur s'étale sur des jours ou semaines, la transparence en vaut la peine.
Quick Start — Letta Server + Python Client
Letta tourne en serveur stateful (FastAPI + Postgres). Les Agent persistent au-delà des redémarrages ; la mémoire est durable. Dans la trace vous verrez des appels d'outils comme core_memory_append — c'est l'Agent qui décide de mettre à jour sa propre mémoire. Pas de passe d'extraction cachée.
# 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 traceFonctionnalités clés
Blocs core + archival memory
Core memory = in-context (toujours visible pour l'Agent, limité à ~2 Ko par bloc). Archival = hors contexte, interrogeable via appels de fonction. Cette séparation est l'intuition clé de MemGPT.
Mises à jour mémoire auto-dirigées
L'Agent choisit quoi retenir. core_memory_append, core_memory_replace, archival_memory_insert et archival_memory_search sont des outils exposés au LLM — pas des processus automatiques en arrière-plan.
Serveur Agent stateful
Les Agent persistent dans Postgres. Tuez le process, redémarrez, reprenez exactement où vous en étiez — y compris tous les blocs mémoire, l'état de conversation et les appels d'outils en vol.
Multi-Agent avec mémoire partagée
Plusieurs Agent peuvent partager des blocs mémoire. Idéal pour les patterns manager/worker où un superviseur lit le même contexte que ses subordonnés tout en conservant son propre bloc persona.
ADE (Agent Development Environment)
L'UI web de Letta permet d'inspecter les blocs mémoire d'un Agent en temps réel, de suivre les appels d'outils en direct et d'éditer la mémoire directement lors du debug.
API compatible OpenAI
Les Agent Letta peuvent être appelés via un endpoint chat completions style OpenAI, en faisant des remplaçants drop-in pour des appels OpenAI sans état dans les apps existantes.
Comparaison
| Memory Control | State Persistence | Overhead | Best For | |
|---|---|---|---|---|
| Lettacelui-ci | 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 |
Cas d'usage
01. Agent de recherche autonomes
Agent long terme qui ingèrent des articles, conservent des hypothèses en core memory et archivent les sources. Le modèle mémoire explicite est essentiel quand un Agent tourne pendant des heures — il faut pouvoir auditer ce qu'il a « appris ».
02. Copilotes d'assistant personnel
Assistants qui se construisent un modèle de leur utilisateur sur plusieurs semaines. L'état Postgres persistant de Letta signifie que les redémarrages, migrations et changements d'infra ne lessivent pas la relation.
03. Supervision multi-Agent
L'Agent superviseur lit des blocs mémoire partagés écrits par des Agent worker. Le modèle à blocs partagés est plus propre que le passage de messages pour les scénarios de coordination.
Tarification et licence
Letta OSS : Apache 2.0 — self-host via docker-compose avec Postgres. Pas de coût de licence. Vous payez vos propres clés d'API LLM et embedding.
Letta Cloud : service hébergé avec l'ADE et Postgres managé. Tarification à l'usage par Agent actif. Voir letta.com/pricing.
Modèle de coût : Letta ajoute un surcoût d'appels d'outils. Prévoyez ~2-3x le coût en Token d'une API chat sans état pour un travail équivalent, compensé par le fait de ne pas avoir besoin d'un pipeline séparé de bourrage de contexte.
Assets associés sur 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.
Questions fréquentes
Letta vs MemGPT — quelle est la relation ?+
MemGPT est l'article de recherche 2023 (UC Berkeley) qui a introduit la mémoire Agent paginée. Letta est l'entreprise et le framework open source production-grade construit sur ces idées. Si vous avez regardé memgpt.ai en 2023 et que vous vous demandez où est passé le projet — c'est Letta que vous cherchez maintenant.
Dois-je self-host Postgres ?+
Pour le self-host, oui — Letta a besoin d'une instance Postgres. docker-compose s'en occupe en local ; en production, utilisez RDS/Supabase/Neon. Si vous ne voulez pas gérer Postgres, Letta Cloud s'en occupe pour vous.
Les Agent Letta peuvent-ils appeler des APIs externes ?+
Oui. Les tools sont de simples fonctions Python. Enregistrez-les via client.tools.create(source_code=...) et l'Agent peut appeler vos outils personnalisés à côté de ses outils mémoire. Patterns courants : recherche web, lookup base de données, posts Slack.
Quels LLMs fonctionnent avec Letta ?+
OpenAI, Anthropic Claude, Google Gemini, Groq, Ollama et tout endpoint compatible OpenAI (vLLM et LM Studio inclus). Configurez par Agent via le champ model — vous pouvez mixer (par ex. modèle bon marché pour les ops mémoire, Claude pour la réponse principale).
Quand Letta est-il excessif ?+
Chatbots simples avec sessions de 10 tours, ou systèmes RAG où la connaissance vit dans les documents pas dans l'historique de conversation. Dans ces cas, mem0 ou Zep vous emmènent à 80 % du chemin avec 30 % de l'infrastructure.