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

Was Memmy ist und was es speichert

Memmy ist ein lokaler Speicher-Hub für KI-Agenten, der auf Ihrem eigenen VPS (Virtual Private Server) ausgeführt wird. Es verwaltet eine SQLite-Datenbank mit dem Wissen, das Ihre Agenten erlernt haben. Jeder Agent auf diesem Server liest und schreibt in denselben Speicher. Das Projekt wird von memmy-agent veröffentlicht, steht unter der MIT-Lizenz und hat im Juli 2026 die Version 1.0.4.

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

Memmy ordnet die gespeicherten Daten vier Ebenen zu. L1 Trace ist der rohe Ablauf: die Anfrage, die Antwort und die Tool-Aufrufe. L2 Policy ist eine aus Traces abgeleitete Vorgehensweise, die sich als nützlich erwiesen hat. L3 World Model ist stabiles Wissen über ein Projekt oder eine Umgebung. Skill ist eine aufrufbare, aus einer Policy herausgebildete Vorgehensweise. Der Dienst weist beim Erfassen eines Ablaufs eine Ebene zu. Sie müssen diese Ebenen daher nicht manuell erstellen.

Was sich ein gemeinsamer Memory-Hub gegenüber toolbezogenem Speicher ändert

Jeder Agent verfügt heute über einen eigenen Speicher. Claude Code speichert Anweisungsdateien im Repository. Cursor speichert Regeln in seiner Workspace-Datenbank. Codex speichert Sitzungsprotokolle unter ~/.codex. Jeder Speicher gehört zu genau einem Tool. Deshalb ist eine Information, die Sie am Montag in einem Tool vermittelt haben, am Dienstag in einem anderen Tool unbekannt. Das verursacht doppelte Kosten: erstens Tokens, die Sie für die erneute Erklärung desselben Projekts aufwenden, und zweitens fehlerhafte Arbeit, wenn ein Agent auf einer Annahme handelt, die Sie an anderer Stelle bereits korrigiert haben.

Ein Hub verlagert den Speicher aus dem Tool. Memmy liest außerdem die vorhandenen Speicher ein. Sie beginnen daher nicht mit einer leeren Datenbank. Sein Scanner kennt sechs 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 und Hermes unter ~/.hermes. Sie können eine Quelle manuell mit einem Namen und einem lokalen Pfad hinzufügen.

Die Importzähler stimmen nicht überein. Das ist erwartungsgemäß. Der Scanner gruppiert Nachrichten nach Quelle und Konversation und schreibt anschließend pro vollständigem Turn eine L1-Memory. Ein Turn gilt als vollständig, wenn er nichtleeren Benutzerinhalt enthält und mit einer nichtleeren Assistentennachricht endet. Eine unterbrochene Sitzung liefert daher keinen Beitrag. Nachrichten werden anhand von Konversationsprüfpunkten und stabilen Turn-IDs dedupliziert. Die Anzahl der gescannten Nachrichten, die Anzahl der importierten Nachrichten und die Anzahl der neuen Memories unterscheiden sich im selben Lauf.

Dies ist das Gegenstück zu wie Claude Code den Kontext innerhalb einer Sitzung verwaltet. Das Kontextmanagement entscheidet, was in ein einzelnes Fenster passt. Ein Memory-Hub entscheidet, was nach dem Schließen dieses Fensters erhalten bleibt.

Voraussetzungen auf dem VPS

• Node.js 22 oder neuer. Die Memmy-Dokumentation benötigt diese Version, und Ubuntu 24.04 wird mit Node 18 ausgeliefert.
• git und eine Build-Toolchain, da better-sqlite3 ein natives Modul ist, das während der Installation kompiliert werden kann.
• Etwa 2 GB RAM. Die Installation im root-Kontext lädt einen großen Workspace und eine Frontend-Build-Toolchain.
• Einige GB freien 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 v22 oder höher ausgeben. Ein v18 an dieser Stelle bedeutet, dass der NodeSource-Schritt nicht erfolgreich war. Die Installation schlägt später bei der Engine-Prüfung des Projekts fehl.

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 in Memory/dist. Für einen Headless-Server muss nichts anderes im Verzeichnisbaum kompiliert werden. Prüfen Sie, ob das native Modul geladen wurde:

node -e "require('better-sqlite3'); console.log('better-sqlite3 loads')"

Wenn diese Zeile statt einer Ausgabe einen Fehler ausgibt, ist das native Modul nicht mit Ihrer Node-Version kompatibel. 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 diesen 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 Anzeige. Auf einem Server ohne grafische Sitzung bleibt das Skript daher hängen oder wird beendet.

Den Speicherdienst starten und prüfen, ob er antwortet

npm run memory:serve:dev

So wird der Speicherdienst laut Dokumentation aus dem Quellcode gestartet. Er bindet 127.0.0.1:18960, speichert die Datenbank unter ~/.memmy/memory-service/memory.sqlite und liest die Konfiguration aus ~/.memmy/config.yaml. Die README nennt dieselben Werte, 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

Prüfen Sie in einer zweiten Shell, ob der Dienst aktiv ist:

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

Der Health-Endpunkt ist der einzige Endpunkt, der niemals ein Token verlangt. Deshalb eignet er sich als Test. Wenn curl mit dem Exit-Code 7 und einer Meldung zu Failed to connect to 127.0.0.1 port 18960 beendet wird, lauscht kein Dienst. Sehen Sie im Terminal nach, in dem der Dienst läuft. Ein Absturz beim Start wird dort ausgegeben. Die häufigste Ursache ist, dass das native SQLite-Modul nicht geladen werden kann. ss -lntp | grep 18960 bestätigt den Socket, sobald der Dienst aktiv ist.

Der restliche HTTP API (Anwendungsprogrammierschnittstelle) befindet sich unter /api/v1.

• POST /api/v1/memory/add schreibt eine Erinnerung, und POST /api/v1/memory/search führt Abfragen aus.
• 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 protokollieren einen Durchlauf.
• GET /api/v1/panel/overview, /api/v1/panel/analysis und /api/v1/panel/items liefern Daten für das Dashboard.

Memmy reserviert einen Portblock. Im Headless-Betrieb verwenden Sie nur den ersten Port: 18960 für den Speicher, 18970 für die Gateway-Health-Prüfung, 18980 für die Weboberfläche und die administrative HTTP-Schnittstelle, 18990 für die mit memmy serve gestartete OpenAI-kompatible API sowie 19000 und 19010 für den Entwicklungsserver des Desktop-Frontends. Wenn auf Ihrem Rechner bereits ein Dienst einen dieser Ports verwendet, sollten Sie diese Liste prüfen.

Woher der Befehl memmy-memory tatsächlich kommt

Hier geht die erste Installation meistens schief. Lesen Sie die Definition daher direkt aus dem Paket, statt zu raten. Der Befehlsname hat nichts mit dem Namen des Repositorys 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)"

Dieser Befehl gibt {"memmy-memory":"./dist/src/cli/index.js"} aus. Der erstellte Einstiegspunkt ist daher 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. Zusätzlich gibt es Aufrufe für Sitzungen und Turns, die Agents statt Benutzer verwenden. memmy-memory search "deploy steps" und memmy-memory add "staging migrates on deploy" werden von einem Agent am häufigsten ausgeführt.

Wie verbinden Sie Claude Code mit Memmy?

Claude Code verfügt über keine Schnittstelle für Memory-Plugins. Memmy kann sich daher nicht direkt einklinken. Die Integration ist einfacher. Claude Code führt memmy-memory als normalen Shell-Befehl aus. Eine Anweisungsdatei teilt dem Tool mit, wann es den Befehl ausführen soll. Das dokumentierte Installationsprogramm von Memmy erstellt diese Datei für Sie: memmy-memory init --agent legt eine Memory-Anweisungsdatei im Regelverzeichnis des Ziel-Agenten ab.

Schreiben Sie die Anweisung einmal von Hand. Dann wissen Sie genau, welche Vorgaben der Agent erhalten hat. Claude Code liest CLAUDE.md zu Beginn jeder Sitzung aus dem Projektstammverzeichnis. Ein Abschnitt wie der folgende bildet daher die gesamte Integration:

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

Beachten Sie die Grenzen dieser Lösung. Es handelt sich um eine Integration auf Anweisungsebene. Sie funktioniert nur, wenn das Modell entscheidet, den Befehl auszuführen. Der Aufruf wird nicht erzwungen. Wenn eine Sitzung ohne add endet, wird nichts gespeichert. Bei der nächsten Suche ist das einzige Signal ein leeres Ergebnis. Das entspricht dem Verhalten von den eigenen Memory-Dateien von Claude Code, mit einem Unterschied: Der Speicher wird gemeinsam genutzt. Die Notiz steht daher auch Codex und Cursor auf demselben Rechner zur Verfügung.

Für die umgekehrte Richtung ist keine Einrichtung erforderlich. Der Scanner von Memmy liest ~/.claude/projects/**/*.jsonl bereits ein. Dort speichert Claude Code seine Sitzungsprotokolle. Führen Sie Memmy auf demselben Server aus, auf dem Sie Claude Code in einer tmux-Sitzung ausführen. Die Arbeit vom Vortag wird dadurch ohne weitere Konfiguration zu Memory.

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

Nein. Wenn Sie diese Richtung kennen, sparen Sie Zeit. MCP (Model Context Protocol) verwendet Clients und Server. Memmy ist ein Client. Memmy stellt Verbindungen zu MCP-Servern her und stellt deren Tools seiner eigenen Agent-Laufzeit 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 Clientseite wird in ~/.memmy/config.yaml konfiguriert. Die Datei MEMMY_CONFIG verweist unter tools.mcpServers darauf:

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 untergeordneter Prozess von Memmy ausgeführt. Daher muss der Befehl auf demselben System vorhanden sein und unter demselben Benutzer ausgeführt werden. Wenn Sie MCP-Server auf einem VPS ausführen, müssen Sie diese hier angeben.

Den Datenspeicher privat halten

Alles, was Memmy besitzt, liegt unter ~/.memmy: config.yaml, der Arbeitsbereich, memory-service/memory.sqlite und Laufzeitdateien. Scans und die Aufnahme von Daten erfolgen lokal. Erinnerungen werden in diese lokale SQLite-Datei geschrieben. Die Standardeinstellung ist daher tatsächlich lokal.

Zwei Pfade greifen auf das Netzwerk zu. MEMMY_CLOUD_SERVICE verwendet standardmäßig https://memmy-api.memtensor.cn und unterstützt den Kontomodus mit dessen Testtokens. Im API-Key-Modus wird dieser Dienst daher nie aufgerufen. Das Programm zur Verbesserung der Erinnerungen ist eine separate Option in den Datenschutzeinstellungen. Es ist deaktiviert, bis Sie es einschalten.

Ein dritter Pfad wird leichter übersehen. Wenn Sie einen gehosteten Embedding-Provider konfigurieren, wird der Text jeder Erinnerung an diesen Provider gesendet, damit er in einen Vektor umgewandelt werden kann. Die lokale Speicherung schützt die Daten in diesem Fall nicht. Nur ein von Ihnen selbst gehosteter Embedding-Endpunkt verhindert diese Übertragung.

Binden Sie Port 18960 an die Loopback-Adresse. Dafür ist keine Firewall-Regel erforderlich, da ein Dienst, der an 127.0.0.1 gebunden ist, von außerhalb des Rechners 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

Wenn Sie den Dienst jemals an eine umfassendere Adresse binden, setzen Sie vorher ein Token. Wenn Sie storage.token in der Konfiguration oder die Umgebungsvariable MEMMY_MEMORY_TOKEN beziehungsweise MEMORY_SERVICE_TOKEN setzen, erfordern alle Endpunkte außer dem Health-Endpunkt ein Bearer-Token. Konfigurationswerte unterstützen ${ENV_NAME}-Referenzen. Dadurch bleiben das Token und Ihre Model-API-Keys aus der Datei selbst heraus. Das entspricht der Vorgehensweise Secrets aus AI-Agenten herauszuhalten und einer standardmäßigen deny ufw-Richtlinie, die als zusätzliche Absicherung dient, falls eine zukü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. Daher ist eine Datei das Backup. Wenn Sie sie mit cp kopieren, während der Dienst schreibt, kann eine inkonsistente Datenbankkopie entstehen. Verwenden Sie den eigenen Backup-Befehl von SQLite:

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

Dadurch wird eine konsistente Kopie erstellt, während der Dienst weiterläuft. Übertragen Sie sie nach einem Zeitplan vom Server auf ein anderes System. Dafür ist restic für die externe Speicherung vorgesehen. Der Verlust von config.yaml kostet Sie die Anbietereinstellungen, die Sie erneut eingeben können. Der Verlust von memory.sqlite kostet Sie jede einzelne Erinnerung. Eine zweite Kopie befindet sich an keiner anderen Stelle auf dem System.

Den Speicherdienst unter systemd ausführen

npm run memory:serve:dev in einer Shell wird zusammen mit der Shell beendet. Eine Unit-Datei hält den Dienst auch nach Neustarts aktiv.

[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

Legen Sie das Token nicht in der Unit ab. Speichern Sie es in /etc/memmy/memory.env. 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 ist dies /usr/bin/npm. Bei nvm liegt es unter dem Home-Verzeichnis des Benutzers. Diesen Pfad findet systemd nicht. Eine Unit, die sofort startet und beendet wird, ist stattdessen innerhalb von npm fehlgeschlagen. journalctl -u memmy-memory -n 50 gibt den Grund aus. Die Vorgehensweise ist dieselbe wie bei jedem anderen systemd-Dienst auf einem VPS.

Was Memmy noch nicht kann

• Es gibt keinen Linux-Desktop-Build. Die Packaging-Skripte unterstützen macOS und Windows. Daher sind die Workbench, der Onboarding-Assistent und das Memory-Dashboard nicht auf dem Server selbst verfügbar.
• memory:serve:dev führt den TypeScript-Einstiegspunkt über tsx aus. Das ist ein 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. Anschließend wendet sie die Top-K-Auswahl innerhalb dieses Fensters an. In einem sehr großen Speicher kann ein älterer Memory außerhalb des Fensters liegen.
• Die Erzeugung von Embeddings erfolgt nach der Erfassung. Ein Fehler wird in eine Retry-Warteschlange gestellt, anstatt den Agentenlauf zu blockieren. Ein gerade hinzugefügter Memory ist möglicherweise noch nicht per Vektorsuche auffindbar.
• Eine SQLite-Datei bedeutet einen Node. Es gibt kein Clustering. Ein zweiter Server hat daher einen zweiten, getrennten Memory.

Version 1.0.4 und ungefähr 329 Sterne im Juli 2026 kennzeichnen ein junges Projekt. Flags, Pfade und Skriptnamen ändern sich zwischen Releases. Lesen Sie das Feld bin und die Ausgabe von npm run in Ihrem eigenen Checkout, anstatt einem kopierten Befehl zu vertrauen, unabhängig davon, woher er stammt, auch hier.

FAQ

Warum liefert die Integritätsprüfung „connection refused“?

An Port 18960 lauscht kein Dienst. Ein curl-Exit-Code 7 mit Failed to connect to 127.0.0.1 port 18960 bedeutet, dass der Memory-Dienst nicht läuft oder beim Start beendet wurde. Lesen Sie daher das Terminal oder das Journal, in dem der Dienst gestartet wurde. Die beiden häufigsten Ursachen sind ein better-sqlite3-natives Modul, das nicht zu Ihrer Node-Version passt und mit npm rebuild better-sqlite3 behoben wird, sowie eine Node-Version unter 22. Bestätigen Sie den Socket mit ss -lntp | grep 18960, sobald der Dienst läuft.

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

Er stammt aus dem Feld bin des Workspace-Pakets @memmy/memory, nicht aus dem Repository-Namen. Führen Sie node -p "JSON.stringify(require('./Memory/package.json').bin)" im Checkout 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 erstellen Sie für den kurzen Namen einen symbolischen Link nach /usr/local/bin.

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

Nein. Memmy ist ein MCP-Client, kein MCP-Server. Memmy stellt ausgehende Verbindungen zu den unter tools.mcpServers in ~/.memmy/config.yaml aufgeführten Servern her 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. Gesteuert wird dies durch eine Anweisungsdatei, die memmy-memory init --agent in das Regelverzeichnis des Agents schreibt.

Sendet der Betrieb von Memmy meine Erinnerungen an einen Cloud-Dienst?

Scan- und Erfassungsvorgänge laufen lokal. Die Erinnerungen werden auf Ihrem eigenen Datenträger in ~/.memmy/memory-service/memory.sqlite gespeichert. MEMMY_CLOUD_SERVICE verweist im Kontomodus und für Test-Token auf https://memmy-api.memtensor.cn. Das Programm zur Verbesserung der Erinnerungen bleibt deaktiviert, bis Sie es aktivieren. Achten Sie auf den Embedding-Provider: Ein gehostetes Embedding-Modell erhält den Text jeder Erinnerung, die es in einen Vektor umwandelt. Wenn das relevant ist, verwenden Sie einen Endpoint, den Sie selbst betreiben.