Memmy: Gemeinsamer Speicher für KI-Agenten auf dem VPS

Was Memmy ist und welche Daten es speichert

Memmy ist ein lokaler Memory-Hub für KI-Agenten, der auf Ihrem eigenen VPS (virtual private server) läuft. Es verwaltet eine SQLite-Datenbank mit dem Wissen, das Ihre Agenten erworben haben. Jeder Agent auf diesem System liest und schreibt in denselben Speicher. Das Projekt wird von memmy-agent von MemTensor veröffentlicht und steht unter der MIT-Lizenz. Zum 1. November 2026 hat es die Version 1.2.401; Memory wird unabhängig davon in Version 2.1.7 versioniert.

Für einen Server ist nur ein Teil davon relevant. Memmy stellt einen Memory-Dienst bereit, der auf http://127.0.0.1:18960 lauscht, eine memmy-memory-Befehlszeilenschnittstelle (CLI), die mit diesem Dienst kommuniziert, sowie eine Desktop-Arbeitsumgebung. Die Arbeitsumgebung ist nur für macOS und Windows paketiert. Auf einem Linux-VPS führen Sie daher den Dienst und die CLI aus. Damit erhalten Claude Code, Codex und Cursor einen gemeinsamen Speicher.

Memmy ordnet die gespeicherten Daten vier Ebenen zu. Capture speichert zunächst einen separaten Raw Turn. Anschließend schreibt es für jeden erfassten Schritt ein L1-Trace-Element, darunter Anfragen, Antworten, Tool-Aufrufe und Ergebnisse. L2 Policy ist eine aus Traces abgeleitete Prozedur, deren Nutzen sich bestätigt hat. L3 World Model enthält stabiles Wissen über ein Projekt oder eine Umgebung. Skill ist eine aufrufbare Prozedur, die aus einer Policy herausgebildet wurde. Capture erstellt L1-Traces. Hintergrundaufgaben entwickeln die höheren Ebenen weiter. Explizite Schreibvorgänge können eine Ebene auswählen. Falls diese Unterscheidungen abstrakt wirken, ist Memory eine der späteren Stufen in einem schrittweisen Lernpfad zum Erstellen von Agenten. Die Ebenen werden verständlicher, sobald Sie selbst eine einfache Agentenschleife geschrieben und beobachtet haben, dass sie zwischen den Ausführungen alles vergisst.

Was ein gemeinsamer Memory-Hub im Vergleich zu einem eigenen Speicher pro Tool ändert

Jeder Agent verfügt heute über einen eigenen Speicher. Claude Code legt Anweisungsdateien im Repository ab. Cursor speichert Regeln in seiner Workspace-Datenbank. Codex legt Sitzungsprotokolle unter ~/.codex ab. Jeder Speicher gehört zu genau einem Tool. Eine Information, die Sie einem Tool am Montag beigebracht haben, ist daher am Dienstag in einem anderen Tool unbekannt. Das kostet Sie doppelt: einmal in Form von Tokens, die Sie für die erneute Erklärung desselben Projekts aufwenden, und einmal durch falsche Arbeit, wenn ein Agent auf einer Annahme basiert, die Sie an anderer Stelle bereits korrigiert haben.

Ein Hub verlagert den Speicher aus dem Tool heraus. Memmy liest außerdem die vorhandenen Speicher ein, sodass Sie nicht mit einer leeren Datenbank beginnen. Der Scanner kennt zehn integrierte Quellen: Claude Code unter ~/.claude/projects/**/*.jsonl, Codex unter ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode unter ~/.local/share/opencode/opencode.db, die state.vscdb-Dateien von Cursor, die SQLite-Datenbanken von OpenClaw unter ~/.openclaw, Hermes unter ~/.hermes, DeepSeek Harness unter ~/.dsh/sessions, WorkBuddy unter ~/.workbuddy/projects, Pi unter ~/.pi/agent/sessions und QwenWork unter ~/.qwenworkcn/projects. Die Desktop-Arbeitsumgebung kann einen weiteren Agenten anhand seines Namens hinzufügen. Sie fragt erst dann nach dem Pfad zu dessen Verlauf, wenn sie den Agenten nicht selbst findet. Der serverseitige Scanner unterstützt keine benutzerdefinierten Quellen. Auf einem Headless-VPS erhalten Sie daher nur die integrierten Quellen.

Die Importzähler werden nicht übereinstimmen. Das ist erwartbar. Der Scanner gruppiert Nachrichten nach Quelle und Konversation und schreibt anschließend pro vollständigem Durchlauf eine L1-Memory. Ein Durchlauf gilt als vollständig, wenn er nicht leeren Benutzerinhalt enthält und mit einer nicht leeren Assistentenantwort endet. Ein unvollständiger Durchlauf trägt daher nichts bei, bis ein späterer Sync ihn vervollständigen kann. Nachrichten werden anhand von Konversations-Checkpoints und stabilen Turn-IDs dedupliziert. Die Anzahl der gescannten Nachrichten, die Anzahl der importierten Nachrichten und die Anzahl der neuen Memories unterscheiden sich daher im selben Lauf.

Dieser Abschnitt gehört zu wie Claude Code den Kontext innerhalb einer Sitzung verwaltet. Die Kontextverwaltung entscheidet, was in ein einzelnes Kontextfenster passt. Ein Memory-Hub entscheidet, was nach dem Schließen dieses Fensters erhalten bleibt.

Voraussetzungen für den VPS

• Node.js 22 oder neuer. Die Memmy-Dokumentation verlangt diese Version, und Ubuntu 24.04 enthält Node 18.
• git und eine Build-Toolchain, weil better-sqlite3 ein natives Modul ist, das während der Installation kompiliert werden kann.
• RAM für die Installation im Root-Arbeitsverzeichnis und die zugehörige Frontend-Build-Toolchain.
• Freier Speicherplatz für node_modules und die Datenbank.

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 sollte für den dokumentierten Build aus dem Quellcode v22 oder höher ausgeben. Ein v18 an dieser Stelle bedeutet, dass der NodeSource-Schritt nicht erfolgreich war. npm's engine-strict ist standardmäßig auf false gesetzt. Eine inkompatible Engine-Deklaration erzeugt daher normalerweise eine Warnung, anstatt die Installation automatisch fehlschlagen zu lassen.

Memmy aus dem Quellcode unter Ubuntu 24.04 installieren

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 kompiliert den @memmy/memory-Workspace zu Memory/dist. Außerdem werden AgentSourceCore, der Memory Viewer und die für diesen Workspace benötigten Integrationsdateien erstellt. Prüfen Sie, ob das native Modul geladen wurde:

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

Wenn diese Zeile einen Fehler ausgibt, statt etwas zu drucken, lesen Sie die Fehlermeldung, um den Fehler beim Laden oder bei der Datenbankinitialisierung zu bestimmen. Bei einer Inkompatibilität des nativen Moduls führen Sie npm rebuild better-sqlite3 aus. Genau das macht auch das Startskript des Projekts, bevor es etwas startet.

Die README beschreibt bash scripts/dev-start.sh als Start mit einem einzigen Befehl. Führen Sie den Befehl nicht auf einem Headless-VPS aus. Er startet neben dem Memory Service die Electron-Desktop-Shell und einen Vite-Dev-Server auf Port 19000. Electron benötigt eine grafische Anzeige. Auf einem Server ohne grafische Sitzung bleibt das Skript daher hängen oder wird beendet.

Aktuelle Releases enthalten außerdem memmy-agent-linux-cli.tar.gz und ein install.sh für Linux x64 und arm64. Das Installationsprogramm benötigt Node.js 22.23.4+ innerhalb von 22.x, 24.22.1+ innerhalb von 24.x oder 26.12.1+ innerhalb von 26.x sowie eine systemd-Benutzersitzung. Andere Hauptversionen werden abgelehnt. Die Startprogramme memmy und memmy-memory werden in ~/.local/bin abgelegt. Der Memory Service wird als Benutzereinheit auf 127.0.0.1:18960 gestartet. Diese Anleitung verwendet weiterhin den Build aus dem Quellcode, weil Sie dabei jedes Skript vor der Ausführung lesen können.

Speicherdienst starten und prüfen, ob er antwortet

npm run memory:serve:dev

Das ist die dokumentierte Methode, um den Speicherdienst aus dem Quellcode zu starten. Er bindet an 127.0.0.1:18960, speichert die Datenbank unter ~/.memmy/memory-service/memory.sqlite und liest die Konfiguration aus ~/.memmy/config.yaml. Der Server akzeptiert dieselben Werte als Flags, wenn Sie sie explizit angeben möchten:

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

Fragen Sie in einer zweiten Shell ab, ob der Dienst aktiv ist:

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

Für die Health-Prüfung ist kein Token erforderlich. Deshalb eignet sie sich als Probe. Wenn curl mit dem Code 7 und einer Failed to connect to 127.0.0.1 port 18960-Meldung beendet wird, ist die Verbindung fehlgeschlagen. Daraus lässt sich allein jedoch nicht ableiten, ob ein Listener vorhanden ist. Prüfen Sie Adresse, Port und die lokale Firewall. Lesen Sie außerdem das Terminal, in dem der Dienst läuft, auf Startfehler durch. ss -lntp | grep 18960 bestätigt den Socket, sobald der Dienst aktiv ist.

Der restliche HTTP-API-Teil (Application Programming Interface) befindet sich unter /api/v1.

• POST /api/v1/memory/add schreibt eine Erinnerung, und POST /api/v1/memory/search fragt Erinnerungen ab.
• GET /api/v1/memory/:id und DELETE /api/v1/memory/:id lesen einen Eintrag und entfernen ihn.
• POST /api/v1/sessions/open und POST /api/v1/sessions/:sessionId/close begrenzen eine Agent-Sitzung.
• POST /api/v1/turns/start und POST /api/v1/turns/:turnId/complete erfassen einen einzelnen Turn.
• GET /api/v1/panel/overview, /api/v1/panel/analysis und /api/v1/panel/items versorgen das Dashboard.

Memmy reserviert einen Portblock. Im Headless-Betrieb verwenden Sie nur den ersten Port: 18960 für den Speicher, 18970 für den Gateway-Health-Endpunkt, 18980 für die Weboberfläche und die Admin-HTTP-Schnittstelle, 18990 für die OpenAI-kompatible API, die memmy serve startet, danach 19000 für den Vite-Entwicklungsserver des Desktop-Frontends und 19001 für dessen Hot-Reload-Socket. Auf der Port-Seite des Projekts ist für Hot Reload weiterhin 19010 aufgeführt, aber die Vite-Konfiguration setzt 19001. Wenn auf Ihrem System bereits etwas einen dieser Ports belegt, finden Sie dort den richtigen Ausgangspunkt für die Suche.

Woher der Befehl memmy-memory tatsächlich stammt

Hier geht die erste Installation meist schief. Lesen Sie die Information daher direkt aus dem Paket ab, statt sie zu erraten. Der Befehlsname hat nichts mit dem Repository-Namen zu tun. Er stammt aus dem Feld bin des Workspace, in dem der Befehl definiert ist:

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

Damit wird {"memmy-memory":"./dist/src/cli/index.js"} ausgegeben. Der erzeugte Einstiegspunkt ist also Memory/dist/src/cli/index.js. Er ist erst nach npm run memory:build vorhanden, weil der Build dist erstellt und die Datei als ausführbar markiert. Führen Sie ihn direkt aus:

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

Wenn Sie den kurzen Namen in Ihrem PATH verwenden möchten, verknüpfen Sie dieselbe Datei:

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

Die CLI verwendet standardmäßig http://127.0.0.1:18960 und akzeptiert --url, --token, --config, --source und --user-id. Ihre Unterbefehle sind init, health, search, add, get und delete. Hinzu kommen Session- und Turn-Aufrufe, die Agents statt Benutzer verwenden, sowie install, upgrade, service und stop zur Verwaltung des Dienstes selbst. memmy-memory search "deploy steps" und memmy-memory add "staging migrates on deploy" führt ein Agent am häufigsten aus.

Wie verbinden Sie Claude Code mit Memmy?

Memmy registriert sich nicht selbst als Server in Claude Code. Die Verbindung erfolgt über Dateien, die Claude Code bereits liest. Wie weit die Integration reicht, hängt davon ab, welchen memmy-memory Sie verwenden. In einem ausgecheckten Quellcode-Repository schreibt memmy-memory init --agent claude ein memmy-memory Skill nach ~/.claude/skills/ und einen markierten Speicherblock nach ~/.claude/CLAUDE.md. Claude Code führt memmy-memory anschließend als normalen Shell-Befehl aus, wenn diese Anweisungen dies vorgeben. Der Launcher, den das Linux-Installationsprogramm in ~/.local/bin ablegt, geht weiter: Derselbe Befehl registriert zusätzlich Hooks in ~/.claude/settings.json für SessionStart, UserPromptSubmit, Stop, PostCompact und SessionEnd. Diese Hooks fügen relevanten Speicher ein und speichern jeden abgeschlossenen Turn, ohne dass das Modell dies selbst entscheiden muss.

Schreiben Sie die Anweisung einmal von Hand. Dann wissen Sie genau, was dem Agenten vorgegeben wurde. Claude Code liest CLAUDE.md zu Beginn jeder Sitzung aus dem Projektstammverzeichnis. Ein Abschnitt wie dieser bildet daher die gesamte Integration über den Quellcodepfad:

## 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.

Machen Sie sich klar, welchen Nutzen das bietet. Ohne Hooks handelt es sich um eine Integration auf Anweisungsebene. Sie funktioniert nur, wenn das Modell beschließt, den Befehl auszuführen. Der Aufruf wird nicht erzwungen. Wenn eine Sitzung ohne add endet, hat die Anweisung selbst nichts gespeichert. Ein späterer Verlaufsscan kann den abgeschlossenen Turn jedoch weiterhin importieren. Das entspricht dem Verhalten von den eigenen Speicherdateien von Claude Code, mit einem Unterschied: Der Speicher ist gemeinsam nutzbar. Die Notiz ist daher auf demselben Rechner auch für Codex und Cursor verfügbar. Hooks schließen diese Lücke, statt lediglich darum zu bitten. Deshalb steht dauerhafter Speicher neben Budgetbegrenzungen und Berechtigungsregeln unter den DeepSeek-Harness-Plugins, deren Installation sich lohnt.

Für die umgekehrte Richtung ist keine Einrichtung erforderlich. Der Scanner von Memmy liest ~/.claude/projects/**/*.jsonl bereits aus. Dort schreibt Claude Code seine Sitzungstranskripte. Führen Sie Memmy auf demselben Server aus, auf dem Sie Claude Code in einer tmux-Sitzung verwenden. Dann wird die Arbeit des Vortags ohne weitere Konfiguration zum Speicher.

Funktioniert Memmy als MCP-Server für Claude Code?

Nein. Wenn Sie das wissen, sparen Sie sich einen Nachmittag. MCP (model context protocol) unterscheidet zwischen Clients und Servern. Memmy ist ein Client. Memmy stellt Verbindungen zu MCP-Servern her und stellt deren Tools seiner eigenen Agent-Laufzeitumgebung bereit. Memmy veröffentlicht keinen MCP-Endpunkt, auf den claude mcp add verweisen kann. Die einzige MCP-Bridge im Repository gehört zur Composio-Integration innerhalb der lokalen Desktop-API. Diese API bindet einen zufälligen Port auf 127.0.0.1 und ist durch ihren eigenen x-memmy-mcp-token-Header geschützt.

Die Client-Seite wird in ~/.memmy/config.yaml konfiguriert. Die Datei, auf die MEMMY_CONFIG verweist, liegt unter tools.mcpServers:

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

type akzeptiert stdio, sse und streamableHttp. Ein stdio-Server wird als Kindprozess von Memmy ausgeführt. Deshalb muss sein Befehl auf demselben Rechner vorhanden sein und unter demselben Benutzer ausgeführt werden. Wenn Sie MCP-Server auf einem VPS betreiben, sind dies die Server, die Sie hier eintragen sollten.

Den Memory-Speicher privat halten

Alles, was Memmy besitzt, liegt unter ~/.memmy: config.yaml, der Workspace, memory-service/memory.sqlite und Laufzeitdateien. Scannen und Einlesen erfolgen lokal, und die Erinnerungen werden in diese lokale SQLite-Datei geschrieben. Damit ist das Standardverhalten tatsächlich lokal.

Die Cloud-Verbindung ist ein Pfad, den Sie überwachen sollten. MEMMY_CLOUD_SERVICE bezeichnet den Cloud-Ursprung. Der Code legt dafür keinen Standardwert fest. .env.example, das die Installationsschritte nach .env kopieren, setzt den Wert jedoch auf https://api.memmy.cn. Damit wird der Account-Modus mit seinen Testtokens unterstützt. Sobald der Wert gesetzt ist, sendet Memmys Analytics-Code außerdem Nutzungsereignisse dorthin, auch im API-Key-Modus: Ereignis- und Befehlsnamen, Versionen und eine Installations-ID. Die CLI meldet nur festgelegte Befehlswörter, niemals Suchanfragen oder Erinnerungstext. Der Analytics-Code sendet nichts, wenn der Wert nicht gesetzt ist. Leeren Sie diese Zeile daher auf einem Server, der ausschließlich API-Keys verwendet, in .env, bevor Sie irgendetwas starten. Das Programm zur Verbesserung der Erinnerungen ist ein separates Umschaltfeld in den Datenschutzeinstellungen.

Modellaufrufe sind ein weiterer Pfad. Wenn Sie einen gehosteten Embedding-Provider konfigurieren, wird der zu eingebettende Erinnerungstext an diesen Provider gesendet, damit er in einen Vektor umgewandelt werden kann. Lokale Speicherung hilft an dieser Stelle nicht. Verwenden Sie den integrierten lokalen Embedding-Provider oder einen Embedding-Endpunkt, den Sie selbst hosten, um diesen Pfad zu schließen. Gehostete Modelle für Zusammenfassungen, die Weiterentwicklung und die Relevanzfilterung erhalten ebenfalls Erinnerungsinhalte, wenn diese Aufgaben ausgeführt werden. Prüfen Sie daher auch diese Modelleinstellungen.

Belassen Sie Port 18960 auf der Loopback-Adresse. Dafür ist keine Firewall-Regel erforderlich, weil ein Dienst, der an 127.0.0.1 gebunden ist, von außerhalb des Rechners überhaupt nicht erreichbar ist. Greifen Sie stattdessen über SSH von Ihrem Laptop darauf zu:

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

Der aktuelle Memory-Service lehnt Bind-Adressen außerhalb des Loopbacks ab. Wenn Sie storage.token in der Konfiguration oder die Umgebungsvariable MEMMY_MEMORY_TOKEN bzw. MEMORY_SERVICE_TOKEN setzen, schützen Sie gewöhnliche Memory-API-Aufrufe mit einem Bearer-Token. Der Health-Check bleibt unauthentifiziert, und der Browser-Viewer verwendet für lokale Anfragen separate Prüfungen. Konfigurationswerte unterstützen ${ENV_NAME}-Referenzen. Dadurch bleiben das Token und Ihre Model-API-Keys aus der Datei selbst heraus. Das entspricht derselben Vorgehensweise wie Secrets aus AI-Agenten herauszuhalten und einer standardmäßigen deny ufw policy. Diese Richtlinie dient als zusätzliche Absicherung, falls eine künftige Version ihre standardmäßige Bind-Adresse ändert.

Sichern Sie ~/.memmy, bevor Sie dem System vertrauen

memory.sqlite ist der gesamte Datenspeicher. Die Vektoren befinden sich über die Erweiterung sqlite-vec in derselben Datei. Damit besteht das Backup aus einer einzigen Datei. Wenn Sie sie mit cp kopieren, während der Dienst in die Datei schreibt, kann eine inkonsistente Datenbankkopie entstehen. Verwenden Sie stattdessen den integrierten Backup-Befehl von SQLite:

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

Damit wird eine konsistente Kopie erstellt, während der Dienst weiterläuft. Übertragen Sie diese regelmäßig vom Server auf ein anderes System. Dafür eignet sich restic für die Sicherung an einen externen Speicherort. Wenn Sie config.yaml verlieren, müssen Sie lediglich die Provider-Einstellungen erneut eingeben. Wenn Sie memory.sqlite verlieren, gehen die seit dem letzten verwendbaren Backup aufgezeichneten Erinnerungen verloren. Der Dienst erstellt vor Schema-Migrationen außerdem ein lokales Backup. Dieses ist jedoch keine aktuelle Kopie an einem externen Speicherort.

Den Memory-Dienst unter systemd ausführen

npm run memory:serve:dev in einer Shell wird mit der Shell beendet. Eine Unit-Datei hält den Dienst über Reboots hinweg am Laufen. Der Dienst läuft als Benutzer memmy aus einem Checkout in /opt/memmy und verwendet die Konfiguration im Home-Verzeichnis dieses Benutzers. Beenden Sie die Kopie, die in Ihrer Shell läuft. Verschieben Sie anschließend den Checkout und die Konfiguration und setzen Sie den Link memmy-memory neu:

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

Der Dienst speichert seine Datenbank unter /home/memmy/.memmy. Deshalb startet er mit einem leeren Datenspeicher.

[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

Speichern Sie das Token nicht in der Unit. Legen Sie es in /etc/memmy/memory.env ab. Die Datei muss root gehören und den Modus 600 haben:

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

status=203/EXEC in der Statusausgabe bedeutet, dass systemd ExecStart überhaupt nicht ausführen konnte. Prüfen Sie daher which npm: Bei einer NodeSource-Installation befindet es sich unter /usr/bin/npm, bei nvm dagegen unter einem Pfad im Home-Verzeichnis des Benutzers. Diesen Pfad findet systemd nicht. Wenn eine Unit sofort startet und wieder beendet wird, prüfen Sie den Exit-Status und das Journal: Code 0 bedeutet ein sauberes Beenden. Andere Ergebnisse sind unter anderem Exit-Codes ungleich 0, Signale und Zeitüberschreitungen. Führen Sie journalctl -u memmy-memory -n 50 aus, um die Ausgabe des Dienstes anzuzeigen. Die Vorgehensweise entspricht der bei jedem anderen systemd-Dienst auf einem VPS.

Das Projekt bietet inzwischen zwei Alternativen auf Benutzerebene. Für einen Build aus dem Quellcode verwendet die README den Weg memmy-memory install --service-only. Dabei wird die festgelegte Memory-Laufzeitumgebung heruntergeladen und ein Benutzerdienst registriert. Das Linux-Installationsprogramm richtet memmy-memory.service als systemd --user-Unit ein. Keine der beiden Varianten aktiviert Linger. Führen Sie daher sudo loginctl enable-linger <user> aus, damit der Service Manager dieses Benutzers nach der Abmeldung weiterläuft und beim Booten gestartet wird.

Was Memmy noch nicht kann

• Es gibt keinen Linux-Desktop-Build. Die Packaging-Skripte decken macOS und Windows ab. Daher sind die Workbench und der Onboarding-Assistent nicht direkt auf dem Server verfügbar. Der Memory-Service enthält jetzt einen Browser-Viewer unter http://127.0.0.1:18960/viewer/, der über den obigen SSH-Tunnel erreichbar ist. Für Linux gibt es stattdessen ein CLI-Tarball und install.sh.
• memory:serve:dev führt den TypeScript-Einstiegspunkt über tsx aus, einem Entwicklungspfad. Das Repository enthält außerdem memory:serve für kompilierten Output. Führen Sie npm run ohne Argumente aus, um zu sehen, welche Skripte Ihr Checkout tatsächlich enthält.
• Die Suche erstellt ihr Suchfenster aus den neuesten 2,000 Vektorzeilen und wendet die Top-K-Auswahl innerhalb dieses Fensters an. In einem sehr großen Speicher kann eine alte Erinnerung außerhalb dieses Fensters liegen.
• Die Embedding-Erstellung erfolgt nach der Erfassung. Ein Fehler wird in eine Retry-Warteschlange gestellt, statt den Durchlauf des Agenten zu blockieren. Eine gerade hinzugefügte Erinnerung ist möglicherweise noch nicht über die Vektorsuche auffindbar.
• Ein zweiter Server mit einer eigenen lokalen SQLite-Datenbank verfügt über einen getrennten Speicher.

Version 1.2.401 vom 1 November 2026 beschreibt weiterhin ein junges Projekt, das sich schnell weiterentwickelt. Flags, Pfade und Skriptnamen ändern sich zwischen Releases. Lesen Sie das Feld bin und die Ausgabe von npm run in Ihrem eigenen Checkout, statt einem Befehl zu vertrauen, den Sie irgendwo kopiert haben, auch hier.

FAQ

Warum meldet der Health Check „connection refused“?

Der curl-Exit-Code 7 mit Failed to connect to 127.0.0.1 port 18960 bestätigt eine fehlgeschlagene Verbindung. Er zeigt nicht, ob Memmy beendet wurde, abgestürzt ist, an einer anderen Adresse lauscht oder nicht erreichbar ist. Prüfen Sie Adresse und Port, führen Sie ss -lntp | grep 18960 aus und lesen Sie die Terminalausgabe oder das Journal, in dem der Dienst gestartet wurde. Wenn das Log eine Inkompatibilität des nativen SQLite-Moduls meldet, führen Sie npm rebuild better-sqlite3 aus. Prüfen Sie auch Ihre Node-Version: Die Quelldokumentation verlangt Node 22 oder neuer. Das Linux-Installationsprogramm akzeptiert innerhalb von 22.x nur Node.js 22.23.4+, innerhalb von 24.x nur 24.22.1+ und innerhalb von 26.x nur 26.12.1+.

Woher kommt der Befehl memmy-memory nach dem Build aus dem Quellcode?

Er stammt aus dem Feld bin des @memmy/memory-Workspace-Pakets, nicht aus dem Repository-Namen. Führen Sie node -p "JSON.stringify(require('./Memory/package.json').bin)" innerhalb des Checkouts aus. Der Befehl gibt {"memmy-memory":"./dist/src/cli/index.js"} aus. Diese Datei existiert erst nach npm run memory:build, weil der Build dist erstellt und die Datei als ausführbar markiert. Führen Sie sie als node Memory/dist/src/cli/index.js health aus oder verknüpfen Sie sie für den kurzen Namen symbolisch nach /usr/local/bin.

Kann ich Memmy mit claude mcp add zu Claude Code hinzufügen?

Nein. Memmy ist ein MCP-Client und kein MCP-Server. Memmy baut ausgehend Verbindungen zu den unter tools.mcpServers in ~/.memmy/config.yaml aufgeführten Servern auf und stellt deren Tools seiner eigenen Laufzeitumgebung bereit. Claude Code erreicht Memmy auf dem umgekehrten Weg, indem es die memmy-memory-CLI als Shell-Befehl ausführt. memmy-memory init --agent claude schreibt einen Skill und einen CLAUDE.md-Block, die angeben, wann Claude Code ihn verwenden soll. Außerdem fügt der Launcher aus dem Linux-Installationsprogramm Claude-Code-Hooks hinzu, die Turns automatisch speichern.

Werden meine Erinnerungen beim Ausführen von Memmy an einen Cloud-Dienst gesendet?

Scan und Ingestion laufen lokal. Die Erinnerungen werden unter ~/.memmy/memory-service/memory.sqlite auf Ihrer eigenen Festplatte gespeichert. MEMMY_CLOUD_SERVICE, das in .env.example auf https://api.memmy.cn gesetzt wird, stellt den Kontomodus und Test-Tokens bereit und empfängt Nutzungsanalysen, jedoch keinen Erinnerungstext, solange diese Einstellung aktiv ist. Leeren Sie den Wert daher, wenn Sie ausschließlich API-Schlüssel verwenden. Das Programm zur Verbesserung der Erinnerungen verfügt über einen separaten Datenschutzschalter. Ein gehostetes Embedding-Modell empfängt den Erinnerungstext, den es in einen Vektor umwandelt. Verwenden Sie den integrierten lokalen Provider oder einen selbst betriebenen Endpoint, wenn diese Verarbeitung lokal bleiben soll. Gehostete Modelle für Zusammenfassungen, die Weiterentwicklung und die Relevanzfilterung empfangen ebenfalls Erinnerungsinhalte, wenn diese Aufgaben ausgeführt werden.