/ Annuaire / Playground / Memory
← Tous les serveurs ↗ GitHub
● Officiel modelcontextprotocol ⚡ Instantané

Memory

par modelcontextprotocol · modelcontextprotocol/servers

Un graphe de connaissances persistant dans lequel Claude écrit et dont il lit les données à travers les conversations — il se souvient donc de votre projet, votre équipe et vos préférences.

Le Memory MCP de référence. Stocke les entités (personnes, projets, choses), leurs observations (faits) et les relations typées entre eux, sous forme de graphe de connaissances JSON local. Permet à Claude de mémoriser des faits spécifiques ('notre DB de prod s'appelle api-prod-01', 'Jamie préfère les descriptions de PR sous forme de points') sans dépendre de sa fenêtre de contexte.

▶ Voir la démo 📦 Installer 💡 Cas d'usage

Pourquoi l'utiliser

Fonctionnalités clés

Démo en direct

Aperçu en pratique

memory.replay ▶ prêt
0/0

Installer

Choisissez votre client

~/Library/Application Support/Claude/claude_desktop_config.json  · Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Ouvrez Claude Desktop → Settings → Developer → Edit Config. Redémarrez après avoir enregistré.

~/.cursor/mcp.json · .cursor/mcp.json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Cursor utilise le même schéma mcpServers que Claude Desktop. La config projet l'emporte sur la globale.

VS Code → Cline → MCP Servers → Edit
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Cliquez sur l'icône MCP Servers dans la barre latérale Cline, puis "Edit Configuration".

~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}

Même format que Claude Desktop. Redémarrez Windsurf pour appliquer.

~/.continue/config.json
{
  "mcpServers": [
    {
      "name": "memory",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  ]
}

Continue utilise un tableau d'objets serveur plutôt qu'une map.

~/.config/zed/settings.json
{
  "context_servers": {
    "memory": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-memory"
        ]
      }
    }
  }
}

Ajoutez dans context_servers. Zed recharge à chaud à la sauvegarde.

claude mcp add memory -- npx -y @modelcontextprotocol/server-memory

Une seule ligne. Vérifiez avec claude mcp list. Supprimez avec claude mcp remove.

Cas d'usage

Usages concrets : Memory

Comment arrêter de réexpliquer votre projet à Claude chaque matin

👤 Les développeurs solo et les utilisateurs avancés qui discutent quotidiennement avec Claude du même codebase ⏱ ~15 min beginner

Quand l'utiliser : Vous collez continuellement le même paragraphe d'introduction : « notre stack est X, la DB de prod est Y, nous n'utilisons pas Z » — au début de chaque session.

Prérequis
  • Memory MCP en cours d'exécution avec un chemin de fichier persistant — Définissez MEMORY_FILE_PATH=/Users/you/.claude/memory.json pour que le graphe persiste après les redémarrages
Déroulement
  1. Initialiser le graphe avec les faits fondamentaux
    Créez des entités pour : ma compagnie (Acme), notre dépôt principal (acme-corp/api) et notre base de données de prod (api-prod-01). Ajoutez des observations comme « utilise Postgres 16 », « hébergée sur AWS RDS us-east-1 », « fenêtre de sauvegarde à 03:00 UTC ». Connectez-les avec des relations.✓ Copié
    → Entités et relations créées, visibles via read_graph
  2. Ajouter des observations de préférences au fur et à mesure
    Mémorisez : quand je vous demande d'écrire des messages de commit pour ce dépôt, utilisez l'impératif sans balises de préfixe. Stockez ceci comme observation sur l'entité « acme-corp/api ».✓ Copié
    → Observation ajoutée sans recréer l'entité
  3. Testez le rappel dans une nouvelle session
    Que savez-vous sur api-prod-01 ?✓ Copié
    → Claude interroge le graphe et affiche les faits, pas une réponse générique

Résultat : Un graphe de connaissances personnel qui s'améliore à chaque conversation — plus vous utilisez Claude, moins vous tapez de code passe-partout.

Pièges
  • Claude n'utilise pas automatiquement la mémoire ; il oublie de vérifier — Ajoutez « Consultez toujours le graphe de mémoire au début de chaque tâche concernant ce projet » à votre invite système/projet
  • Le graphe devient désorganisé — entités dupliquées avec légères variations de noms — Choisissez une convention d'appellation (kebab-case) et demandez périodiquement à Claude de faire read_graph et de dédupliquer
Combiner avec : filesystem · github

Créer un CRM léger des préférences de vos collègues

👤 Les contributeurs individuels et les responsables qui travaillent avec plusieurs parties prenantes ⏱ ~10 min beginner

Quand l'utiliser : Vous oubliez continuellement qui préfère Slack par rapport à e-mail, qui veut des points par rapport à de la prose, qui est sur quel projet.

Déroulement
  1. Créer une entité personne à la première interaction
    Créez une entité Person « jamie-chen ». Observations : « responsable de produit de l'équipe checkout », « préfère Loom aux documents », « les révisions ont lieu les mardi/jeudi matins PT ».✓ Copié
    → Entité visible via open_nodes
  2. Lier les personnes aux projets avec des relations
    Ajoutez une relation : jamie-chen --owns--> checkout-redesign-2026. Et : alex-kim --reviews--> checkout-redesign-2026.✓ Copié
    → Les relations apparaissent dans le graphe
  3. Requête avant d'écrire quelque chose pour eux
    Je m'apprête à rédiger une mise à jour pour Jamie sur la refonte du checkout. Que sais-je de ses préférences de communication et du projet ?✓ Copié
    → Retourne les préférences stockées, informe le ton du brouillon

Résultat : Vous arrêtez de vous demander « qui était ce responsable de produit déjà ? » et vos mises à jour asynchrones donnent le bon ton dès le premier coup.

Pièges
  • Stocker des informations sensibles/personnelles sur de vrais collègues semble étrange et pourrait fuir — Stockez uniquement les observations de préférences de travail ; jamais de détails personnels. Traitez le fichier comme sensible — il se synchronise avec tout ce pour lequel vous le sauvegardez
Combiner avec : linear · github

Gardez une trace de recherche à travers de nombreuses sessions

👤 Les chercheurs, les écrivains, quiconque enquête sur un sujet pendant des semaines ⏱ ~20 min intermediate

Quand l'utiliser : Vous menez des recherches sur un sujet (étude de marché, revue de littérature, enquête) qui s'étend sur plusieurs sessions et sources.

Déroulement
  1. Capturez chaque découverte comme observation sur une entité de sujet
    Je recherche sur « l'adoption du MCP dans les entreprises ». Créez-la comme entité. Maintenant ajoutez cette découverte comme observation : « Anthropic rapporte que 60 % des clients Claude Code utilisent 3+ MCP (source : blog 2026-03-12) ».✓ Copié
    → L'entité de sujet se développe de manière incrémentale avec des observations citées
  2. Liez les sujets connexes
    Créez l'entité « MCP security concerns ». Reliez-la à « MCP adoption in enterprises » avec la relation « blocks-adoption-when-unaddressed ».✓ Copié
    → Le graphe montre la connexion sémantique
  3. Demandez une synthèse à tout moment
    En fonction de toutes les observations connectées à « MCP adoption in enterprises », rédigez un résumé d'une page avec des citations.✓ Copié
    → Synthèse avec sources par affirmation, rien de fabriqué

Résultat : Un actif de recherche citable et incrémental qui ne dépend pas de gymnastics de fenêtre de contexte.

Pièges
  • Les observations stockées sans sources sont indistinguables de la confabulation du modèle plus tard — Exigez que chaque observation inclue une source dans le texte (« source : X, date : Y »); rejetez celles sans
Combiner avec : firecrawl · exa-search · fetch

Combinaisons

Associez-le à d'autres MCPs pour un effet X10

memory + filesystem

Chargez des documents de recherche long-format, extrayez les faits et stockez-les en mémoire pour une synthèse ultérieure

Lisez tous les fichiers .md sous /research/. Pour chaque affirmation clé, ajoutez-la comme observation sur l'entité de sujet pertinente en mémoire. Incluez le nom du fichier comme source.✓ Copié
memory + github

Mémorisez les conventions spécifiques au dépôt afin que les futures révisions de PR les appliquent sans réexplication

À partir des 10 dernières PR fusionnées dans acme/api, extrayez les conventions de ton, de longueur et de titre. Stockez-les comme observations sur l'entité « acme/api ».✓ Copié
memory + sequential-thinking

Permettez aux longues sessions de raisonnement de persister leurs découvertes de brouillon à travers les conversations

Exécutez une session de pensée séquentielle pour planifier notre migration. À la fin, écrivez les conclusions comme observations sur l'entité « db-migration-q2 ».✓ Copié

Outils

Ce que ce MCP expose

OutilEntréesQuand appelerCoût
create_entities entities: [{name, entityType, observations[]}] Introduisez une nouvelle entité (personne, projet, système, concept) gratuit
create_relations relations: [{from, to, relationType}] Connectez deux entités existantes avec une arête typée gratuit
add_observations observations: [{entityName, contents[]}] Ajoutez des faits à une entité existante (opération la plus courante) gratuit
delete_entities entityNames: str[] Supprimez les entités obsolètes (supprime également leurs relations) gratuit
delete_observations deletions: [{entityName, observations[]}] Supprimez les faits spécifiques qui se sont avérés erronés gratuit
delete_relations relations: [...] Supprimez les arêtes sans supprimer les entités gratuit
read_graph none Videz le graphe complet — utilisez avec parcimonie une fois qu'il se développe gratuit
search_nodes query: str Trouvez des entités par mot-clé sur les noms/types/observations gratuit
open_nodes names: str[] Tirez des entités spécifiques par nom exact gratuit

Coût et limites

Coût d'exécution

Quota d'API
Illimité — JSON local
Tokens par appel
Petit — les opérations graphiques retournent uniquement les nœuds modifiés par défaut
Monétaire
Gratuit
Astuce
Préférez search_nodes et open_nodes à read_graph une fois que vous avez plus de 50 entités, sinon vous payerez pour charger le graphe entier à chaque tour.

Sécurité

Permissions, secrets, portée

Stockage des identifiants : Aucune donnée d'identification. Le fichier graphe est ce vers quoi MEMORY_FILE_PATH pointe.
Sortie de données : Aucune sortie de données du serveur. Les observations sont envoyées à votre fournisseur LLM en tant que contexte lorsque Claude les lit.

Dépannage

Erreurs courantes et correctifs

La mémoire ne persiste pas après les redémarrages

Définissez la variable env MEMORY_FILE_PATH sur un chemin absolu comme /Users/you/.claude/memory.json. Sans cela, le serveur utilise un chemin temporaire.

Vérifier : Check your MCP client config for env vars; after restart, call `read_graph` and verify old entities return
Claude ne consulte jamais la mémoire de son propre chef

Le serveur expose les outils ; le modèle a toujours besoin d'une incitation. Ajoutez une instruction au niveau du projet comme « Avant de répondre aux questions sur <projet>, appelez search_nodes pour le contexte pertinent. »

Entités dupliquées comme « Jamie » et « jamie-chen »

Adoptez une convention d'appellation (kebab-case ou full-name). Exécutez périodiquement read_graph et delete_entities sur les doublons après fusion des faits avec add_observations.

La relation échoue avec « entité non trouvée »

Les deux entités de point de terminaison doivent d'abord exister. Créez-les avec create_entities avant create_relations.

Alternatives

Memory vs autres

AlternativeQuand l'utiliserCompromis
Qdrant MCPVous avez besoin de recherche sémantique sur des milliers de notes, pas d'un graphe bien structuréNécessite l'exécution de Qdrant ; excellent pour le rappel flou, mauvais pour les faits structurés explicites
Notion MCPVotre « mémoire » est en réalité une base de connaissances d'équipe partagéeLié au réseau, plus lent, nécessite une clé API — mais les humains peuvent aussi le lire/éditer
Neo4j MCPVous créez un graphe de connaissances sérieux avec des requêtes complexesPlus lourd — nécessite une base de données; excessif pour la mémoire personnelle

Plus

Ressources

📖 Lire le README officiel sur GitHub

🐙 Voir les issues ouvertes

🔍 Parcourir les 400+ serveurs MCP et Skills