Blog

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

Ashley Innocent

Ashley Innocent

19 March 2026

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

enterprise.banner.title

enterprise.banner.feature1

enterprise.banner.feature2

enterprise.banner.feature3

enterprise.banner.ctaB

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.

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 se souviendront des décisions, des livrables et du 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 configurerez la mémoire MCP pour les 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 — le tout sans perdre le contexte. Les mêmes modèles de mémoire fonctionnent que vous construisiez des API avec l'intégration Apidog ou que vous gériez des sprints de développement de plusieurs jours.

button

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 des 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 => {
      const matchesQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
                          m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()));
      const matchesAgent = !agent || m.agent === agent;
      return matchesQuery && matchesAgent;
    });
    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

Vous n'avez pas besoin de modifier les fichiers de l'agent. 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 fois que vous prenez une 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, lorsque quelqu'un demande « Pourquoi PostgreSQL ? » :

recall(query="PostgreSQL MySQL decision")

Modèle 2 : Transferts d'agents

Lorsque vous changez 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 commence par :

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

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

À la fin de chaque session de travail :

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"
})

Reprendre la prochaine session :

recall(query="checkpoint session-1")

Modèle 4 : Suivi des bugs

Lorsque 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"
})

Rechercher des bugs plus tard :

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

Dépannage

La mémoire ne persiste pas :

Trop de résultats lors du rappel :

Le fichier de mémoire devient volumineux :

Ce que vous avez construit

Composant Objectif
Serveur de mémoire MCP Stocke/récupère des informations entre les sessions
Outil remember Enregistre les décisions, les livrables, les 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 :

Construire une mémoire d'équipe :

Intégrer avec les outils :

Dépannage des problèmes courants

La mémoire ne persiste pas entre les sessions :

Le rappel renvoie des résultats vides :

Le fichier de mémoire devient trop volumineux :

Le serveur ne démarre pas :

Plusieurs agents écrasent les mémoires des autres :

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 :

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.

button

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 et les outils de mémoire (remember, recall, search, rollback) deviendront 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.

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger