Guide

Letta, un agent qui gère sa propre mémoire

Letta est un runtime d'agents dont la mémoire est éditée par l'agent lui-même : blocs de mémoire, pagination du contexte, traitement en arrière-plan et limites.

L'équipe CodeWorlds14 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article11

Letta est un runtime pour agents où la mémoire n'est pas une couche greffée sur le côté mais quelque chose que l'agent édite lui-même en appelant des outils. Il est issu de la recherche sur le projet MemGPT et a gardé son idée centrale : traiter la fenêtre de contexte comme une mémoire de travail qu'il faut gérer.

Il faut dire tout de suite une chose, car elle change le tableau. Le serveur Python, c'est-à-dire le dépôt letta-ai/letta avec le paquet letta sur PyPI, a été décrit par ses auteurs le 3 juillet 2026 comme obsolète et maintenu en mode maintenance seulement. Ce paquet a publié sa dernière version 0.16.8 le 14 mai 2026 et exige Python entre 3.11 et 3.13. Le développement s'est déplacé vers Letta Code, le paquet @letta-ai/letta-code installé depuis npm, et vers le Letta Agent SDK, tandis que l'auto-hébergement passe désormais par l'App Server. Les deux dépôts portent la licence Apache 2.0.

L'idée décrite ci-dessous survit à ce changement, donc elle reste utile à comprendre. Ce qui a changé, c'est ce que tu exécutes : au lieu d'un serveur d'API Python, tu obtiens un harnais d'agent en Node.js avec les mêmes blocs de mémoire et le même traitement en arrière-plan.

La différence clé avec les bibliothèques de mémoire

Il vaut mieux la nommer d'emblée, car elle décide si la suite vaut la peine d'être lue.

Une bibliothèque de mémoire se greffe sur un agent que tu as déjà. Tu appelles sa fonction avant de répondre, tu reçois des faits, tu les colles dans le prompt. Ton code pilote toujours le flux.

Letta inverse cela. L'agent est une entité côté serveur, avec sa propre identité, son propre état et ses propres décisions sur le moment où écrire quelque chose en mémoire et celui où l'utiliser. Tu converses avec cet agent plutôt que de construire une boucle où le modèle n'est qu'une étape.

La conséquence est sérieuse : tu n'ajoutes pas Letta à ton application, tu construis ton agent à l'intérieur de Letta. C'est un engagement bien plus grand que d'ajouter une dépendance, et c'est précisément pourquoi comparer cela à Mem0 ou Zep comme à des options équivalentes induit en erreur. Ils résolvent le même problème à des niveaux entièrement différents.

Les blocs de mémoire

L'élément de base est un bloc de mémoire : un morceau de texte nommé qui se trouve en permanence dans le contexte de l'agent et que l'agent peut modifier.

Deux sont conventionnels. Un bloc décrivant la personne rassemble ce que l'agent a appris sur elle. Un bloc décrivant l'agent lui-même contient son rôle, son style et ses contraintes. Au-delà, tu peux ajouter les tiens, par exemple un bloc avec l'état actuel du dossier sur lequel l'agent travaille.

L'agent dispose d'outils pour ajouter au contenu des blocs et le remplacer. C'est le cœur de l'approche : la mémoire change à la suite d'une décision du modèle plutôt que d'un appel de ton code.

L'avantage est réel. Un agent qui a entendu que la personne a changé d'emploi peut corriger lui-même le bloc concerné plutôt que d'attendre qu'une couche externe détecte ce changement. Aucune règle décrivant ce qui mérite d'être retenu n'est nécessaire.

L'inconvénient est tout aussi réel et il faut le connaître. Un modèle qui gère la mémoire le fait de façon imparfaite : il enregistre des choses sans importance, en perd d'importantes et écrase parfois quelque chose qui était nécessaire. Les blocs ont une limite de taille, donc la place finit par manquer, et une décision s'ensuit sur ce qui disparaît. Sur un travail plus long, il vaut la peine d'inspecter le contenu des blocs, car c'est le seul moyen de savoir si la mémoire fonctionne réellement.

La pagination du contexte

La deuxième idée reprise de la recherche concerne ce qui se passe quand une conversation ne tient pas dans la fenêtre du modèle.

L'analogie est directement système. Ce qui se trouve dans le contexte ressemble à la mémoire de travail : rapide et limitée. Le reste se trouve dans un stockage externe que l'agent atteint par un appel d'outil, exactement comme un système va chercher sur un disque.

L'agent dispose donc d'outils pour rechercher dans l'historique de sa propre conversation et dans son archive. Quand il a besoin de quelque chose qui n'est pas dans le contexte, il appelle la recherche et ramène un fragment.

Ce mécanisme résout un vrai problème tout en introduisant un coût facile à manquer. Chaque accès à l'archive est un tour supplémentaire avec le modèle, donc une réponse qui demande deux appels de ce type prend trois fois plus de temps qu'une réponse sans eux. Avec un assistant qui tient une conversation en direct, cela se remarque.

Sache aussi que le modèle n'ira pas toujours chercher dans l'archive quand il le faudrait. S'il décide qu'il en sait assez, il répondra à partir de ce qu'il a dans le contexte, et cette réponse sera assurée et incomplète. C'est la même classe de problème que pour tout mécanisme reposant sur le jugement d'un modèle.

Le traitement pendant les temps morts

La troisième idée déplace le rangement de la mémoire hors du moment de la réponse.

L'idée est qu'un agent séparé travaille en arrière-plan : il passe en revue ce qui s'est passé, résume, range les blocs et tire des conclusions. Cela se fait quand personne n'attend de réponse.

Le gain est double. La réponse de l'utilisateur ne porte aucun travail de mémoire, donc elle arrive plus vite. Et le rangement peut être plus approfondi, car il n'y a pas de pression de temps et un modèle plus puissant peut lui être affecté.

Le prix est un coût en tokens pour un travail que personne n'a commandé. Un agent en arrière-plan les consomme que quelqu'un lui parle ou non, donc sur de nombreux agents cette ligne grossit d'une façon que le nombre de conversations ne permet pas de prévoir. C'est une chose à mesurer avant de lancer quoi que ce soit à grande échelle.

Les outils et ce qu'un agent peut réellement faire

La mémoire est l'élément le plus bruyant ici, alors qu'un agent qui ne gère que sa propre mémoire ne sert à personne. Le vrai travail commence avec des outils qui atteignent tes systèmes.

Tu définis un outil comme une fonction Python ordinaire avec une description, et l'agent décide quand l'appeler. Le mécanisme est le même que pour la mémoire, sauf que les effets sortent de l'agent : une requête de base de données, un message envoyé, un enregistrement modifié.

Voici quelque chose à réfléchir plus tôt que dans une application ordinaire. L'agent détient un état durable et agit aussi quand personne ne regarde, donc les permissions des outils doivent être contraintes quelle que soit la façon dont le modèle a lu une conversation. Un outil qui supprime des données ou déplace de l'argent exige une confirmation côté système plutôt qu'une confiance dans le jugement du modèle.

La deuxième chose concerne les descriptions. Le modèle ne voit que le nom, la description et le schéma des arguments, donc une phrase qui dit clairement quand appeler l'outil vaut mieux qu'une phrase qui dit seulement ce qu'il fait. Avec un agent de longue durée, cette différence se cumule, car un mauvais choix d'outil entre dans l'historique et façonne les décisions suivantes.

La troisième est la gestion des erreurs. Un outil qui lève une exception renvoie un message à l'agent, et l'agent décide de la suite à partir de lui. Un message qui décrit ce qui s'est mal passé et ce qu'on pourrait faire à la place transforme un échec en étape intermédiaire. Un message technique mène généralement à répéter la même tentative.

Plusieurs agents et la répartition du travail

Puisqu'un agent est une entité durable, la question de plusieurs agents à la fois se pose naturellement, et deux agencements méritent d'être distingués.

Le premier est un agent par utilisateur. Chaque personne obtient le sien, avec sa propre mémoire sur elle-même. Cet agencement est évident pour des assistants et c'est aussi celui qui croît linéairement avec le nombre d'utilisateurs, donc un plan de suppression et d'archivage devrait exister avant le premier déploiement.

Le second est celui des agents spécialisés qui partagent certains blocs de mémoire. Un bloc partagé contenant des règles de l'entreprise ou l'état actuel d'un projet, visible par plusieurs agents, leur permet de travailler à partir des mêmes connaissances sans les dupliquer. Une modification faite par l'un est immédiatement visible pour les autres.

Ce second agencement est tentant et demande de la prudence. Un état partagé modifié par plusieurs entités indépendantes est une source classique de problèmes, familière en dehors de ce domaine. Si deux agents peuvent écraser le même bloc en même temps, tôt ou tard ils le feront.

Le conseil pratique : garde les blocs partagés en lecture seule, et laisse l'écriture à un seul agent ou à ton propre code. Le partage de connaissances devient alors un avantage plutôt qu'un danger.

Letta face aux alternatives

OptionCe que c'estQui gère la mémoireÀ choisir quand
LettaUn runtime d'agentsL'agent lui-même, avec des outilsTu construis un agent de zéro
ZepUne couche de mémoireUn moteur de graphe externeLes faits changent avec le temps
Mem0Une couche de mémoireUne couche externePréférences simples de l'utilisateur
Ta propre implémentationDu code dans le projetToiTu sais exactement quoi retenir

La première ligne diffère des autres par la portée plutôt que par la qualité. La choisir signifie choisir comment construire un agent, pas seulement comment conserver la mémoire. Cela convient à un nouveau projet et pose problème quand on ajoute de la mémoire à quelque chose qui tourne déjà.

La dernière ligne mérite une considération honnête. Pour un assistant qui doit retenir trois choses sur un utilisateur, une table de base de données à trois colonnes bat toutes les options ci-dessus. Ces outils commencent à être rentables là où tu ne sais pas à l'avance ce qui vaudra la peine d'être retenu.

Note aussi que le traitement en arrière-plan et la pagination du contexte peuvent être reproduits par toi-même. Ce ne sont pas des mécanismes fermés mais des idées, et une implémentation plus simple suffit souvent pour un projet donné.

L'exécuter et le déployer

Bash
npm install -g @letta-ai/letta-code
letta server --backend local --listen ws://127.0.0.1:4500

C'est la voie actuelle. Tu installes l'outil en ligne de commande depuis npm, ce qui demande Node.js 22.19 ou plus récent, puis tu démarres l'App Server, un service avec lequel ton application dialogue par WebSocket, le plus commodément via le Letta Agent SDK. L'exécuter toi-même est entièrement possible grâce à la licence Apache 2.0, et le cloud de l'éditeur reste l'alternative.

L'ancienne voie, construite sur pip install letta et le serveur d'API Python, fonctionne toujours et alimente encore les SDK de première génération. Son dépôt est cependant en mode maintenance, donc un nouveau projet n'a aucune raison d'y recourir.

Sur le backend local, l'état de l'agent, blocs de mémoire compris, vit sur la machine qui exécute le serveur et est versionné avec git. Sur le backend cloud, l'état reste chez l'éditeur tandis que le harnais d'agent lui-même peut tourner sur ton propre matériel, ce qui garde les outils et les données proches.

L'état de l'agent est durable, donc un agent créé une fois persiste et se souvient des conversations précédentes. Cela semble évident et comporte une conséquence opérationnelle : les agents s'accumulent, chacun occupe de la place et chacun conserve son propre historique. Dans une application qui crée un agent par utilisateur, sache dès le départ comment les supprimer et ce qu'il advient de leur mémoire lors d'une demande de suppression de données.

Inspecter ce qu'un agent détient en mémoire compte davantage ici que dans une application ordinaire, car le modèle modifie lui-même la mémoire. Brancher un outil de tracing, Arize Phoenix par exemple, te permet de voir quels appels d'outils ont produit l'état actuel des blocs.

Quand c'est le bon choix

Trois conditions méritent d'être vérifiées avant de décider.

La première : tu construis quelque chose de nouveau. Avec une application existante qui a sa propre boucle d'agent, passer à ce runtime signifie une réécriture plutôt que l'ajout d'une dépendance.

La deuxième : l'agent est censé vivre longtemps et apprendre à connaître la personne. Pour des tâches ponctuelles où chaque appel est indépendant, tout le mécanisme est un coût inutile.

La troisième : tu acceptes qu'un modèle gère la mémoire. Cela signifie consentir à une certaine imprévisibilité en échange de ne pas avoir à décrire des règles sur ce qu'il faut retenir. Là où tu dois savoir exactement ce qui a été enregistré, pour des raisons réglementaires par exemple, ce consentement est parfois impossible.

Si l'une des conditions n'est pas remplie, une couche de mémoire plus simple ou ta propre table offre la même chose à moindre coût et avec plus de contrôle.

Erreurs fréquentes

La première est de le traiter comme une bibliothèque à greffer. C'est un runtime d'agents, donc le choix concerne l'architecture de toute l'application.

La deuxième est de ne jamais inspecter les blocs de mémoire. Un modèle les gère de façon imparfaite, et sans regarder le contenu tu ne découvriras pas qu'il a enregistré des broutilles et perdu ce qui comptait.

La troisième est d'ignorer le coût du traitement en arrière-plan. Les tokens sont consommés pendant que personne ne parle, donc la facture ne suit pas le nombre de conversations.

La quatrième est d'ignorer la latence de l'accès à l'archive. Chaque appel de ce type est un tour supplémentaire avec le modèle, ce qui se ressent dans une conversation en direct.

La cinquième est de créer un agent par utilisateur sans plan pour les supprimer. L'état durable signifie qu'ils s'accumulent et subsistent, y compris après le départ d'un utilisateur.

La sixième est de supposer que l'agent ira toujours dans l'archive quand il le faut. S'il décide qu'il en sait assez, il répond à partir du contexte, avec assurance et de façon incomplète.

FAQ

En quoi Letta diffère-t-il de Mem0 et Zep ?

Par la portée. Mem0 et Zep sont des couches de mémoire que tu attaches à ton propre agent et appelles depuis ton code. Letta est un runtime où l'agent vit côté serveur et édite sa propre mémoire avec des outils, donc le choix concerne l'architecture plutôt qu'une dépendance.

Que sont les blocs de mémoire ?

Des morceaux de texte nommés, présents en permanence dans le contexte de l'agent, auxquels l'agent peut ajouter et qu'il peut remplacer avec ses propres outils. Les blocs conventionnels décrivent la personne et l'agent lui-même, et on peut en ajouter des personnalisés, par exemple pour l'état actuel d'un dossier.

Letta peut-il tourner sur ma propre infrastructure ?

Oui, la licence est Apache 2.0. L'App Server s'en charge, démarré avec letta server depuis le paquet @letta-ai/letta-code, et ton application s'y connecte par WebSocket. L'ancien serveur d'API Python du paquet letta peut encore être auto-hébergé, mais son dépôt est en mode maintenance depuis juillet 2026.

Est-ce lié à MemGPT ?

Oui, le produit est issu de la recherche sur ce projet et a gardé son idée centrale : traiter la fenêtre de contexte comme une mémoire de travail, le reste étant conservé dans un stockage externe que l'agent atteint par un outil.

Combien ça coûte ?

L'exécuter toi-même est gratuit ; tu paies les tokens chez ton fournisseur de modèle. Une variante hébergée avec un niveau gratuit et des plans payants existe aussi, et il vaut la peine de vérifier la grille tarifaire actuelle avant de décider, car la ligne du traitement en arrière-plan grossit indépendamment du nombre de conversations.

La documentation se trouve sur le site du produit, et le code et les versions dans le dépôt GitHub.

À lire aussi