Ton IA t'oublie chaque matin — comment corriger ça et 6 projets à construire

#Le problème en une phrase

Chaque session avec un LLM repart de zéro. Claude ne sait pas que tu utilises Bun, GPT ne se souvient pas que tu es végétarien, Gemini a oublié ton architecture microservices. Tu passes tes premières minutes à réexpliquer du contexte que tu as déjà donné hier.

Ce n'est pas un bug — c'est une conséquence directe du fonctionnement des modèles de langage. Leur fenêtre de contexte est éphémère : elle existe le temps d'une conversation et disparaît ensuite. Peu importe le modèle, le fournisseur ou le plan tarifaire.

La bonne nouvelle : en 2026, l'écosystème des solutions de mémoire persistante a explosé. Du fichier texte local au graphe de connaissances temporel, il existe une solution pour chaque besoin.

#Trois familles de solutions

#1. La mémoire native des outils

La plupart des assistants IA proposent désormais un mécanisme intégré pour retenir du contexte entre les sessions.

Claude Code a le système le plus structuré. Le fichier CLAUDE.md contient tes instructions projet (stack, conventions, commandes). Le système d'auto-memory va plus loin : Claude écrit lui-même ses apprentissages dans ~/.claude/projects/<repo>/memory/. Ces fichiers survivent entre les sessions et sont chargés automatiquement.

ChatGPT propose deux types de mémoire : les saved memories (que tu demandes explicitement de retenir) et les insights extraits automatiquement des conversations. La limite principale : la mémoire est globale, pas par projet. Si tu travailles sur un backend Go et un frontend React, les deux contextes se mélangent.

Cursor utilise des fichiers de règles locaux (.cursor/rules/*.mdc). C'est du contexte passif — pas de mémoire entre sessions, mais des instructions rechargées à chaque ouverture du projet. Le pattern communautaire Memory Bank (6 fichiers markdown structurés) compense cette limitation.

#2. Les frameworks de mémoire spécialisés

Pour aller plus loin que du texte brut, des frameworks dédiés gèrent la mémoire comme une infrastructure à part entière.

Mem0 est le plus adopté. Il extrait automatiquement des faits des conversations, détecte les conflits (si une nouvelle information contredit une mémoire existante), et compresse le contexte de 80%. Il supporte plus de 20 bases vectorielles.

Zep se distingue par son graphe de connaissances temporel. Chaque fait a une date de validité. "Le client utilise React 17" peut être automatiquement remplacé par "Le client a migré vers React 19 en février 2026". C'est particulièrement utile pour le support client ou les projets qui évoluent vite.

LangMem gère trois types de mémoire distincts :

• Sémantique — faits et connaissances ("Le projet utilise PostgreSQL 16")
• Épisodique — interactions réussies comme exemples d'apprentissage ("Quand l'utilisateur a demandé X, la réponse Y a bien fonctionné")
• Procédurale — guidelines comportementales qui évoluent ("Toujours proposer des tests avant de refactorer")

#3. L'approche DIY

Si tu veux un contrôle total, tu peux construire ta propre couche de mémoire. L'architecture de base : une base vectorielle (PostgreSQL + pgvector), un modèle d'embedding pour transformer le texte en vecteurs, et un serveur MCP pour connecter le tout à tes outils IA.

#6 projets concrets à construire

La mémoire persistante n'est pas qu'un concept théorique. Voici six projets que tu peux construire aujourd'hui, classés du plus simple au plus ambitieux.

#1. Assistant de code avec mémoire projet

Difficulté : facile — Temps : 30 minutes

Le projet le plus accessible. Tu configures un CLAUDE.md structuré qui retient l'architecture de ton projet, les conventions de code, les commandes de build, et les décisions techniques passées.

L'idée clé : ne pas tout mettre dans un seul fichier. Utilise le système de règles modulaires (.claude/rules/) pour scoper les instructions par type de fichier. Les conventions API ne se chargent que quand tu travailles sur l'API. Les règles de testing ne s'activent que sur les fichiers de test.

mon-projet/
├── .claude/
│   ├── CLAUDE.md          # Stack, commandes, contexte global
│   └── rules/
│       ├── api.md         # Conventions API (scopé sur src/api/**)
│       ├── testing.md     # Standards de test (scopé sur **/*.test.*)
│       └── components.md  # Patterns React (scopé sur src/components/**)

Résultat : Claude suit tes conventions dès la première ligne de code, sans que tu aies à les rappeler.

#2. Base de connaissances conversationnelle

Difficulté : moyenne — Temps : 2-3 heures

Tu construis un système où chaque conversation enrichit automatiquement une base de connaissances. L'IA extrait les faits importants, les stocke sous forme d'embeddings, et les retrouve par recherche sémantique lors des sessions suivantes.

L'architecture minimale : Mem0 (ou pgvector en DIY) pour le stockage, un prompt système qui demande à l'IA de sauvegarder les décisions importantes en fin de session, et un mécanisme de recherche qui injecte les mémoires pertinentes en début de conversation.

Résultat : un "second cerveau" qui s'enrichit à chaque interaction, sans effort manuel.

#3. Agent support client avec historique

Difficulté : moyenne — Temps : 4-6 heures

Un agent qui se souvient de chaque interaction avec un client. Le ticket #47 mentionne un problème de facturation ? L'agent sait que ce même client a eu un problème similaire en janvier et que la solution avait été d'ajuster son plan.

Zep est particulièrement adapté ici grâce à son graphe temporel : les informations client évoluent (changement de plan, de préférences, d'interlocuteur) et Zep gère automatiquement la chronologie.

Résultat : un support plus rapide et plus pertinent, sans obliger l'agent (ni l'humain) à relire l'historique complet.

#4. Système de documentation vivante

Difficulté : moyenne — Temps : une demi-journée

Chaque fois que tu expliques une partie du code à l'IA (ou que l'IA l'explore), les insights sont capturés et transformés en documentation. Les décisions d'architecture, les raisons derrière un pattern inhabituel, les pièges connus — tout est sauvegardé automatiquement.

Le principe : un hook post-session qui analyse la conversation, extrait les explications techniques, et les ajoute dans un dossier docs/ structuré par module.

Résultat : une documentation qui se maintient elle-même, alimentée par l'usage réel du code plutôt que par un effort d'écriture dédié.

#5. Agent d'onboarding personnalisé

Difficulté : avancée — Temps : 1-2 jours

Un agent qui guide les nouveaux développeurs dans le codebase en s'adaptant à leur niveau et à leurs questions précédentes. Il retient ce qu'ils ont déjà compris, identifie les zones où ils bloquent, et ajuste ses explications progressivement.

La mémoire épisodique de LangMem est idéale ici : l'agent apprend quelles explications fonctionnent pour quel profil de développeur.

Résultat : un onboarding plus rapide et moins dépendant de la disponibilité des développeurs seniors.

#6. Pipeline d'apprentissage continu

Difficulté : avancée — Temps : 2-3 jours

Le projet le plus ambitieux : un agent qui s'améliore à chaque tâche. Quand une approche échoue (le build casse, les tests ne passent pas), l'agent mémorise l'erreur et la solution. Quand une approche réussit, il mémorise le pattern.

L'architecture combine les trois types de mémoire de LangMem :

• Sémantique pour les faits techniques du projet
• Épisodique pour les succès et échecs passés
• Procédurale pour les guidelines comportementales qui évoluent

Après quelques semaines, l'agent connaît les pièges spécifiques de ton codebase et les évite sans qu'on le lui rappelle.

Résultat : un assistant qui devient plus efficace au fil du temps — l'opposé exact de l'amnésie quotidienne.

#Quel outil choisir

Le choix dépend de ton cas d'usage principal :

#Ce qu'il faut retenir

L'amnésie des IA n'est plus une fatalité en 2026. L'écosystème offre des solutions à tous les niveaux :

• Niveau 0 : un fichier CLAUDE.md de 60 lignes bien écrites — gratuit, immédiat, et déjà transformateur
• Niveau 1 : une base vectorielle personnelle (Open Brain) — quelques centimes par mois, recherche sémantique
• Niveau 2 : un framework spécialisé (Mem0, Zep, LangMem) — pour la production et les cas complexes

Le principe sous-jacent est toujours le même : ta connaissance t'appartient. Que tu la stockes dans un fichier Markdown local ou dans un graphe de connaissances distribué, l'important est qu'elle survive à la fermeture de la fenêtre de chat.

Et le meilleur point de départ, c'est le projet numéro 1 : structure ton CLAUDE.md, ajoute des règles scopées, et observe la différence dès ta prochaine session.