SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor

Memmy : mémoire locale partagée pour agents IA sur VPS

Installez Memmy 1.2.2 depuis les sources sur Ubuntu, lancez le service sur 127.0.0.1:18960 et partagez une base SQLite locale entre vos agents IA.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, July 31, 2026.

Ce qu’est Memmy et ce qu’il stocke

Memmy est un hub de mémoire local pour les agents IA, qui s’exécute sur votre propre VPS (virtual private server). Il conserve une base de données SQLite contenant ce que vos agents ont appris, et chaque agent présent sur le serveur lit et écrit dans ce même stockage. Le projet est memmy-agent de MemTensor, sous licence MIT, en version 1.2.401 au 1 novembre 2026 ; Memory est versionné séparément en 2.1.7.

Seule une partie de l’ensemble est utile sur un serveur. Memmy fournit un service de mémoire qui écoute sur http://127.0.0.1:18960, une memmy-memory interface de ligne de commande (CLI) qui communique avec ce service, et un workbench de bureau. Le workbench est uniquement distribué pour macOS et Windows. Sur un VPS Linux, vous exécutez donc le service et la CLI. Cela suffit pour fournir une mémoire partagée à Claude Code, Codex et Cursor.

Memmy répartit ce qu’il stocke en quatre couches. Capture enregistre d’abord un Raw Turn séparé, puis écrit un élément L1 Trace pour chaque étape capturée, notamment les requêtes, les réponses, les appels d’outils et les résultats. L2 Policy est une procédure déduite de traces qui se sont révélées utiles. L3 World Model contient les connaissances stables sur un projet ou un environnement. Skill est une procédure appelable, cristallisée à partir d’une policy. Capture crée les traces L1, les tâches en arrière-plan font évoluer les couches supérieures et les écritures explicites peuvent sélectionner une couche. Si ces distinctions restent abstraites, la mémoire est l’une des étapes avancées de un parcours progressif pour apprendre à créer des agents, et les couches deviennent plus faciles à comprendre après avoir écrit vous-même une simple boucle d’agent et constaté qu’elle oublie tout entre deux exécutions.

Ce que change un hub de mémoire partagé par rapport à une mémoire propre à chaque outil

Aujourd’hui, chaque agent dispose de sa propre mémoire. Claude Code conserve les fichiers d’instructions dans le dépôt. Cursor conserve ses règles dans la base de données de son espace de travail. Codex conserve les journaux de session sous ~/.codex. Chaque stockage appartient à un seul outil. Un fait que vous avez indiqué lundi dans un outil est donc inconnu mardi dans un autre. Vous le payez deux fois : d’abord en tokens pour réexpliquer le même projet, puis en travail incorrect lorsqu’un agent applique une hypothèse que vous avez déjà corrigée ailleurs.

Un hub déplace le stockage hors de l’outil. Memmy lit également les stockages existants. Vous ne partez donc pas d’une base de données vide. Son scanner connaît dix sources intégrées : Claude Code à ~/.claude/projects/**/*.jsonl, Codex à ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode à ~/.local/share/opencode/opencode.db, les fichiers state.vscdb de Cursor, les bases de données SQLite d’OpenClaw sous ~/.openclaw, Hermes sous ~/.hermes, DeepSeek Harness sous ~/.dsh/sessions, WorkBuddy sous ~/.workbuddy/projects, Pi sous ~/.pi/agent/sessions et QwenWork sous ~/.qwenworkcn/projects. Le workbench desktop peut ajouter un autre agent par son nom. Il demande le chemin de son historique uniquement lorsqu’il ne trouve pas lui-même l’agent. Le scanner côté serveur ne propose aucune source personnalisée. Sur un VPS headless, vous obtenez donc les sources intégrées.

Les compteurs d’importation ne correspondront pas, et c’est normal. Le scanner regroupe les messages par source et par conversation, puis écrit une mémoire L1 par tour complet. Un tour est considéré comme complet lorsqu’il contient du contenu utilisateur non vide et se termine par un message assistant non vide. Un tour incomplet ne contribue donc à rien tant qu’une synchronisation ultérieure ne permet pas de le compléter. Les messages sont dédupliqués à l’aide de checkpoints de conversation et d’identifiants de tour stables. Le nombre d’éléments analysés, le nombre de messages importés et le nombre de nouvelles mémoires diffèrent lors d’une même exécution.

Cette section complète la manière dont Claude Code gère le contexte dans une seule session. La gestion du contexte détermine ce qui tient dans une seule fenêtre. Un hub de mémoire détermine ce qui reste après la fermeture de cette fenêtre.

Ce dont vous avez besoin sur le VPS

  • Node.js 22 ou version ultérieure. La documentation de Memmy l’exige, et Ubuntu 24.04 fournit Node 18.
  • git et une toolchain de compilation, car better-sqlite3 est un module natif qui peut être compilé pendant l’installation.
  • De la RAM pour l’installation du workspace root et sa chaîne de compilation frontend.
  • De l’espace disque disponible pour node_modules et la base de données.
sudo apt update
sudo apt install -y git build-essential python3 curl ca-certificates sqlite3
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node --version

node --version doit afficher v22 ou une version ultérieure pour la compilation depuis les sources documentée. Un v18 à cet endroit signifie que l’étape NodeSource n’a pas abouti. La valeur par défaut de engine-strict dans npm est false ; une déclaration d’engine incompatible produit donc normalement un avertissement au lieu d’échouer automatiquement lors de l’installation.

Installer Memmy depuis les sources sur Ubuntu 24.04

git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run memory:build

npm run memory:build compile l’espace de travail @memmy/memory dans Memory/dist. Il construit également AgentSourceCore, le visualiseur de mémoire et les ressources d’intégration nécessaires à cet espace de travail. Vérifiez que le module natif est chargé :

node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"

Si cette ligne renvoie une erreur au lieu d’afficher un résultat, consultez le message pour identifier l’échec du chargement ou de l’initialisation de la base de données. En cas d’incompatibilité du module natif, exécutez npm rebuild better-sqlite3. C’est exactement ce que fait le script de démarrage du projet avant de lancer quoi que ce soit.

Le README décrit bash scripts/dev-start.sh comme une commande de démarrage unique. Ne l’exécutez pas sur un VPS headless. Elle démarre l’interface de bureau Electron et un serveur de développement Vite sur le port 19000, en plus du service de mémoire. Electron a besoin d’un affichage. Sur un serveur sans session graphique, le script se bloque ou se termine.

Les versions récentes incluent également memmy-agent-linux-cli.tar.gz et un install.sh pour Linux x64 et arm64. L’installateur nécessite Node.js 22.23.4+ dans la branche 22.x, 24.22.1+ dans la branche 24.x ou 26.12.1+ dans la branche 26.x, ainsi qu’une session utilisateur systemd. Il refuse les autres versions majeures. Il place les lanceurs memmy et memmy-memory dans ~/.local/bin et démarre le service de mémoire comme unité utilisateur sur 127.0.0.1:18960. Ce guide conserve la compilation depuis les sources, car c’est la méthode qui permet de lire chaque script avant son exécution.

Démarrer le service de mémoire et vérifier qu’il répond

npm run memory:serve:dev

C’est la méthode documentée pour exécuter le service de mémoire depuis les sources. Il s’attache à 127.0.0.1:18960, conserve la base de données dans ~/.memmy/memory-service/memory.sqlite et lit la configuration depuis ~/.memmy/config.yaml. Le serveur accepte les mêmes valeurs sous forme de flags lorsque vous voulez les définir explicitement :

npm run memory:serve:dev -- \
  --host 127.0.0.1 --port 18960 \
  --db ~/.memmy/memory-service/memory.sqlite \
  --config ~/.memmy/config.yaml

Depuis un deuxième shell, demandez au service s’il est actif :

curl -sS http://127.0.0.1:18960/api/v1/health

Le endpoint de health ne demande pas de token, ce qui en fait la bonne sonde. Si curl se termine avec le code 7 et un message Failed to connect to 127.0.0.1 port 18960, la connexion a échoué ; cela ne permet pas à lui seul de déterminer si un listener existe. Vérifiez l’adresse, le port et le firewall local, puis consultez le terminal qui exécute le service pour rechercher les erreurs de démarrage. ss -lntp | grep 18960 confirme la présence du socket une fois le service démarré.

Le reste de l’API HTTP (interface de programmation d’application) se trouve sous /api/v1.

  • POST /api/v1/memory/add écrit une mémoire et POST /api/v1/memory/search effectue des requêtes.
  • GET /api/v1/memory/:id et DELETE /api/v1/memory/:id lisent et suppriment une entrée.
  • POST /api/v1/sessions/open et POST /api/v1/sessions/:sessionId/close encadrent une session d’agent.
  • POST /api/v1/turns/start et POST /api/v1/turns/:turnId/complete enregistrent un tour.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis et /api/v1/panel/items alimentent le dashboard.

Memmy réserve un bloc de ports. En mode headless, vous utilisez uniquement le premier : 18960 pour la mémoire, 18970 pour le health du gateway, 18980 pour l’interface web et l’admin HTTP, 18990 pour l’API compatible OpenAI démarrée par memmy serve, puis 19000 pour le serveur de développement Vite du frontend desktop et 19001 pour son socket de hot reload. La page des ports du projet indique encore 19010 pour le hot reload, mais la configuration Vite utilise 19001. Si quelque chose utilise déjà l’un de ces ports sur votre machine, c’est à cet endroit qu’il faut chercher.

D’où vient réellement la commande memmy-memory

C’est généralement ici que la première installation échoue. Consultez donc le package au lieu de deviner. Le nom de la commande n’a aucun rapport avec le nom du dépôt. Il provient du champ bin de l’espace de travail qui la définit :

node -p "JSON.stringify(require('./Memory/package.json').bin)"

Cette commande affiche {"memmy-memory":"./dist/src/cli/index.js"}. Le point d’entrée compilé est donc Memory/dist/src/cli/index.js. Il n’existe qu’après npm run memory:build, car la compilation crée dist et rend le fichier exécutable. Exécutez-le directement :

node Memory/dist/src/cli/index.js health

Pour utiliser le nom court depuis votre PATH, créez un lien vers ce même fichier :

sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory health

La CLI utilise http://127.0.0.1:18960 par défaut et accepte --url, --token, --config, --source et --user-id. Ses sous-commandes sont init, health, search, add, get et delete. Elle fournit également les appels de session et de tour que les agents utilisent plutôt que les utilisateurs, ainsi que install, upgrade, service et stop pour administrer le service lui-même. memmy-memory search "deploy steps" et memmy-memory add "staging migrates on deploy" sont les deux commandes qu’un agent exécute le plus souvent.

Comment connecter Claude Code à Memmy ?

Memmy ne s’enregistre pas comme serveur dans Claude Code. Il se connecte via les fichiers que Claude Code lit déjà, et son niveau d’intégration dépend du memmy-memory que vous exécutez. Depuis un checkout des sources, memmy-memory init --agent claude écrit une Skill memmy-memory dans ~/.claude/skills/ et un bloc de mémoire balisé dans ~/.claude/CLAUDE.md. Claude Code exécute ensuite memmy-memory comme une commande shell ordinaire lorsque ces instructions le lui demandent. Le launcher que l’installateur Linux place dans ~/.local/bin va plus loin : la même commande enregistre aussi des hooks dans ~/.claude/settings.json pour SessionStart, UserPromptSubmit, Stop, PostCompact et SessionEnd. Ces hooks injectent la mémoire pertinente et enregistrent chaque tour terminé, sans que le modèle ait à décider de le faire.

Écrivez l’instruction à la main une seule fois. Vous saurez ainsi exactement ce qui a été indiqué à l’agent. Claude Code lit CLAUDE.md depuis la racine du projet au début de chaque session. Une section comme celle-ci constitue donc toute l’intégration avec la méthode basée sur les sources :

## Memory

Before starting a task, run `memmy-memory search "<topic>"` and read what comes back.
When a task is done, run `memmy-memory add "<what you learned>"` for anything that will matter next session.

Soyez clair sur ce que cela vous apporte. Sans les hooks, l’intégration reste au niveau des instructions. Elle fonctionne donc lorsque le modèle décide d’exécuter la commande, et pas dans le cas contraire. Rien ne force cet appel. Si une session se termine sans add, l’instruction n’a rien enregistré elle-même. Un scan ultérieur de l’historique peut tout de même importer le tour terminé. C’est le même compromis que les fichiers de mémoire de Claude Code, avec une différence : le store est partagé. La note est donc également accessible à Codex et à Cursor sur la même machine. Les hooks comblent cet écart au lieu de simplement le demander. C’est aussi pourquoi la mémoire persistante figure aux côtés des plafonds de budget et des règles de permissions parmi les plugins DeepSeek Harness à installer.

Dans l’autre sens, aucune configuration n’est nécessaire. Le scanner de Memmy lit déjà ~/.claude/projects/**/*.jsonl, qui contient les transcriptions de session écrites par Claude Code. Exécutez Memmy sur le même serveur que Claude Code dans une session tmux : le travail de la veille devient alors de la mémoire, sans configuration supplémentaire.

Memmy fonctionne-t-il comme serveur MCP pour Claude Code ?

Non. Le savoir permet d’éviter d’y passer l’après-midi. MCP (model context protocol) utilise des clients et des serveurs. Memmy est un client. Il se connecte aux serveurs MCP et met leurs outils à la disposition de son propre agent. Il n’expose pas de endpoint MCP auquel claude mcp add pourrait se connecter. Le seul bridge MCP du dépôt appartient à l’intégration Composio dans l’API locale desktop. Cette API écoute sur un port aléatoire de 127.0.0.1, protégé par son propre en-tête x-memmy-mcp-token.

Le client est configuré dans ~/.memmy/config.yaml, le fichier indiqué par MEMMY_CONFIG, sous tools.mcpServers :

tools:
  mcpServers:
    example:
      type: stdio
      command: npx
      args:
        - "-y"
        - "your-mcp-server"
      toolTimeout: 30
      enabledTools:
        - "*"

type accepte stdio, sse et streamableHttp. Un serveur stdio s’exécute comme processus enfant de Memmy. Sa commande doit donc exister sur la même machine et s’exécuter avec le même utilisateur. Si vous avez déjà des serveurs MCP exécutés sur un VPS, ce sont ceux qu’il faut répertorier ici.

Conserver le stockage mémoire privé

Tout ce que Memmy utilise se trouve sous ~/.memmy : config.yaml, l’espace de travail, memory-service/memory.sqlite et les fichiers d’exécution. L’analyse et l’ingestion s’effectuent localement, et les mémoires sont écrites dans ce fichier SQLite local. Le fonctionnement par défaut est donc réellement local.

La connexion au cloud est un point à surveiller. MEMMY_CLOUD_SERVICE désigne l’origine cloud. Le code ne lui attribue aucune valeur par défaut, mais .env.example, que les étapes d’installation copient vers .env, lui attribue la valeur https://api.memmy.cn. Elle active le mode compte avec ses jetons d’essai. Lorsqu’elle est définie, le code d’analytics de Memmy lui envoie également des événements d’utilisation, y compris en mode clé API : noms des événements et des commandes, versions et identifiant d’installation. La CLI ne transmet que des mots de commande fixes, jamais les requêtes de recherche ni le texte des mémoires. Le code d’analytics n’envoie rien lorsque cette valeur n’est pas définie. Sur un serveur qui utilise uniquement des clés API, videz donc cette ligne dans .env avant de démarrer quoi que ce soit. Le programme d’amélioration des mémoires est un réglage distinct dans les paramètres de confidentialité.

Les appels aux modèles constituent un autre point de sortie. Si vous configurez un fournisseur d’embeddings hébergé, le texte des mémoires à vectoriser est envoyé à ce fournisseur afin d’être converti en vecteur. Le stockage local ne suffit pas à empêcher cette transmission. Utilisez le fournisseur d’embeddings local intégré ou un endpoint d’embeddings que vous hébergez vous-même pour supprimer ce chemin. Les modèles hébergés utilisés pour les résumés, l’évolution et le filtrage par pertinence reçoivent également le contenu des mémoires lorsque ces tâches s’exécutent. Vérifiez donc aussi ces paramètres de modèles.

Conservez le port 18960 sur l’adresse loopback. Aucune règle de firewall n’est nécessaire, car un service lié à 127.0.0.1 n’est pas accessible depuis l’extérieur de la machine. Depuis votre ordinateur portable, utilisez plutôt SSH :

ssh -N -L 18960:127.0.0.1:18960 you@your-vps

Le service mémoire actuel rejette les adresses bind qui ne sont pas des adresses loopback. La définition de storage.token dans la configuration, ou de la variable d’environnement MEMMY_MEMORY_TOKEN ou MEMORY_SERVICE_TOKEN, protège les appels API mémoire ordinaires avec un bearer token. Le endpoint de health check reste sans authentification, et le viewer dans le navigateur utilise des vérifications distinctes pour les requêtes locales. Les valeurs de configuration prennent en charge les références ${ENV_NAME}. Le token et vos clés API de modèles peuvent ainsi rester en dehors du fichier lui-même. C’est la même pratique que garder les secrets hors des agents IA partout ailleurs. Une politique ufw par défaut en deny constitue votre protection de dernier recours si une version ultérieure modifie son adresse bind par défaut.

Sauvegardez ~/.memmy avant de lui faire confiance

memory.sqlite est le store complet. Les vecteurs sont stockés dans ce même fichier grâce à l’extension sqlite-vec, qui constitue donc à elle seule la sauvegarde. Le copier avec cp pendant que le service écrit peut produire une base de données incohérente. Utilisez la commande de sauvegarde intégrée à SQLite :

mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"

Cette commande crée une copie cohérente tandis que le service continue de fonctionner. Envoyez-la régulièrement vers un autre emplacement, par exemple avec restic vers un stockage hors site. La perte de config.yaml vous oblige à ressaisir les paramètres du fournisseur. La perte de memory.sqlite vous fait perdre les souvenirs enregistrés depuis votre dernière sauvegarde utilisable ; le service crée également une sauvegarde locale avant les migrations de schéma, mais celle-ci ne constitue pas une copie hors site à jour.

Exécuter le service Memory avec systemd

npm run memory:serve:dev lancé dans un shell s’arrête avec le shell. Un fichier d’unité maintient le service actif après les redémarrages. Le service s’exécute avec l’utilisateur memmy, depuis un checkout situé dans /opt/memmy, et utilise sa configuration dans le répertoire personnel de cet utilisateur. Arrêtez la copie lancée dans votre shell, puis déplacez le checkout et la configuration et recréez le lien memmy-memory :

sudo useradd -m -s /bin/bash memmy
sudo mkdir -p /opt/memmy
sudo mv ~/memmy-agent /opt/memmy/memmy-agent
sudo chown -R memmy:memmy /opt/memmy
sudo ln -sfn /opt/memmy/memmy-agent/Memory/dist/src/cli/index.js /usr/local/bin/memmy-memory
sudo install -d -o memmy -g memmy -m 700 /home/memmy/.memmy
sudo install -o memmy -g memmy -m 600 ~/.memmy/config.yaml /home/memmy/.memmy/config.yaml
sudo install -d -m 755 /etc/memmy

Le service conserve sa base de données dans /home/memmy/.memmy. Il démarre donc avec un magasin vide.

[Unit]
Description=Memmy memory service
After=network-online.target

[Service]
Type=simple
User=memmy
WorkingDirectory=/opt/memmy/memmy-agent
EnvironmentFile=/etc/memmy/memory.env
ExecStart=/usr/bin/npm run memory:serve:dev
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Ne stockez pas le token dans l’unité. Placez-le dans /etc/memmy/memory.env, avec root comme propriétaire et le mode 600 :

MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-string
sudo systemctl daemon-reload
sudo systemctl enable --now memmy-memory
systemctl status memmy-memory --no-pager
curl -sS http://127.0.0.1:18960/api/v1/health

Dans la sortie de status, status=203/EXEC signifie que systemd n’a pas pu exécuter ExecStart. Vérifiez donc which npm : il se trouve dans /usr/bin/npm avec une installation NodeSource et dans un répertoire situé sous le répertoire personnel de l’utilisateur avec nvm. systemd ne trouvera pas ce dernier. Pour une unité qui démarre puis s’arrête immédiatement, vérifiez le code de sortie et le journal : le code 0 indique une sortie normale, tandis que les autres résultats incluent les sorties avec un code différent de zéro, les signaux et les délais d’expiration. Exécutez journalctl -u memmy-memory -n 50 pour afficher la sortie du service. Le fonctionnement est le même que pour n’importe quel autre service systemd sur un VPS.

Le projet propose désormais deux solutions alternatives au niveau utilisateur. Pour une compilation depuis les sources, le README indique memmy-memory install --service-only. Cette commande télécharge la version épinglée du runtime Memory et enregistre un service utilisateur. L’installateur Linux configure memmy-memory.service comme unité systemd --user. Aucune de ces solutions n’active linger. Exécutez donc sudo loginctl enable-linger <user> pour maintenir le gestionnaire de services de cet utilisateur après sa déconnexion et le démarrer au boot.

Ce que Memmy ne fait pas encore

  • Il n’existe pas encore de build pour le bureau Linux. Les scripts de packaging couvrent macOS et Windows. Le workbench et son assistant de première configuration ne sont donc pas disponibles directement sur le serveur. Le service de mémoire inclut désormais un viewer accessible depuis un navigateur à l’adresse http://127.0.0.1:18960/viewer/, via le tunnel SSH indiqué ci-dessus. Sous Linux, vous disposez à la place d’un tarball CLI et de install.sh.
  • memory:serve:dev exécute le point d’entrée TypeScript via tsx, qui correspond à un chemin de développement. Le dépôt fournit également memory:serve pour la sortie compilée. Exécutez npm run sans argument pour voir quels scripts sont réellement disponibles dans votre checkout.
  • La recherche construit sa fenêtre à partir des 2,000 dernières lignes vectorielles, puis applique la sélection Top-K à l’intérieur de cette fenêtre. Dans un store très volumineux, une mémoire ancienne peut se trouver en dehors de cette fenêtre.
  • La génération des embeddings a lieu après la capture. En cas d’échec, la tâche est placée dans une file de retry au lieu de bloquer le tour de l’agent. Une mémoire ajoutée à l’instant peut donc ne pas être immédiatement trouvable par la recherche vectorielle.
  • Un second serveur utilisant sa propre base SQLite locale possède une mémoire distincte.

La version 1.2.401, au 1 novembre 2026, décrit toujours un jeune projet qui évolue rapidement. Les flags, les chemins et les noms de scripts changent d’une release à l’autre. Consultez le champ bin et la sortie de npm run dans votre propre checkout au lieu de faire confiance à une commande copiée n’importe où, y compris ici.

FAQ

Pourquoi le health check renvoie-t-il « connection refused » ?

Le code de sortie 7 de curl avec Failed to connect to 127.0.0.1 port 18960 indique qu’une connexion a échoué. Il ne permet pas de savoir si Memmy est arrêté, a planté, écoute ailleurs ou est inaccessible. Vérifiez l’adresse et le port, exécutez ss -lntp | grep 18960, puis consultez le terminal ou le journal où le service a été démarré. Si le journal signale une incompatibilité de module natif SQLite, exécutez npm rebuild better-sqlite3. Vérifiez également votre version de Node : la documentation source exige Node 22 ou une version ultérieure, tandis que l’installateur Linux accepte uniquement Node.js 22.23.4+ dans la branche 22.x, 24.22.1+ dans la branche 24.x ou 26.12.1+ dans la branche 26.x.

D’où vient la commande memmy-memory après une compilation depuis les sources ?

Elle provient du champ bin du package de workspace @memmy/memory, et non du nom du dépôt. Exécutez node -p "JSON.stringify(require('./Memory/package.json').bin)" dans le checkout : la commande affiche {"memmy-memory":"./dist/src/cli/index.js"}. Ce fichier n’existe qu’après npm run memory:build, car la compilation crée dist et rend le fichier exécutable. Exécutez-le avec node Memory/dist/src/cli/index.js health, ou créez un lien symbolique vers celui-ci dans /usr/local/bin pour utiliser le nom court.

Puis-je ajouter Memmy à Claude Code avec claude mcp add ?

Non. Memmy est un client MCP, pas un serveur MCP. Il se connecte aux serveurs répertoriés sous tools.mcpServers dans ~/.memmy/config.yaml et met leurs outils à la disposition de son propre runtime. Claude Code accède à Memmy dans l’autre sens, en exécutant le CLI memmy-memory comme commande shell. memmy-memory init --agent claude écrit un Skill et un bloc CLAUDE.md qui lui indiquent quand les utiliser. Le launcher de l’installateur Linux ajoute également des hooks Claude Code qui enregistrent automatiquement les échanges.

L’exécution de Memmy envoie-t-elle mes souvenirs à un service cloud ?

L’analyse et l’ingestion s’exécutent localement, et les souvenirs sont écrits dans ~/.memmy/memory-service/memory.sqlite sur votre propre disque. MEMMY_CLOUD_SERVICE, défini sur https://api.memmy.cn dans .env.example, gère le mode compte et les tokens d’essai, et reçoit des données d’utilisation sans le texte des souvenirs tant que ce paramètre est défini. Videz donc ce paramètre si vous utilisez uniquement des clés API. Le programme d’amélioration de la mémoire dispose d’un bouton de confidentialité distinct. Un modèle d’embeddings hébergé reçoit le texte du souvenir qu’il convertit en vecteur. Utilisez le provider local intégré ou un endpoint que vous exécutez vous-même pour conserver ce traitement en local. Les modèles hébergés de résumé, d’évolution et de filtrage par pertinence reçoivent également le contenu des souvenirs lorsque ces tâches s’exécutent.

Cet article vous a-t-il été utile ?