Comment Ajouter une Mémoire Persistante à Votre Agent IA : Se Souvenir d'Hier

En bref

Ajoutez une mémoire persistante aux agents IA en 4 étapes : (1) Configurez un serveur de mémoire MCP avec les outils remember, recall, search et rollback, (2) Ajoutez des instructions de mémoire aux invites des agents, (3) Configurez ~/.claude/settings.json pour Claude Code ou .cursor/mcp.json pour Cursor, (4) Utilisez des modèles de mémoire pour l'enregistrement des décisions, les transferts d'agents et les points de contrôle de session. Les agents conservent le contexte entre les sessions — fini le copier-coller des conversations précédentes.

Essayez Apidog dès aujourd'hui

Résolvez le problème du « je ne me souviens pas d'hier ». Ajoutez une mémoire persistante aux agents IA à l'aide du protocole MCP, et ils retiendront décisions, livrables et contexte des sessions précédentes.

Vous connaissez la chanson :

Day 1: "Build the user authentication system"
Agent: [Builds JWT auth, creates users table, implements refresh tokens]

Day 2: "Continue from yesterday"
Agent: "I don't have context from previous sessions. Can you paste what we did?"

Vous copiez-collez la conversation précédente. L'agent lit 2000 lignes de contexte. Vous perdez tous les deux 15 minutes à vous remettre à niveau.

La mémoire persistante résout ce problème. Avec la mémoire MCP (Model Context Protocol), les agents stockent automatiquement les décisions et les rappellent quand nécessaire. Pas de copier-coller. Pas de ré-explication.

Dans ce tutoriel, vous allez configurer la mémoire MCP pour vos agents IA. Vous apprendrez à stocker les décisions des sessions de l'Architecte Backend, rappeler le contexte lors du passage à l'Optimiseur de Base de Données, et transférer les livrables au Développeur Frontend — sans perdre le contexte. Ces modèles de mémoire fonctionnent aussi bien pour la construction d’API avec l’intégration Apidog que pour gérer des sprints de développement sur plusieurs jours.

Qu'est-ce que la mémoire MCP ?

La mémoire MCP permet aux agents IA de stocker et de récupérer des informations entre les sessions. Considérez-la comme un carnet partagé que les agents peuvent écrire et lire.

Quatre outils alimentent la mémoire MCP :

Outil	Objectif	Exemple
remember	Stocker des informations avec des étiquettes	Enregistrer « table des utilisateurs avec UUID, bcrypt »
recall	Rechercher par mot-clé ou étiquette	Trouver « décisions d'authentification »
rollback	Restaurer à un état précédent	Annuler les mauvaises modifications de schéma
search	Rechercher entre les sessions	« Qu'a décidé l'Architecte Backend ? »

┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  AI Agent       │         │  MCP Memory      │         │  Storage    │
│  (Claude Code)  │◄───────►│  Server          │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

Étape 1 : Configurer un serveur de mémoire MCP

Vous avez besoin d'un serveur MCP qui expose les outils de mémoire. Plusieurs implémentations open source existent.

Option A : Utiliser un serveur de mémoire hébergé

npm install -g @example/mcp-memory-server

Option B : Exécuter un simple serveur local

Créez memory-server.js :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const MEMORY_FILE = path.join(process.env.HOME, ".mcp-memory", "memories.json");

const server = new McpServer({
  name: "memory",
  version: "1.0.0"
});

// Ensure memory file exists
async function initMemory() {
  await fs.mkdir(path.dirname(MEMORY_FILE), { recursive: true });
  try {
    await fs.access(MEMORY_FILE);
  } catch {
    await fs.writeFile(MEMORY_FILE, JSON.stringify([]));
  }
}

// Tool: remember
server.tool(
  "remember",
  {
    content: z.string().describe("Information to store"),
    tags: z.array(z.string()).describe("Tags for retrieval (e.g., ['backend', 'auth'])"),
    agent: z.string().optional().describe("Agent name for tagging")
  },
  async ({ content, tags, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const memory = {
      id: Date.now().toString(),
      content,
      tags,
      agent,
      timestamp: new Date().toISOString()
    };
    memories.push(memory);
    await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2));
    return { content: [{ type: "text", text: `Stored memory with tags: ${tags.join(", ")}` }] };
  }
);

// Tool: recall
server.tool(
  "recall",
  {
    query: z.string().describe("Search query or tag to find"),
    agent: z.string().optional().describe("Filter by agent name")
  },
  async ({ query, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories.filter(m =>
      (m.content.toLowerCase().includes(query.toLowerCase()) ||
      m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()))) &&
      (!agent || m.agent === agent)
    );
    return {
      content: [{
        type: "text",
        text: results.length === 0
          ? "No memories found"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Tags to search for"),
    limit: z.number().optional().default(10)
  },
  async ({ tags, limit }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories
      .filter(m => tags.some(t => m.tags.includes(t)))
      .slice(0, limit);
    return {
      content: [{
        type: "text",
        text: results.map(m => `[${m.agent || "unknown"}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: rollback
server.tool(
  "rollback",
  {
    agent: z.string().describe("Agent name to rollback"),
    timestamp: z.string().describe("Rollback to this timestamp")
  },
  async ({ agent, timestamp }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const rolledBack = memories.filter(m =>
      m.agent !== agent || new Date(m.timestamp) <= new Date(timestamp)
    );
    await fs.writeFile(MEMORY_FILE, JSON.stringify(rolledBack, null, 2));
    return {
      content: [{
        type: "text",
        text: `Rolled back ${agent} to ${timestamp}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Exécutez le serveur :

node memory-server.js

Étape 2 : Ajouter des instructions de mémoire à n'importe quel agent

Aucune modification des fichiers de l’agent n’est requise. Ajoutez des instructions de mémoire dans votre invite :

Vous avez accès aux outils de mémoire MCP : remember, recall, search, rollback.

Suivez ces protocoles de mémoire :

**Lorsque vous démarrez une session :**
1. Rappeler le contexte : recall(query="ecommerce-api", agent="Backend Architect")
2. Examiner les éléments en attente de la dernière session

**Lorsque vous terminez le travail :**
1. Mémoriser les livrables avec des balises :
   - remember(content="Table des utilisateurs créée avec clé primaire UUID, hachage de mot de passe bcrypt, authentification JWT avec jetons de rafraîchissement", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Inclure les décisions prises et les éléments en attente

**Lors du transfert à un autre agent :**
1. Laisser le contexte pour l'agent destinataire :
   - remember(content="Endpoints API : /auth/login, /auth/register, /products, /orders. Flux d'authentification : jeton d'accès JWT (15min) + jeton de rafraîchissement (7 jours). Problème connu : la limitation de débit n'est pas encore implémentée", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**En cas d'échec :**
1. Rechercher le dernier état valide connu
2. Utiliser rollback pour restaurer

Exemple en action :

Vous : « Activez le mode Architecte Backend. Concevez le système utilisateur pour notre API e-commerce. »

Agent : [Construit l'authentification JWT, crée la table des utilisateurs, implémente les jetons de rafraîchissement]

Agent : « Système utilisateur terminé. Stockage de la mémoire... »
→ Appelle : remember("table des utilisateurs avec UUID, bcrypt, JWT + jetons de rafraîchissement", tags: ["ecommerce-api", "auth", "database"])

[Fin de session]

[Le lendemain]

Vous : « Continuez à partir d'hier »

Agent : « Rappel du contexte... »
→ Appelle : recall(query="ecommerce-api")
→ Retourne : « table des utilisateurs avec UUID, bcrypt, JWT + jetons de rafraîchissement »

Agent : « Hier, j'ai conçu la table des utilisateurs avec des clés primaires UUID, implémenté le hachage de mot de passe bcrypt et configuré l'authentification JWT avec des jetons de rafraîchissement. Prochaine étape : schéma du catalogue de produits. Prêt à continuer. »

Étape 3 : Configurer pour Claude Code

Ajoutez le serveur de mémoire à votre configuration MCP.

Modifiez ~/.claude/settings.json :

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/your-username"
      }
    }
  }
}

Redémarrez Claude Code. Les outils de mémoire devraient maintenant être disponibles.

Testez-le :

Utilisez l'outil remember pour stocker : "Mémoire de test pour le projet e-commerce"
Balises : ["test", "ecommerce-api"]

Utilisez l'outil recall pour trouver des mémoires sur "test"

Étape 4 : Configurer pour Cursor

Créez .cursor/mcp.json dans votre projet :

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"]
    }
  }
}

Testez-le :

@memory remember "Démarrage du projet API e-commerce avec PostgreSQL"
Balises : ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Modèles de mémoire pour les flux de travail réels

Modèle 1 : Enregistrement des décisions

À chaque décision technique, enregistrez-la :

remember({
  content: "Choix de PostgreSQL plutôt que MySQL pour : (1) support JSONB pour les attributs de produit flexibles, (2) meilleure recherche plein texte, (3) support natif UUID",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Plus tard, pour retrouver la raison :

recall(query="PostgreSQL MySQL decision")

Modèle 2 : Transferts d'agents

Lors d'un changement d'agent, laissez une note de transfert :

remember({
  content: "Backend terminé. Endpoints : POST /auth/login, POST /auth/register, GET /products, POST /orders. Auth : accès JWT 15min + rafraîchissement 7 jours. En attente : limitation de débit, vérification d'e-mail. Besoins frontend : formulaire de connexion, liste de produits, panier, paiement.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Le Développeur Frontend démarre par :

recall(query="handoff", agent="Backend Architect")

Modèle 3 : Points de contrôle de session

À la fin de chaque session :

remember({
  content: "Session terminée. Fait : table des utilisateurs, endpoints d'authentification, schéma de produit. Prochaine session : système de commande, webhook de paiement. Bloqueurs : en attente des clés API Stripe.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Pour reprendre la session :

recall(query="checkpoint session-1")

Modèle 4 : Suivi des bugs

Quand vous trouvez un bug :

remember({
  content: "BUG : Le jeton de rafraîchissement n'expire pas après la déconnexion. Jeton stocké en mémoire, non persistant. Correction : déplacer vers Redis avec TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Pour retrouver les bugs :

search(tags=["bug", "ecommerce-api"])

Dépannage

La mémoire ne persiste pas :

• Vérifiez le chemin du fichier de mémoire (~/.mcp-memory/memories.json)
• Assurez-vous que le serveur MCP est en cours d'exécution
• Vérifiez que Claude Code/Cursor a la configuration MCP

Trop de résultats lors du rappel :

• Ajoutez des balises plus spécifiques
• Filtrez par nom d'agent
• Utilisez des expressions exactes entre guillemets

Le fichier de mémoire devient volumineux :

• Archivez périodiquement les anciennes mémoires
• Utilisez rollback pour nettoyer les projets terminés
• Ajoutez des dates d'expiration à votre schéma de mémoire

Ce que vous avez construit

Composant	Objectif
Serveur de mémoire MCP	Stocke/récupère des informations entre sessions
Outil remember	Enregistre les décisions, livrables, transferts
Outil recall	Trouve le contexte des sessions précédentes
Outil search	Recherche par balises dans toutes les mémoires
Outil rollback	Restaure à un état précédent si nécessaire
Modèles de mémoire	Enregistrement des décisions, transferts, points de contrôle, suivi des bugs

Prochaines étapes

Étendre le serveur de mémoire :

• Ajouter une recherche sémantique avec des embeddings
• Implémenter l'expiration de la mémoire (auto-archivage après 30 jours)
• Ajouter une synthèse de la mémoire (condenser les longues sessions)

Construire une mémoire d'équipe :

• Partager un serveur de mémoire centralisé au sein de votre équipe
• Étiqueter les mémoires par projet et par développeur
• Créer des parcours d'intégration pour les nouveaux membres

Intégrer avec les outils :

• Enregistrer automatiquement les commits git comme mémoires
• Synchroniser avec la gestion de projet (Jira, Linear)
• Exporter les mémoires vers la documentation

Dépannage des problèmes courants

La mémoire ne persiste pas entre les sessions :

• Vérifiez que le serveur MCP est en cours d'exécution avant de démarrer Claude Code
• Vérifiez que le chemin du fichier de mémoire existe : ls -la ~/.mcp-memory/memories.json
• Assurez-vous que les permissions de fichier autorisent la lecture/écriture : chmod 644 ~/.mcp-memory/memories.json
• Confirmez que la configuration du serveur dans ~/.claude/settings.json pointe vers le bon chemin

Le rappel renvoie des résultats vides :

• Vérifiez que la requête correspond aux balises stockées (sensible à la casse)
• Essayez des termes de recherche plus larges ou utilisez search avec des balises spécifiques
• Vérifiez si les mémoires ont réellement été stockées : cat ~/.mcp-memory/memories.json
• Assurez-vous que le filtre de nom d'agent correspond (si le paramètre agent est utilisé)

Le fichier de mémoire devient trop volumineux :

• Implémentez l'archivage automatique pour les mémoires de plus de 30 jours
• Ajoutez un outil prune qui supprime les mémoires par plage de dates
• Divisez les mémoires en fichiers distincts par projet ou par date
• Utilisez un backend de base de données (SQLite) au lieu de JSON pour une utilisation à grande échelle

Le serveur ne démarre pas :

• Vérifiez la version de Node.js : node --version (devrait être 18+)
• Installez les dépendances manquantes : npm install @modelcontextprotocol/sdk zod
• Recherchez les erreurs de syntaxe dans le code du serveur
• Exécutez directement pour voir les erreurs : node memory-server.js

Plusieurs agents écrasent les mémoires des autres :

• Incluez toujours le champ agent lors de l'appel à remember
• Utilisez des balises uniques par projet : ["project-x", "backend", "auth"]
• Filtrez le rappel par nom d'agent lors de la récupération du contexte
• Envisagez des fichiers de mémoire séparés par projet

Considérations de sécurité du serveur de mémoire

Stockage des clés API : Si votre serveur de mémoire stocke des données sensibles (clés API, mots de passe), implémentez le chiffrement :

import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.MEMORY_ENCRYPTION_KEY;
const ALGORITHM = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY), iv);
  const encrypted = cipher.update(text, 'utf8', 'hex');
  return {
    encryptedData: encrypted + cipher.final('hex'),
    iv: iv.toString('hex'),
    authTag: cipher.getAuthTag().toString('hex')
  };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY),
    Buffer.from(encrypted.iv, 'hex')
  );
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  return decipher.update(encrypted.encryptedData, 'hex', 'utf8') + decipher.final('utf8');
}

Contrôle d'accès : Pour les serveurs de mémoire d'équipe, ajoutez une authentification :

• Exigez une clé API dans les appels d'outils de mémoire
• Implémentez des espaces de noms de mémoire spécifiques à l'utilisateur
• Enregistrez toutes les opérations de mémoire pour les pistes d'audit
• Limitez le taux des requêtes par utilisateur

Vos agents IA disposent désormais d'une mémoire persistante. Ils se souviennent d'hier. Ils rappellent les décisions. Ils transmettent le contexte sans copier-coller.

Fini le « Je n'ai pas le contexte des sessions précédentes. » Fini les ré-explications. Fini le temps perdu.

C'est le pouvoir de la mémoire MCP : donnez à vos agents un carnet partagé, et regardez-les devenir réellement utiles sur des projets de plusieurs jours.

FAQ

Qu'est-ce que la mémoire MCP ?

La mémoire MCP est une implémentation de protocole qui permet aux agents IA de stocker et de récupérer des informations entre les sessions. Considérez-la comme un carnet partagé que les agents peuvent écrire et lire, persistant le contexte au-delà des conversations uniques.

Comment configurer une mémoire persistante pour Claude Code ?

Installez un serveur de mémoire MCP, puis ajoutez-le à ~/.claude/settings.json avec la commande et le chemin du serveur. Redémarrez Claude Code : les outils de mémoire (remember, recall, search, rollback) seront disponibles.

Quels agents IA supportent la mémoire MCP ?

Tout agent fonctionnant sur des clients compatibles MCP (Claude Code, Cursor, Windsurf) peut utiliser les outils de mémoire. Vous n'avez pas besoin de modifier les fichiers des agents — ajoutez simplement des instructions de mémoire à vos invites.

Quels sont les meilleurs modèles de mémoire pour les transferts d'agents ?

Utilisez remember avec des balises comme ["handoff", "nom-du-projet"] pour laisser le contexte au prochain agent. Incluez le travail terminé, les éléments en attente et les problèmes connus. L'agent récepteur appelle recall(query="handoff") pour le récupérer.

Quelle quantité de mémoire les serveurs MCP peuvent-ils stocker ?

Cela dépend de l'implémentation. Le serveur de référence utilise un fichier JSON qui croît indéfiniment. Les serveurs de production devraient ajouter des politiques d'expiration, d'auto-archivage ou des backends de base de données pour une utilisation à grande échelle.

Les équipes peuvent-elles partager un serveur de mémoire centralisé ?

Oui. Exécutez le serveur de mémoire sur une machine partagée ou une instance cloud, configurez les clients de tous les membres de l'équipe pour qu'ils s'y connectent, et étiquetez les mémoires par projet et par développeur pour une récupération organisée.

Que faire si le rappel de mémoire renvoie trop de résultats ?

Ajoutez des balises plus spécifiques lors du stockage des mémoires. Filtrez par nom d'agent dans vos requêtes de rappel. Utilisez des expressions exactes entre guillemets. Envisagez d'implémenter une recherche sémantique avec des embeddings pour une récupération plus intelligente.