Memstate AI MCP Server

Memstate AI - MCP

Mémoire versionnée pour agents IA. Stockez des faits, détectez les conflits et suivez l’évolution des décisions dans le temps — exposé via un serveur MCP hébergé.

Tableau de bord · Documentation · Tarifs

---

Pourquoi Memstate ?

	RAG (la plupart des autres systèmes de mémoire)	Memstate AI
Utilisation de tokens par conversation	~7 500	~1 500
Visibilité pour l’agent	Boîte noire	Transparence totale
Versionnement de la mémoire	Aucun	Historique complet
Croissance des tokens avec la mémoire	O(n)	O(1)
Infrastructure requise	Oui	Aucune — SaaS hébergé

Les autres systèmes de mémoire déversent tout dans votre fenêtre de contexte en espérant que cela fonctionne. Memstate offre à votre agent une base de connaissances structurée et versionnée qu’il parcourt avec précision — chargez uniquement ce dont vous avez besoin, sachez ce qui a changé, sachez quand des faits entrent en conflit.

---

Benchmarks

Nous avons construit une suite de benchmarks open-source qui teste ce qui compte vraiment pour la mémoire d’un agent : votre système peut-il stocker des faits, les rappeler avec précision d’une session à l’autre, détecter les conflits lorsque les choses changent et maintenir le contexte à mesure qu’un projet évolue ?

Comparaison directe : Memstate AI vs Mem0

Les deux systèmes ont été testés dans des conditions identiques avec le même agent (Claude Sonnet 4.6, température 0), les mêmes scénarios et la même grille de notation.

Métrique	Memstate AI	Mem0	Vainqueur
Score global	69,1	15,4	Memstate
Précision (rappel des faits)	74,1	12,6	Memstate
Détection des conflits	85,5	19,0	Memstate
Continuité du contexte	63,7	10,1	Memstate
Efficacité des tokens	22,3	30,6	Mem0

Pondération des scores : Précision 40 %, Détection des conflits 25 %, Continuité du contexte 25 %, Efficacité des tokens 10 %.

Détail par scénario

Le benchmark exécute cinq scénarios réalistes qui simulent des flux de travail d’agent multi-sessions :

Scénario	Memstate AI	Mem0
Évolution de l’architecture d’une application web	43,2	55,6
Migration d’un système d’authentification	66,2	10,2
Évolution du schéma de base de données	72,7	7,0
Conflits de versionnement d’API	86,5	0,9
Revirement de décision d’équipe	77,2	3,3

Mem0 a remporté le premier scénario (suivi d’architecture simple), mais a sévèrement peiné sur les scénarios nécessitant la gestion des contradictions, le contexte inter-sessions et le suivi des revirements de décision — obtenant un score proche de zéro sur trois des cinq scénarios.

Pourquoi Memstate gagne

Le benchmark révèle une différence architecturale fondamentale :

Mem0 utilise une recherche sémantique basée sur les embeddings. Les faits sont découpés, vectorisés et récupérés par similarité. Cela fonctionne pour des recherches simples mais échoue lorsque :

• Des faits contredisent des faits antérieurs (le système ne peut pas distinguer le courant de l’obsolète)
• Un rappel précis est nécessaire (les embeddings renvoient des résultats « similaires », pas exacts)
• La latence d’écriture-lecture importe (les nouveaux souvenirs mettent plusieurs secondes à devenir consultables)

Memstate utilise un stockage clé-valeur structuré et versionné. Chaque fait réside à un chemin de clé explicite avec un historique complet des versions. Cela signifie :

• La détection des conflits est intégrée — lorsqu’un nouveau fait en contredit un ancien, le système le sait et conserve les deux versions
• Le rappel est déterministe — vous récupérez exactement ce qui a été stocké, pas une correspondance approximative
• La continuité inter-sessions est fiable — l’agent navigue dans une arborescence structurée plutôt que d’espérer que la recherche sémantique fasse remonter le bon contexte
• Le coût en tokens reste O(1) — l’agent charge d’abord des résumés et n’approfondit les détails que si nécessaire, au lieu de déverser tous les embeddings potentiellement pertinents dans la fenêtre de contexte

Notes sur l’équité

• Les deux systèmes ont utilisé le même modèle d’agent, la même température et la même grille d’évaluation
• Mem0 a bénéficié d’un délai d’ingestion de 10 secondes entre les écritures et les lectures pour tenir compte de son pipeline d’embedding asynchrone
• Mem0 obtient un score plus élevé en efficacité des tokens, mais cette métrique doit être lue en contexte — une utilisation moindre de tokens peut simplement refléter le fait que moins d’informations sont renvoyées. Un système qui récupère des faits incomplets ou incorrects utilise moins de tokens par réponse mais peut nécessiter plus d’appels de suivi, coûtant finalement plus de tokens pour arriver à la même réponse
• Le code source du benchmark est inclus dans ce dépôt pour une reproductibilité totale
• Mem0 peut se comporter différemment avec une configuration personnalisée ou un modèle d’embedding différent

---

Démarrage rapide

Obtenez votre clé API sur memstate.ai/dashboard, puis ajoutez-la à la configuration de votre client MCP :

{
  "mcpServers": {
    "memstate": {
      "command": "npx",
      "args": ["-y", "@memstate/mcp"],
      "env": {
        "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Pas de Docker. Pas de base de données. Pas d’infrastructure. Opérationnel en 60 secondes.

---

Configuration du client

Claude Desktop

Emplacement de la configuration :

• macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows : %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "memstate": {
      "command": "npx",
      "args": ["-y", "@memstate/mcp"],
      "env": { "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE" }
    }
  }
}

Claude Code

claude mcp add memstate npx @memstate/mcp -e MEMSTATE_API_KEY=YOUR_API_KEY_HERE

Cursor

Dans Paramètres Cursor → MCP → Ajouter un serveur — même format JSON que pour Claude Desktop ci-dessus.

Cline / Windsurf / Kilo Code / Roo Code

Tous prennent en charge le même format de configuration MCP stdio. Ajoutez-le au fichier de paramètres MCP de votre client.

---

Outils principaux

Outil	Quand l’utiliser
memstate_remember	Stocker du markdown, des résumés de tâches, des décisions. Le serveur extrait automatiquement les chemins de clé et détecte les conflits. À utiliser pour la plupart des écritures.
memstate_set	Définir un chemin de clé unique sur une valeur courte (ex. config.port = 8080). Pas pour du texte long.
memstate_get	Parcourir tous les souvenirs d’un projet ou d’une sous-arborescence. À utiliser au début de chaque tâche.
memstate_search	Recherche sémantique par sens lorsque vous ne connaissez pas le chemin de clé exact.
memstate_history	Voir comment une connaissance a évolué au fil du temps — chaîne de versions complète.
memstate_delete	Supprimer logiquement un chemin de clé. Crée une pierre tombale ; l’historique complet est préservé.
memstate_delete_project	Supprimer logiquement un projet entier et tous ses souvenirs.

Comment fonctionnent les chemins de clé

Les souvenirs sont organisés en notation pointée hiérarchique :

project.my_app.database.schema
project.my_app.auth.provider
project.my_app.deploy.environment

Les chemins de clé sont auto-préfixés : keypath="database" avec project_id="my_app" → project.my_app.database. Votre agent peut accéder précisément à ce dont il a besoin — pas de déversement complet du contexte.

---

Comment ça marche

Agent: memstate_remember(project_id="my_app", content="## Auth\nUsing SuperTokens...")
         ↓
Server extracts keypaths:  [project.my_app.auth.provider, ...]
         ↓
Conflict detection:  compare against existing memories at those keypaths
         ↓
New version stored — old version preserved in history chain
         ↓
Next session: memstate_get(project_id="my_app") → structured summaries only
         ↓
Agent drills into project.my_app.auth only when it needs auth details

Le coût en tokens reste constant, quel que soit le nombre total de souvenirs existants.

---

Ajouter aux instructions de votre agent

Copiez dans votre AGENTS.md ou invite système :

## Memory (Memstate MCP)

### Before each task
- memstate_get(project_id="my_project") — browse existing knowledge
- memstate_search(query="topic", project_id="my_project") — find by meaning

### After each task
- memstate_remember(project_id="my_project", content="## Summary\n- ...", source="agent")

### Tool guide
- memstate_remember — markdown summaries, decisions, task results (preferred)
- memstate_set — single short values only (config flags, status)
- memstate_get — browse/retrieve before tasks
- memstate_search — semantic lookup when keypath unknown
- memstate_history — audit how knowledge evolved
- memstate_delete — remove outdated memories (history preserved)

---

Variables d’environnement

Variable	Valeur par défaut	Description
MEMSTATE_API_KEY	(requis)	Clé API depuis memstate.ai/dashboard
MEMSTATE_MCP_URL	https://mcp.memstate.ai	Surcharge pour les déploiements auto-hébergés

Vérifier votre connexion

MEMSTATE_API_KEY=your_key npx @memstate/mcp --test

Affiche tous les outils disponibles et confirme que votre clé API fonctionne.

Conçu pour les agents IA qui méritent de savoir ce qu’ils savent.