MCP Memory Service — Anwendungsfälle, Installieren & Live-Demo

Warum nutzen

Hauptfunktionen

Vektor- und symbolischer Hybrid-Abruf — weniger Falsch-Positive als reine Embedding-Stores
Automatisch aufgebauter Knowledge Graph, der Entities, Entscheidungen und Projekte verknüpft
Hintergrundkonsolidierung: dedupliziert, fasst zusammen und erkennt Drift
REST-API neben MCP — gleicher Speicher, zwei Clients
SQLite-first (keine Infrastruktur); austauschbar gegen Postgres / pgvector für Skalierung

Live-Demo

In der Praxis

mcp-memory-service.replay ▶ bereit

0/0

Installieren

Wählen Sie Ihren Client

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

{
  "mcpServers": {
    "mcp-memory-service": {
      "command": "uvx",
      "args": [
        "mcp-memory-service"
      ]
    }
  }
}

Öffne Claude Desktop → Settings → Developer → Edit Config. Nach dem Speichern neu starten.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "mcp-memory-service": {
      "command": "uvx",
      "args": [
        "mcp-memory-service"
      ]
    }
  }
}

Cursor nutzt das gleiche mcpServers-Schema wie Claude Desktop. Projektkonfiguration schlägt die globale.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "mcp-memory-service": {
      "command": "uvx",
      "args": [
        "mcp-memory-service"
      ]
    }
  }
}

Klicken Sie auf das MCP-Servers-Symbol in der Cline-Seitenleiste, dann "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "mcp-memory-service": {
      "command": "uvx",
      "args": [
        "mcp-memory-service"
      ]
    }
  }
}

Gleiche Struktur wie Claude Desktop. Windsurf neu starten zum Übernehmen.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "mcp-memory-service",
      "command": "uvx",
      "args": [
        "mcp-memory-service"
      ]
    }
  ]
}

Continue nutzt ein Array von Serverobjekten statt einer Map.

~/.config/zed/settings.json

{
  "context_servers": {
    "mcp-memory-service": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-memory-service"
        ]
      }
    }
  }
}

In context_servers hinzufügen. Zed lädt beim Speichern neu.

claude mcp add mcp-memory-service -- uvx mcp-memory-service

Einzeiler. Prüfen mit claude mcp list. Entfernen mit claude mcp remove.

Anwendungsfälle

Praxisnahe Nutzung: MCP Memory Service

Claude über ein mehrwöchiges Coding-Projekt synchron halten

👤 Entwickler bei langfristigen Projekten ⏱ ~15 min beginner

Wann einsetzen: Bei jeder Sitzung verbringst du 10 Minuten damit, Claude an Projektkonventionen, Entscheidungen und TODOs zu erinnern.

Voraussetzungen

Memory-Service läuft — uvx mcp-memory-service (Standard: ~/.mcp-memory.db)

Ablauf

Kernkontext einpflegen

Use mcp-memory-service. Store these as project-level memory: 'use bun not npm', 'all DB writes go through src/db/repo.ts', 'no class components in src/ui'.✓ Kopiert

→ 3 Erinnerungen mit Projekt-Tag gespeichert
In nächster Sitzung verwenden

Recall any project-level rules before suggesting changes to src/ui/Form.tsx.✓ Kopiert

→ Relevante Regeln sichtbar; Vorschlag respektiert sie
Neue Entscheidungen erfassen

Save: 'switched from React Query to SWR on 2026-04-22 because of Suspense compat'.✓ Kopiert

→ Erinnerung mit Datum gespeichert; wird beim nächsten Auftreten des Themas sichtbar

Ergebnis: Claude behandelt dein Projekt wie ein kontinuierliches Engagement, nicht 100 Kaltaufrufe.

Fallstricke

Gedächtnis wächst unbegrenzt; Abruf zieht alte/irrelevante Einträge — Wöchentlich konsolidieren; Erinnerungen taggen um Abruf auf aktuell + dieses Projekt zu beschränken

Kombinieren mit: filesystem

Einem persönlichen Assistenzagenten ein dauerhaftes Profil geben

👤 Menschen, die tägliche Claude-Agenten entwickeln ⏱ ~10 min beginner

Wann einsetzen: Dein täglicher Agent sollte Präferenzen, wiederkehrende Meetings und Personen kennen, ohne erneut zu fragen.

Ablauf

Profil einpflegen

Use mcp-memory-service. Store: my timezone (Asia/Tokyo), my partner's name, my work hours (10–7), recurring 1:1s.✓ Kopiert

→ Profil mit type=profile gespeichert
Spontan abrufen

Schedule 'lunch w/ Alice' for next Tuesday — pick a time that respects my work hours.✓ Kopiert

→ Vorschlag nutzt deine Arbeitszeiten aus dem Gedächtnis; kein erneutes Nachfragen

Ergebnis: Weniger wiederholtes Kontext-Setzen pro Aufgabe.

Fallstricke

Sensible Details (medizinisch, finanziell) unverschlüsselt gespeichert — Separaten DB-Pfad verwenden (verschlüsseltes FS oder SQLCipher); oder einfach keine medizinischen/finanziellen Daten in dieser Schicht speichern

Kombinieren mit: google-workspace-mcp

Einen Forschungs-Knowledge-Graph beim Lesen von Papieren aufbauen

👤 Forscher, Analysten, intensive Leser ⏱ ~60 min intermediate

Wann einsetzen: Du liest 30 Paper und willst Entities, Behauptungen und Widersprüche verfolgen.

Ablauf

Beim Lesen einpflegen

For each paper I link, extract: authors, key claims, methods, datasets — store as linked nodes.✓ Kopiert

→ Knotenanzahl wächst; Verlinkungen sichtbar
Widersprüche finden

Across stored papers, find claims that contradict. List with sources.✓ Kopiert

→ Paare widersprechender Behauptungen mit Zitaten
Überblick generieren

Draft a 2-page survey with the dominant claim threads + contradictions noted.✓ Kopiert

→ Markdown-Überblick mit quellengestützten Behauptungen

Ergebnis: Eine echte Synthese, nicht nur Notizen.

Fallstricke

Extraktionsqualität variiert — einige Behauptungen sind Rauschen — Knoten mit niedrigem Vertrauen periodisch bereinigen; der Konsolidierungsjob hilft, ist aber kein Allheilmittel

Kombinieren mit: filesystem

Projektentscheidungslog zwischen Teammitglieds-Agenten teilen

👤 Kleine Teams, die KI-Entwicklungsagenten nutzen ⏱ ~30 min advanced

Wann einsetzen: Drei Personen im Team nutzen Claude Code; niemand weiß, welche Entscheidungen die Agenten der anderen bereits getroffen haben.

Voraussetzungen

Gehostete Instanz für alle erreichbar — Mit --host 0.0.0.0 auf einem gemeinsamen Dev-Server ausführen; oder Docker-Image deployen

Ablauf

Team-Konfigurationen auf gemeinsamen Service zeigen

Update each teammate's MCP config to use the shared URL with separate auth tokens.✓ Kopiert

→ Alle Agenten lesen/schreiben denselben Speicher
Konvention: Entscheidungen taggen

Convention: anything stored as type=decision is team-visible; type=personal is namespaced.✓ Kopiert

→ Tags angewendet; Abruf entsprechend begrenzt

Ergebnis: Teamgedächtnis ohne Wiki.

Fallstricke

Persönliche Notizen versehentlich als team-sichtbar getaggt — Standard auf type=personal; explizites type=decision als Opt-in für Team-Notizen erforderlich

Kombinieren mit: github

Kombinationen

Mit anderen MCPs für 10-fache Wirkung

mcp-memory-service + filesystem

Gedächtnis in Repo-Dateien verankern — memory_id ↔ Dateipfad verknüpfen

When I edit src/db/repo.ts, recall any decisions referencing it before suggesting changes.✓ Kopiert

mcp-memory-service + github

PR-Review-Zusammenfassungen automatisch als Entscheidungsgedächtnis speichern

After every merged PR, store the design rationale + reviewer concerns as type=decision tagged with the repo.✓ Kopiert

Werkzeuge

Was dieses MCP bereitstellt

Werkzeug	Eingaben	Wann aufrufen	Kosten
store_memory	content, tags?, type?, metadata?	Bei jedem neuen Fakt / jeder Entscheidung, die es wert ist aufzubewahren	0
recall	query, top_k?, tags?, since?	Erster Schritt vor dem Antworten — Kontext nicht neu erfinden	0
graph_neighbors	node_id, depth?	Verwandte Entities/Entscheidungen erkunden	0
consolidate	scope?	Wöchentliche Wartung; führt Duplikate zusammen	LLM-Tokens für Zusammenfassung
delete_memory	memory_id	Recht auf Vergessenwerden oder Datenkorrektur	0

Kosten & Limits

Was der Betrieb kostet

API-Kontingent: Keine — alles lokal
Tokens pro Aufruf: Recall gibt 200–2000 Tokens zurück je nach top_k
Kosten in €: Kostenlos; Konsolidierung nutzt lokales oder BYO-LLM
Tipp: top_k=5 für die meisten Recall-Aufrufe begrenzen; Konsolidierung für Deduplizierung statt Prompts zu überladen

Sicherheit

Rechte, Secrets, Reichweite

Minimale Scopes: filesystem write to db path

Credential-Speicherung: DB unter ~/.mcp-memory.db; FS verschlüsseln oder SQLCipher für sensible Daten verwenden

Datenabfluss: Standardmäßig keine; Konsolidierung kann nach außen kommunizieren wenn an ein LLM angebunden

Niemals gewähren: Weltlesbare DB auf gemeinsamen Hosts

PII fließt über Erinnerungen ein — Datenaufbewahrungsrichtlinie auf Anwendungsebene anwenden

Fehlerbehebung

Häufige Fehler und Lösungen

Recall gibt nichts zurück

Tags-Filter prüfen; Embeddings-Index muss nach Schema-Änderungen möglicherweise neu aufgebaut werden

Prüfen: Look at tool result count and the tags you pass

DB-Lock-Fehler bei gleichzeitigen Agenten

Auf Postgres-Backend wechseln oder SQLite-WAL-Modus aktivieren (Standard in neueren Versionen)

Prüfen: PRAGMA journal_mode;

Konsolidierung läuft ewig

Eingrenzen: consolidate(scope='last_week') statt voller DB

Erinnerungen voller Off-Topic-Chat

Beim Speichern strenger sein — store_memory nur für Fakten/Entscheidungen aufrufen, nicht für beiläufigen Chat

Prüfen: Aktuelle Speicherungen prüfen; Ballast löschen

Alternativen

MCP Memory Service vs. andere

Alternative	Wann stattdessen	Kompromiss
claude-mem-skill	Sitzungsüberbrückende Komprimierung gewünscht, kein langfristiger Wissensspeicher	claude-mem ist für Sitzungskontinuität; dies ist echtes persistentes Gedächtnis + Graph
Mem0	Gehostete Gedächtnisschicht mit SDKs gewünscht	Kostenpflichtig bei größerem Volumen; Daten verlassen deinen Rechner
Letta (formerly MemGPT)	Vollständige Agent-Laufzeitumgebung mit eingebautem Gedächtnis gewünscht, nicht nur eine Gedächtnisschicht	Schwerer; hat eigene Meinungen zur Agenten-Architektur

Mehr

Ressourcen

📖 Offizielle README auf GitHub lesen

🐙 Offene Issues ansehen

🔍 Alle 400+ MCP-Server und Skills durchsuchen