Memmy installeren op een VPS voor gedeeld AI-geheugen
Gebruik Memmy als lokale geheugenhub voor uw AI-agents op een VPS. Leer hoe u de service op poort 18960 configureert en SQLite inzet voor gedeelde context tussen agents.
Wat Memmy is en wat het opslaat
Memmy is een lokale geheugenhub voor AI-agents die op uw eigen VPS (virtual private server) draait. Het onderhoudt één SQLite-database van wat uw agents hebben geleerd, en elke agent op de server leest en schrijft naar diezelfde opslag. Het project is memmy-agent van MemTensor, uitgebracht onder de MIT-licentie, en bevindt zich op versie 1.2.401 per 1 november 2026; Memory heeft een onafhankelijke versie 2.1.7.
Slechts een deel hiervan is relevant op een server. Memmy levert een memory service die luistert op http://127.0.0.1:18960, een memmy-memory command line interface (CLI) die met die service communiceert, en een desktop workbench. De workbench is alleen verpakt voor macOS en Windows, dus op een Linux VPS draait u de service en de CLI. Dat is voldoende om Claude Code, Codex en Cursor een gedeeld geheugen te geven.
Memmy sorteert wat het opslaat in vier lagen. Capture slaat eerst een afzonderlijke Raw Turn op en schrijft vervolgens één L1 Trace-item voor elke vastgelegde stap, inclusief verzoeken, antwoorden, tool-aanroepen en resultaten. L2 Policy is een procedure die is afgeleid van traces die nuttig bleken. L3 World Model is stabiele kennis over een project of een omgeving. Skill is een aanroepbare procedure die is gekristalliseerd uit een policy. Capture creëert L1-traces, achtergrondtaken ontwikkelen de hogere lagen, en expliciete schrijfacties kunnen een laag selecteren. Als deze onderscheidingen abstract aanvoelen: geheugen is een van de latere fasen in een stapsgewijs pad voor het leren bouwen van agents, en de lagen worden duidelijker zodra u zelf een eenvoudige agent-loop hebt geschreven en hebt gezien hoe deze alles vergeet tussen runs door.
Wat een gedeelde geheugenhub verandert ten opzichte van geheugen per tool
Elke agent gebruikt tegenwoordig zijn eigen geheugen. Claude Code bewaart instructiebestanden in de repository. Cursor houdt regels bij in de workspace-database. Codex slaat sessielogs op onder ~/.codex. Elke opslag hoort bij één tool, waardoor een feit dat u op maandag in de ene tool heeft aangeleerd, op dinsdag onbekend is in de andere. U betaalt daar dubbel voor: eenmaal in tokens die worden verbruikt om hetzelfde project opnieuw uit te leggen, en eenmaal in foutief werk wanneer een agent handelt op basis van een aanname die u elders al heeft gecorrigeerd.
Een hub verplaatst de opslag buiten de tool. Memmy leest ook de bestaande opslaglocaties, zodat u niet met een lege database begint. De scanner kent tien ingebouwde bronnen: Claude Code op ~/.claude/projects/**/*.jsonl, Codex op ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode op ~/.local/share/opencode/opencode.db, de state.vscdb-bestanden van Cursor, de SQLite-databases van OpenClaw onder ~/.openclaw, Hermes onder ~/.hermes, DeepSeek Harness onder ~/.dsh/sessions, WorkBuddy onder ~/.workbuddy/projects, Pi onder ~/.pi/agent/sessions en QwenWork onder ~/.qwenworkcn/projects. De desktop-workbench kan een andere agent op naam toevoegen en vraagt alleen om het geschiedenispad wanneer de agent zelf niet kan worden gevonden. De server-side scanner heeft geen aangepaste bronnen, dus op een headless VPS krijgt u de ingebouwde bronnen.
De importtellers zullen niet overeenkomen, en dat is te verwachten. De scanner groepeert berichten per bron en conversatie en schrijft vervolgens één L1-geheugen per volledige beurt. Een beurt telt als volledig wanneer deze niet-lege gebruikersinhoud bevat en eindigt met een niet-leeg assistentbericht; een onvolledige beurt draagt dus niets bij totdat een latere synchronisatie deze kan voltooien. Berichten worden ontdubbeld met behulp van conversatie-checkpoints en stabiele beurt-ID's. Het aantal gescande berichten, het aantal geïmporteerde berichten en het aantal nieuwe geheugenitems verschillen allemaal tijdens dezelfde run.
Dit is het onderdeel dat aansluit bij hoe Claude Code context beheert binnen één sessie. Contextbeheer bepaalt wat er in één venster past. Een geheugenhub bepaalt wat er overblijft nadat dat venster is gesloten.
Wat u nodig heeft op de VPS
- Node.js 22 of nieuwer. De documentatie van Memmy vereist dit, en Ubuntu 24.04 levert standaard Node 18.
giten een build-toolchain, omdatbetter-sqlite3een native module is die tijdens de installatie gecompileerd kan worden.- Voldoende RAM voor de installatie van de root-workspace en de frontend build-chain.
- Vrije schijfruimte voor
node_modulesen de database.
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 --versionnode --version hoort v22 of hoger weer te geven voor de gedocumenteerde source-build. Een v18 hier betekent dat de NodeSource-stap niet is geslaagd. De engine-strict van npm staat standaard op false, waardoor een incompatibele engine-declaratie doorgaans een waarschuwing geeft in plaats van de installatie automatisch te laten falen.
Memmy installeren vanaf broncode op Ubuntu 24.04
git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run memory:buildnpm run memory:build compileert de @memmy/memory workspace naar Memory/dist. Het bouwt ook AgentSourceCore, de memory viewer en de integratie-assets die nodig zijn voor die workspace. Controleer of de native module is geladen:
node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"Als die regel een foutmelding geeft in plaats van uitvoer, lees dan de foutmelding om het laadprobleem of de mislukte database-initialisatie te identificeren. Bij een mismatch in de native module voert u npm rebuild better-sqlite3 uit; dit is precies wat het startscript van het project zelf doet voordat het iets opstart.
De README documenteert bash scripts/dev-start.sh als een startcommando met één opdracht. Voer dit niet uit op een headless VPS. Het start de Electron desktop-shell en een Vite dev-server op poort 19000 naast de memory service. Omdat Electron een display vereist, zal het script op een server zonder grafische sessie blijven hangen of afsluiten.
Recente releases voegen ook memmy-agent-linux-cli.tar.gz en een install.sh toe voor Linux x64 en arm64. De installer vereist Node.js 22.23.4+ binnen 22.x, 24.22.1+ binnen 24.x, of 26.12.1+ binnen 26.x, plus een systemd-gebruikerssessie; andere hoofdversies worden geweigerd. Het plaatst de memmy en memmy-memory launchers in ~/.local/bin en start de memory service als een user unit op 127.0.0.1:18960. Deze handleiding behoudt de build vanaf broncode omdat dit de methode is waarbij u elk script kunt inzien voordat het wordt uitgevoerd.
Start de memory service en controleer of deze reageert
npm run memory:serve:devDit is de gedocumenteerde manier om de memory service vanuit de broncode uit te voeren. Deze bindt 127.0.0.1:18960, bewaart de database op ~/.memmy/memory-service/memory.sqlite en leest de configuratie uit ~/.memmy/config.yaml. De server accepteert dezelfde waarden als flags wanneer u deze expliciet wilt opgeven:
npm run memory:serve:dev -- \
--host 127.0.0.1 --port 18960 \
--db ~/.memmy/memory-service/memory.sqlite \
--config ~/.memmy/config.yamlVraag vanuit een tweede shell of de service actief is:
curl -sS http://127.0.0.1:18960/api/v1/healthHealth vereist geen token, daarom is dit de juiste probe. Als curl afsluit met code 7 en een Failed to connect to 127.0.0.1 port 18960 melding, is de verbinding mislukt; dat alleen stelt nog niet vast of er een listener bestaat. Controleer het adres, de poort en de lokale firewall, en lees de terminal waarin de service draait voor opstartfouten. ss -lntp | grep 18960 bevestigt de socket zodra de service actief is.
De rest van de HTTP API (application programming interface) bevindt zich onder /api/v1.
POST /api/v1/memory/addschrijft een memory enPOST /api/v1/memory/searchvoert queries uit.GET /api/v1/memory/:idenDELETE /api/v1/memory/:idlezen en verwijderen één item.POST /api/v1/sessions/openenPOST /api/v1/sessions/:sessionId/closeomsluiten een agent-sessie.POST /api/v1/turns/startenPOST /api/v1/turns/:turnId/completeregistreren één beurt.GET /api/v1/panel/overview,/api/v1/panel/analysisen/api/v1/panel/itemsvoeden het dashboard.
Memmy reserveert een blok poorten, en headless gebruikt u alleen de eerste: 18960 voor memory, 18970 voor gateway health, 18980 voor de web UI en admin HTTP, 18990 voor de OpenAI-compatibele API die memmy serve start, vervolgens 19000 voor de Vite dev server van de desktop frontend en 19001 voor de hot reload socket daarvan. De poortenpagina van het project vermeldt nog steeds 19010 voor hot reload, maar de Vite-configuratie stelt 19001 in. Als iets op uw systeem al een van deze poorten bezet, is die lijst de plek om te zoeken.
Waar het memmy-memory commando vandaan komt
Dit is het punt waar een eerste installatie meestal misgaat; lees het daarom vanuit het pakket in plaats van te gokken. De naam van het commando heeft niets te maken met de naam van de repository. Het is afkomstig uit het bin veld van de workspace waarin het wordt gedefinieerd:
node -p "JSON.stringify(require('./Memory/package.json').bin)"Dit print {"memmy-memory":"./dist/src/cli/index.js"}. Het gegenereerde entry point is dus Memory/dist/src/cli/index.js, en dit bestaat pas na npm run memory:build, omdat de build-stap dist aanmaakt en het bestand uitvoerbaar maakt. Voer het direct uit:
node Memory/dist/src/cli/index.js healthWilt u de korte naam in uw PATH hebben, link dan datzelfde bestand:
sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory healthDe CLI gebruikt standaard http://127.0.0.1:18960 en accepteert --url, --token, --config, --source en --user-id. De subcommando's zijn init, health, search, add, get en delete, plus session- en turn-aanroepen die door agents worden gebruikt in plaats van door mensen, en install, upgrade, service en stop voor het beheer van de service zelf. memmy-memory search "deploy steps" en memmy-memory add "staging migrates on deploy" zijn de twee die een agent het meest uitvoert.
Hoe verbindt u Claude Code met Memmy?
Memmy registreert zichzelf niet als server binnen Claude Code. Het maakt verbinding via bestanden die Claude Code al leest, en de reikwijdte hangt af van welke memmy-memory u uitvoert. Vanuit een broncode-checkout schrijft memmy-memory init --agent claude een memmy-memory Skill naar ~/.claude/skills/ en een gemarkeerd geheugenblok naar ~/.claude/CLAUDE.md, waarna Claude Code memmy-memory uitvoert als een gewoon shell-commando wanneer de instructies dat aangeven. De launcher die het Linux-installatieprogramma in ~/.local/bin plaatst, gaat verder: hetzelfde commando registreert ook hooks in ~/.claude/settings.json voor SessionStart, UserPromptSubmit, Stop, PostCompact en SessionEnd, die relevante geheugenfragmenten injecteren en elke voltooide beurt opslaan zonder dat het model daarvoor hoeft te kiezen.
Schrijf de instructie eenmaal handmatig, zodat u precies weet wat er aan de agent is doorgegeven. Claude Code leest CLAUDE.md aan het begin van elke sessie vanuit de project-root, dus een sectie zoals deze vormt de volledige integratie op het bronpad:
## 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.Wees duidelijk over wat dit u oplevert. Zonder de hooks is er sprake van integratie op instructieniveau; het werkt dus alleen wanneer het model besluit het commando uit te voeren, en anders niet. Niets dwingt de aanroep af. Als een sessie eindigt zonder de add, heeft de instructie zelf niets opgeslagen; een latere geschiedenis-scan kan de voltooide beurt echter nog steeds importeren. Dit is dezelfde afweging als bij de eigen geheugenbestanden van Claude Code, met één verschil: de opslag is gedeeld, waardoor de notitie ook Codex en Cursor op dezelfde machine bereikt. Hooks dichten dit gat in plaats van erom te vragen, wat ook de reden is dat duurzaam geheugen naast budgetlimieten en permissieregels tot de DeepSeek Harness-plugins die het installeren waard zijn behoort.
De andere richting vereist helemaal geen configuratie. De scanner van Memmy leest al ~/.claude/projects/**/*.jsonl, de locatie waar Claude Code zijn sessietranscripties schrijft. Voer Memmy uit op dezelfde server waar u Claude Code binnen een tmux-sessie draait en het werk van gisteren wordt geheugen zonder dat u iets hoeft te configureren.
Werkt Memmy als een MCP-server voor Claude Code?
Nee, en het kennen van deze richting bespaart u een middag werk. MCP (model context protocol) kent clients en servers. Memmy is een client. Het maakt verbinding met MCP-servers en stelt hun tools beschikbaar aan zijn eigen agent-runtime. Het publiceert geen MCP-endpoint waar claude mcp add naar kan verwijzen. De enige MCP-bridge in de repository hoort bij de Composio-integratie binnen de lokale desktop-API, en die API bindt een willekeurige poort op 127.0.0.1 achter zijn eigen x-memmy-mcp-token-header.
De client-zijde wordt geconfigureerd in ~/.memmy/config.yaml, het bestand waar MEMMY_CONFIG naar verwijst, onder tools.mcpServers:
tools:
mcpServers:
example:
type: stdio
command: npx
args:
- "-y"
- "your-mcp-server"
toolTimeout: 30
enabledTools:
- "*"type accepteert stdio, sse en streamableHttp. Een stdio-server draait als een onderliggend proces van Memmy, wat betekent dat het commando op dezelfde machine moet bestaan en onder dezelfde gebruiker moet draaien. Als u al MCP-servers op een VPS laat draaien, zijn dat de servers die u hier moet opgeven.
De geheugenopslag privé houden
Alles wat Memmy bezit, bevindt zich onder ~/.memmy: config.yaml, de werkruimte, memory-service/memory.sqlite en runtime-bestanden. Scannen en opname gebeuren lokaal en herinneringen worden naar dat lokale SQLite-bestand geschreven, dus de standaardinstelling is daadwerkelijk lokaal.
De cloudverbinding is een pad om in de gaten te houden. MEMMY_CLOUD_SERVICE benoemt de cloud-oorsprong. De code stelt hiervoor geen standaardwaarde in, maar .env.example, dat tijdens de installatiestappen naar .env wordt gekopieerd, stelt deze in op https://api.memmy.cn. Dit ondersteunt de accountmodus met proeftokens, en wanneer dit is ingesteld, verstuurt de analysecode van Memmy ook gebruiksgebeurtenissen naar deze locatie, ook in de API-sleutelmodus: gebeurtenis- en opdrachtnamen, versies en een installatie-ID. De CLI rapporteert alleen vaste opdrachtwoorden, nooit zoekopdrachten of geheugentekst, en de analysecode verstuurt niets wanneer de waarde niet is ingesteld. Maak daarom op een server die alleen API-sleutels gebruikt, die regel in .env leeg voordat u met iets begint. Het programma voor geheugenverbetering is een afzonderlijke schakelaar in de privacyinstellingen.
Modelaanroepen vormen een ander pad. Als u een gehoste embedding-provider configureert, wordt de geheugentekst die wordt ge-embed naar die provider verzonden zodat deze kan worden omgezet in een vector. Lokale opslag helpt daar niet. Gebruik de ingebouwde lokale embedding-provider of een embedding-endpoint dat u zelf host om dat pad af te sluiten. Gehoste modellen voor samenvatting, evolutie en relevantiefiltering ontvangen ook geheugeninhoud wanneer die taken worden uitgevoerd, dus controleer ook die modelinstellingen.
Houd poort 18960 op het loopback-adres. Hiervoor is geen firewallregel nodig, omdat een service die is gebonden aan 127.0.0.1 vanaf buiten de server helemaal niet bereikbaar is. Benader deze in plaats daarvan vanaf uw laptop via SSH:
ssh -N -L 18960:127.0.0.1:18960 you@your-vpsDe huidige geheugenservice weigert bind-adressen die geen loopback zijn. Het instellen van storage.token in de configuratie, of de omgevingsvariabele MEMMY_MEMORY_TOKEN of MEMORY_SERVICE_TOKEN, beveiligt gewone geheugen-API-aanroepen met een bearer-token; de statuscontrole blijft ongeauthenticeerd en de browser-viewer gebruikt afzonderlijke controles voor lokale verzoeken. Configuratie-waarden ondersteunen ${ENV_NAME}-verwijzingen, zodat het token en uw model-API-sleutels buiten het bestand zelf blijven. Dat is dezelfde gewoonte als geheimen buiten AI-agents houden overal elders, en een standaard deny ufw-beleid is uw vangnet als een toekomstige versie het standaard bind-adres wijzigt.
Maak een back-up van ~/.memmy voordat u deze vertrouwt
memory.sqlite is de volledige opslag. De vectoren bevinden zich in hetzelfde bestand via de sqlite-vec-extensie, dus één bestand vormt de back-up. Het kopiëren hiervan met cp terwijl de service schrijft, kan leiden tot een corrupte database. Gebruik het ingebouwde back-upcommando van SQLite:
mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"Dit genereert een consistente kopie terwijl de service actief blijft. Verplaats deze kopie volgens een vast schema naar een externe locatie; dit is waar restic naar externe opslag voor bedoeld is. Het verlies van config.yaml kost u providerinstellingen die u opnieuw kunt invoeren. Het verlies van memory.sqlite kost u herinneringen die zijn vastgelegd sinds uw laatste bruikbare back-up; de service maakt ook een lokale back-up vóór schema-migraties, maar dit is geen actuele externe kopie.
De memory service uitvoeren onder systemd
npm run memory:serve:dev in een shell stopt zodra de shell wordt afgesloten. Een unit-bestand houdt de service actief na een reboot. De service draait als een memmy-gebruiker, vanuit een checkout in /opt/memmy, met de configuratie in de home-directory van die gebruiker. Stop het proces dat in uw shell draait, verplaats de checkout en de configuratie, en pas de memmy-memory-link aan:
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/memmyDe service bewaart de database onder /home/memmy/.memmy, waardoor deze met een lege opslag start.
[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.targetHoud de token buiten het unit-bestand. Plaats deze in /etc/memmy/memory.env, met root als eigenaar en modus 600:
MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-stringsudo 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/healthstatus=203/EXEC in de statusuitvoer betekent dat systemd ExecStart in het geheel niet kon uitvoeren. Controleer daarom which npm: dit is /usr/bin/npm bij een NodeSource-installatie en een pad onder de home-directory van de gebruiker bij nvm, wat systemd niet zal vinden. Een unit die direct na het starten afsluit, vereist controle van de exit-status en de journal: code 0 is een correcte afsluiting, terwijl andere resultaten non-zero exitcodes, signalen en timeouts kunnen bevatten. Voer journalctl -u memmy-memory -n 50 uit voor de uitvoer van de service. De werking is identiek aan elke andere systemd-service op een VPS.
Het project biedt nu twee alternatieven op gebruikersniveau. De route in de README voor een source-build is memmy-memory install --service-only, die de vastgelegde Memory-runtime downloadt en een gebruikersservice registreert. De Linux-installer stelt memmy-memory.service in als een systemd --user-unit. Geen van beide schakelt linger in, dus voer sudo loginctl enable-linger <user> uit om de service manager van die gebruiker actief te houden na het uitloggen en deze bij het opstarten te laden.
Wat Memmy nog niet doet
- Er is geen Linux desktop-build. De packaging-scripts dekken macOS en Windows, waardoor de workbench en de onboarding-wizard niet beschikbaar zijn op de server zelf. De memory-service bevat nu een browser-viewer op
http://127.0.0.1:18960/viewer/, bereikbaar via de bovenstaande SSH-tunnel. Linux krijgt in plaats daarvan een CLI-tarball eninstall.sh. memory:serve:devvoert het TypeScript-entrypoint uit viatsx, een ontwikkelpad. De repository levert ookmemory:servevoor gecompileerde output. Voernpm runuit zonder argumenten om te zien welke scripts uw checkout daadwerkelijk bevat.- Retrieval bouwt zijn zoekvenster op uit de laatste 2.000 vector-rijen en past vervolgens Top-K-selectie toe binnen dat venster. In een zeer grote opslag kan een oud geheugen buiten dit bereik vallen.
- Embedding vindt plaats na capture; een fout leidt tot een retry-wachtrij in plaats van het blokkeren van de beurt van de agent. Een geheugen dat zojuist is toegevoegd, is mogelijk nog niet vindbaar via vector-zoekopdrachten.
- Een tweede server met een eigen lokale SQLite-database heeft een afzonderlijk geheugen.
Versie 1.2.401 van 1 november 2026 beschrijft nog steeds een jong project dat zich snel ontwikkelt. Flags, paden en scriptnamen wijzigen tussen releases. Lees het bin-veld en de output van npm run in uw eigen checkout in plaats van te vertrouwen op een commando dat elders is gekopieerd, inclusief hier.
FAQ
Waarom geeft de health check 'connection refused' terug?
Een curl exitcode 7 met Failed to connect to 127.0.0.1 port 18960 duidt op een mislukte verbinding. Dit zegt niets over of Memmy is gestopt, gecrasht, op een andere poort luistert of onbereikbaar is. Controleer het adres en de poort, voer ss -lntp | grep 18960 uit en lees de terminal of journal waar de service is gestart. Als het logboek een mismatch met de native SQLite-module rapporteert, voer dan npm rebuild better-sqlite3 uit. Controleer ook uw Node-versie: de brondocumentatie vereist Node 22 of nieuwer, terwijl de Linux-installer alleen Node.js 22.23.4+ binnen 22.x, 24.22.1+ binnen 24.x, of 26.12.1+ binnen 26.x accepteert.
Waar komt het memmy-memory-commando vandaan na het bouwen vanuit de broncode?
Dit komt uit het bin-veld van het @memmy/memory-werkruimtepakket, niet uit de naam van de repository. Voer node -p "JSON.stringify(require('./Memory/package.json').bin)" uit binnen de checkout en het print {"memmy-memory":"./dist/src/cli/index.js"}. Dat bestand bestaat pas na npm run memory:build, omdat het buildproces dist aanmaakt en het bestand als uitvoerbaar markeert. Voer het uit als node Memory/dist/src/cli/index.js health, of maak een symlink naar /usr/local/bin voor de korte naam.
Kan ik Memmy toevoegen aan Claude Code met claude mcp add?
Nee. Memmy is een MCP-client, geen MCP-server. Het maakt verbinding met servers die onder tools.mcpServers in ~/.memmy/config.yaml staan en stelt hun tools beschikbaar aan de eigen runtime. Claude Code bereikt Memmy andersom, door de memmy-memory CLI als shell-commando uit te voeren. memmy-memory init --agent claude schrijft een Skill en een CLAUDE.md-blok die aangeven wanneer dit moet gebeuren, en de launcher van de Linux-installer voegt ook Claude Code-hooks toe die beurten automatisch opslaan.
Verstuurt het draaien van Memmy mijn herinneringen naar een cloudservice?
Scannen en verwerken gebeuren lokaal en herinneringen worden naar ~/.memmy/memory-service/memory.sqlite op uw eigen schijf geschreven. MEMMY_CLOUD_SERVICE, ingesteld op https://api.memmy.cn in .env.example, bedient de accountmodus en proeftokens en ontvangt gebruiksstatistieken zonder de tekst van de herinneringen zolang dit is ingesteld; maak dit leeg als u alleen API-sleutels gebruikt. Het programma voor geheugenverbetering heeft een aparte privacy-schakelaar. Een gehost embedding-model ontvangt de tekst van de herinnering die het omzet in een vector; gebruik de ingebouwde lokale provider of een endpoint dat u zelf beheert om die verwerking lokaal te houden. Gehoste modellen voor samenvattingen, evolutie en relevantiefilters ontvangen ook de inhoud van herinneringen wanneer die taken worden uitgevoerd.