Letta (ex-MemGPT) : la plateforme open source pour construire des agents IA avec mémoire persistante

Letta (ex-MemGPT) : la plateforme open source pour construire des agents IA avec mémoire persistante

L’un des angles morts des agents IA en production, c’est la mémoire. Un LLM, aussi puissant soit-il, oublie tout dès que la fenêtre de contexte se referme. Les frameworks comme LangGraph ou CrewAI orchestrent des étapes, mais laissent au développeur la charge de gérer la persistance, le résumé, la hiérarchisation des souvenirs. Letta, anciennement MemGPT, issu d’une publication de recherche de l’UC Berkeley, prend le problème par l’autre bout : c’est une plateforme d’agents où la mémoire est un citoyen de première classe, traitée comme un système d’exploitation gèrerait la hiérarchie RAM / disque.

L’héritage MemGPT : la mémoire vue comme un OS

L’article fondateur proposait une analogie simple : la fenêtre de contexte d’un LLM ressemble à de la RAM : rapide, coûteuse, limitée. Le reste des connaissances d’un agent doit vivre sur un « disque » externe que le LLM sait paginer à la demande. Letta industrialise cette idée avec plusieurs couches :

• Core memory (blocs persona et human) : toujours présente dans le prompt, modifiable par l’agent lui-même via des outils.
• Recall memory : historique complet des échanges, consultable via recherche.
• Archival memory : mémoire à long terme de type base vectorielle, que l’agent interroge quand il a besoin de se souvenir.
• Tool-driven updates : l’agent décide explicitement quand mettre à jour sa mémoire, en appelant des fonctions dédiées.

Cette architecture change une chose essentielle : l’agent sait qu’il a une mémoire, il apprend à s’en servir, et son comportement s’améliore au fil des interactions sans ré-entraînement.

Ce que Letta propose concrètement

• Un serveur d’agents auto-hébergeable (Docker Compose fourni, y compris une variante avec vLLM intégré pour tourner 100% en local).
• Une API REST pour créer des agents, leur envoyer des messages, inspecter et modifier leur mémoire — parfaite pour intégrer dans ses applications existantes.
• Des SDK officiels en Python et TypeScript.
• Une interface web (Letta ADE) pour visualiser les agents, leurs blocs de mémoire, leurs outils et leurs traces de raisonnement, un atout précieux pour le débogage.
• Un modèle agnostique : OpenAI, Anthropic, ou tout endpoint compatible OpenAI (Ollama, vLLM, LiteLLM).
• La licence Apache 2.0, sans ambiguïté sur l’usage commercial et la redistribution.

Exemple d’agent avec mémoire structurée

En Python, la création d’un agent tient en quelques lignes :

from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

agent = client.agents.create(
    model="ollama/llama3.1:70b",
    embedding="ollama/nomic-embed-text",
    memory_blocks=[
        {"label": "persona",
         "value": "Je suis un assistant interne pour l'équipe projet."},
        {"label": "human",
         "value": "Nom : Louis. Rôle : direction de projet chez Askem."}
    ],
    tools=["web_search", "archival_memory_insert", "archival_memory_search"]
)

client.agents.messages.create(
    agent_id=agent.id,
    input="Rappelle-toi que notre POC RAG est basé sur pgvector et Qdrant."
)

Ce qui se passe ensuite est différent d’un simple appel LLM : l’agent va, de sa propre initiative, écrire l’information pertinente dans sa mémoire d’archive. Lors d’une future conversation, même des semaines plus tard, il recherchera ce souvenir au moment opportun.

Letta face à Mem0, LangGraph, CrewAI

Le paysage peut prêter à confusion, mais les outils ne jouent pas dans la même catégorie :

• LangGraph et CrewAI sont des frameworks d’orchestration : le développeur écrit la machine à états, les rôles, et ajoute de la mémoire à la main si besoin.
• Mem0 est une brique mémoire à greffer sur un framework existant — utile si l’on a déjà une stack et qu’on veut ajouter du souvenir persistant.
• Letta est une plateforme complète : un serveur, une API, des agents persistants par défaut. On ne reconstruit pas la boucle mémoire soi-même.

Le choix dépend donc du besoin : si l’agent est un composant ponctuel dans un workflow plus large (par exemple un nœud n8n), Mem0 greffé sur LangGraph suffira. Si l’objectif est de faire vivre un ou plusieurs assistants qui capitalisent dans le temps : support interne, tuteur pédagogique, compagnon de projet, Letta fait gagner des semaines de plomberie.

Déploiement type auto-hébergé

Le dépôt fournit un compose.yaml prêt à l’emploi avec PostgreSQL (pour la persistance des agents et la mémoire), le serveur Letta, et optionnellement vLLM pour l’inférence locale. Pour une infrastructure existante, on peut brancher un Ollama ou un vLLM déjà en place via la variable d’environnement OLLAMA_BASE_URL.

Les points de vigilance classiques restent valables : placer le serveur derrière un reverse proxy avec TLS, protéger l’API par un mécanisme d’authentification (les jetons Letta à défaut d’un SSO), sauvegarder la base PostgreSQL qui contient toute la mémoire accumulée par les agents. Prévoir aussi de tracer les appels d’outils : un agent qui réécrit sa mémoire doit être auditable.

Limites à connaître avant de se lancer

• Les performances de la boucle mémoire dépendent fortement de la qualité du modèle à manipuler des appels d’outils. En local, il faut viser au minimum Llama 3.1 70B ou un équivalent Qwen pour obtenir un comportement stable.
• La courbe d’apprentissage est réelle : comprendre la différence entre core / recall / archival memory et savoir designer les blocs demande un peu de pratique.
• L’écosystème évolue vite : sur des versions antérieures à 0.5, l’API a connu des ruptures significatives. Pin les versions en production.
• Pour les cas très simples (une question, une réponse), Letta est sur-dimensionné. Son intérêt commence à partir du moment où l’agent doit se souvenir au-delà d’une session.

Position stratégique dans une stack IA open source

Letta complète plus qu’il ne concurrence les briques déjà évoquées sur ce site. Ollama ou vLLM fournissent l’inférence, Qdrant ou pgvector servent de substrat vectoriel pour la mémoire d’archive, Langfuse trace ce que fait l’agent, n8n ou un front maison expose l’agent aux utilisateurs. Letta occupe la place d’un agent runtime : un serveur dédié aux agents persistants, au même niveau de maturité qu’un serveur applicatif traditionnel.

L’intérêt profond de Letta n’est pas technique, il est stratégique : en rendant la mémoire native, il ouvre la porte à des agents qui ne repartent pas de zéro à chaque conversation. C’est exactement la brique qui manque pour que l’IA passe du chatbot jetable à l’assistant qui connaît vraiment son contexte.