---
title: "mcp-memory-service: Gedächtnis für Claude Code & Cursor"
canonical: https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/
language: de
description: "Gemeinsames Gedächtnis für Claude Code, Cursor und OpenCode einrichten: SQLite-Pfade, lokale ONNX-Embeddings, 5-ms-Angaben und veraltete Entscheidungen prüfen."
image: "https://wavect.io/img/blog/headers/header_mcp-memory-service-claude-code-cursor.png"
---

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

15 Min. Lesezeit · 24. Sep. 2026 Zuletzt geprüft 24. September 2026

[**Weiter**](/de/blog/openviking-agent-memory-review/)

# mcp-memory-service: Gemeinsames Gedächtnis für Claude Code und Cursor

TL;DR

mcp-memory-service ist ein dauerhafter gemeinsamer Speicher für KI-Coding-Tools. Sein stärkster Anwendungsfall ist der Abruf von Projektentscheidungen über Claude Code, Cursor und OpenCode hinweg, nicht der Ersatz versionierter Anweisungen. Konfigurieren Sie dieselbe lokale Datenbank, prüfen Sie echte Abrufe zwischen den Clients und speichern Sie Belege sowie Entscheidungsstatus. Lokale ONNX-Berechnung macht ein Cloud-Coding-Modell nicht offline. Die 5 ms sind eine Projektangabe, kein von uns reproduzierter Benchmark.

**mcp-memory-service gibt KI-Coding-Agenten einen gemeinsamen, dauerhaften Speicher für Architekturentscheidungen, Fehleranalysen und Projektkonventionen.** Der Nutzen besteht nicht darin, ein unbegrenztes Gespräch im Modell zu behalten. Eine neue Sitzung kann relevante Einträge aus einer anderen Sitzung oder einem anderen Tool abrufen, sofern beide Clients denselben Speicher erreichen und die Memory-Werkzeuge tatsächlich verwenden. Das [offizielle Repository](https://github.com/doobidoo/mcp-memory-service) beschreibt lokale Embeddings, semantische Suche und typisierte Beziehungen in einem Wissensgraphen.

**Quellenprüfung: 24. September 2026.** Dieser Leitfaden basiert auf Dokumentation. Er ist weder ein Bericht über eine praktisch durchgeführte Integration noch ein unabhängig reproduzierter Benchmark. Dokumentierte Funktionen, unsere Konfigurationsbeispiele und vorgeschlagene Abnahmetests werden entsprechend getrennt.

## Ersetzt das CLAUDE.md, Cursor-Regeln oder das eingebaute Gedächtnis?

**Nein. Stabile Anweisungen gehören ins Repository, veränderliche und belegte Projekthistorie in den gemeinsamen Speicher.** Die Behauptung, Claude Code beginne jede Sitzung völlig ohne dauerhaften Kontext, greift zu kurz: Die [Memory-Dokumentation von Claude Code](https://code.claude.com/docs/en/memory) beschreibt Anweisungsdateien und Auto Memory. Auch [Cursor-Regeln](https://cursor.com/docs/rules) bewahren Anweisungen. Daraus folgt jedoch nicht, dass verschiedene Tools eine gemeinsame, durchsuchbare Entscheidungshistorie nutzen.

| Information | Geeigneter Ort | Begründung |
| --- | --- | --- |
| Build-Befehle, Verzeichnisregeln und verpflichtende Prüfungen | Versionierte Anweisungen, etwa CLAUDE.md, AGENTS.md oder Cursor-Regeln | Prüfbare Vorgaben sollen mit dem Code versioniert werden. |
| Warum ein Ansatz verworfen wurde oder welche Migration einen Fehler auslöste | Abgegrenzter gemeinsamer Speicher mit Verweisen auf Entscheidungen, Commits und Tests | Historische Begründungen sollen über Sitzungen hinweg auffindbar bleiben. |
| Wie die Anwendung aktuell tatsächlich funktioniert | Aktueller Code, Konfiguration und ausführbare Tests | Eine gespeicherte Aussage kann inzwischen überholt sein. |

Die entscheidende Einstiegsfrage lautet deshalb: Rekonstruiert das Team beim Wechsel zwischen Claude Code, Cursor und OpenCode immer wieder dieselben Begründungen? Beginnen Sie mit diesem Problem, statt ein zweites, widersprüchliches Regelwerk aufzubauen.

## mcp-memory-service installieren: Installation ist noch keine Integration

Der einfache Installationsbefehl lautet:

```
pip install mcp-memory-service
```

Der [PyPI-Eintrag](https://pypi.org/project/mcp-memory-service/) nennt Version **11.13.0** vom 19. September 2026, Python ab Version 3.10 und die Apache-2.0-Lizenz. Unser Beispiel fixiert diese geprüfte Version, statt spätere Veröffentlichungen automatisch zu übernehmen.

```
python3 -m venv "$HOME/.venvs/mcp-memory-service"
"$HOME/.venvs/mcp-memory-service/bin/python" -m pip install "mcp-memory-service==11.13.0"
mkdir -p "$HOME/.local/share/agent-memory/example-app"
"$HOME/.venvs/mcp-memory-service/bin/memory" server --help
```

Diese Shell-Befehle sind für macOS und Linux gedacht. Unter Windows müssen Sie insbesondere die ausführbare Datei der virtuellen Umgebung und die absoluten Speicherpfade anpassen. Übernehmen Sie POSIX-Pfade nicht unverändert. Nutzen Sie das im Team etablierte Verfahren zur Verwaltung von Python-Umgebungen.

Der [offizielle Einrichtungsleitfaden](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/setup-guide.md) dokumentiert `memory server` und die Verbindung zum Client. Die Installation eines Python-Pakets registriert nicht automatisch einen MCP-Server in jeder IDE, importiert keine alten Gespräche und sorgt nicht dafür, dass jede neue Sitzung Erinnerungen abruft.

## Die entscheidende Einstellung: dieselbe Datenbank für alle Clients

**Dasselbe Paket mit unterschiedlichen Datenbankpfaden bedeutet getrennte Erinnerungen.** Im folgenden Beispiel für einen Benutzer auf einem Rechner verwenden alle drei Clients dieselbe ausführbare Datei und dieselbe absolute SQLite-Datei. Die [Konfigurationsreferenz](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/mastery/configuration-guide.md) dokumentiert `MCP_MEMORY_STORAGE_BACKEND`, `MCP_MEMORY_SQLITE_PATH` und `MCP_MEMORY_USE_ONNX`.

Ersetzen Sie `example-app` überall einheitlich durch ein Projekt beziehungsweise einen klar abgegrenzten Vertrauensbereich. Trennen Sie die Repositories unterschiedlicher Kunden auch beim Speicher, statt Tags als Zugriffsschutz zu behandeln. Der Pfad verweist auf eine Datei, nicht nur auf deren Verzeichnis. Container, Remote-Entwicklungsrechner und andere Betriebssystemkonten teilen nicht automatisch Ihr Home-Verzeichnis, nur weil ihre Konfiguration ähnlich aussieht.

Jeder MCP-Client startet in diesem Beispiel einen stdio-Prozess für denselben lokalen Speicher. Das ist kein Konzept für einen Mehrbenutzerbetrieb. Prüfen Sie parallele Zugriffe vor der produktiven Nutzung. Legen Sie eine aktive SQLite-Datenbank weder in Git noch in einen synchronisierten Ordner, den Sie wie eine Datenbankreplikation behandeln.

## Claude Code über lokales MCP verbinden

Führen Sie diesen Befehl im Projekt aus, für das die Verbindung verfügbar sein soll:

```
claude mcp add \
  --env MCP_MEMORY_STORAGE_BACKEND=sqlite_vec \
  --env MCP_MEMORY_SQLITE_PATH="$HOME/.local/share/agent-memory/example-app/sqlite_vec.db" \
  --env MCP_MEMORY_USE_ONNX=true \
  --transport stdio --scope local \
  memory -- "$HOME/.venvs/mcp-memory-service/bin/memory" server
claude mcp list
```

Das Beispiel folgt dem [offiziellen MCP-Befehlsformat von Claude Code](https://code.claude.com/docs/en/mcp). Mit `--scope local` bleibt die Registrierung in Ihrer lokalen Projektkonfiguration. Die Optionen stehen vor dem Servernamen, die ausführbare Datei hinter dem Trenner `--`. Der explizite Programmpfad vermeidet die Annahme, dass eine IDE denselben PATH wie das Terminal erbt.

Starten oder verbinden Sie den Client anschließend neu und prüfen Sie den Verbindungsstatus sowie die Werkzeuge `memory_store` und `memory_search`. Geben Sie nur erwartete Aktionen frei. Ein verbundener Server beweist noch nicht, dass bereits ein Eintrag gespeichert wurde.

## Cursor für denselben Memory-Speicher konfigurieren

Ergänzen Sie diesen Eintrag in der projektbezogenen Datei `.cursor/mcp.json`. Erhalten Sie dabei bereits konfigurierte Server:

```
{
  "mcpServers": {
    "memory": {
      "type": "stdio",
      "command": "${userHome}/.venvs/mcp-memory-service/bin/memory",
      "args": [
        "server"
      ],
      "env": {
        "MCP_MEMORY_STORAGE_BACKEND": "sqlite_vec",
        "MCP_MEMORY_SQLITE_PATH": "${userHome}/.local/share/agent-memory/example-app/sqlite_vec.db",
        "MCP_MEMORY_USE_ONNX": "true"
      }
    }
  }
}
```

Die [MCP-Dokumentation von Cursor](https://cursor.com/docs/mcp) beschreibt die stdio-Felder und unterstützt die Ersetzung von `${userHome}`. Prüfen Sie den aufgelösten Pfad, verbinden Sie den Server neu und lesen Sie bei fehlenden Werkzeugen die MCP-Ausgabe. Zugangsdaten und Datenbanken aus Kundenprojekten gehören nicht in eine eingecheckte Projektkonfiguration.

Dass beide Clients einen Server namens „memory“ anzeigen, beweist keine gemeinsame Datenhaltung. Der unten beschriebene Test prüft die tatsächliche Verbindung zwischen Datenbank und Werkzeugaufrufen.

## OpenCode: MCP-Verbindung und Auto-Capture-Plugin unterscheiden

Für dieselbe lokale MCP-Anbindung ergänzen Sie `opencode.json`:

```
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "memory": {
      "type": "local",
      "command": [
        "{env:HOME}/.venvs/mcp-memory-service/bin/memory",
        "server"
      ],
      "enabled": true,
      "environment": {
        "MCP_MEMORY_STORAGE_BACKEND": "sqlite_vec",
        "MCP_MEMORY_SQLITE_PATH": "{env:HOME}/.local/share/agent-memory/example-app/sqlite_vec.db",
        "MCP_MEMORY_USE_ONNX": "true"
      }
    }
  }
}
```

Die [MCP-Referenz von OpenCode](https://opencode.ai/docs/mcp-servers/) verwendet `type: local`, ein Befehlsarray und `environment`, nicht Cursors Feld `env`. Die [Konfigurationsreferenz](https://opencode.ai/docs/config/) dokumentiert die Ersetzung von `{env:HOME}`. Unser Beispiel kombiniert diese dokumentierten Client-Einstellungen mit dem Serverbefehl des Projekts. Wir haben diese Drei-Client-Konfiguration nicht praktisch ausgeführt.

Das separate [Memory-Awareness-Plugin](https://github.com/doobidoo/mcp-memory-service/blob/main/opencode/README.md) nutzt dagegen die HTTP-REST-API für den Abruf beim Sitzungsstart und die automatische Erfassung. Seine Dateien stammen aus dem Repository und werden nicht allein durch pip installiert. MCP stellt Werkzeuge bereit; das Plugin ergänzt Automatisierung im Sitzungsablauf. Das sind unterschiedliche Integrationswege.

Beginnen Sie mit einem Weg. Beide ohne klare Erfassungsregeln parallel einzuführen, erschwert die Zuordnung von Einträgen. Das stdio-Beispiel benötigt keinen HTTP-Listener. Ein optionaler Plugin-Betrieb erfordert eine gesonderte Prüfung von Endpunkt, Authentifizierung und Netzwerkzugriff.

## Prüfen, ob Erinnerungen Neustart und IDE-Wechsel überstehen

**Prüfen Sie den tatsächlichen Abruf, nicht die Zusicherung des Agenten.** Fordern Sie Claude Code ausdrücklich auf, mit `memory_store` eine fiktive Entscheidung mit dem Tag `project:example-app` zu speichern: „Zahlungsereignisse verwenden eine Outbox, damit nach einer bestätigten Zahlung das nachgelagerte Ereignis nicht verloren gehen kann.“ Ergänzen Sie eine fiktive Entscheidungsreferenz, Status und Datum. Verwenden Sie keine echten Kundendaten.

Kontrollieren Sie die erfolgreiche Rückmeldung des Speicherwerkzeugs. Schließen Sie die Sitzung. Fragen Sie in einer neuen Cursor-Sitzung mit einem ausdrücklichen Aufruf von `memory_search` nach dem Grund für die Zahlungs-Outbox. Vergleichen Sie Kennung und Inhalt des zurückgegebenen Eintrags. Eine plausible Antwort aus allgemeinem Modellwissen reicht nicht. Wiederholen Sie den Test in OpenCode und nach einem Neustart der Client-Prozesse.

Ergänzen Sie einen Negativtest: Ein anderes Projekt darf die Entscheidung unter dem gewählten Isolationskonzept nicht abrufen können. Ein Tag grenzt Suchergebnisse ein, ersetzt aber keine Sicherheitsgrenze. Prüfen Sie fehlende und unerwünschte Treffer, bevor Sie automatische Erfassung aktivieren.

## Lokale ONNX-Embeddings: Was „keine externen API-Aufrufe“ wirklich bedeutet

**Lokale Embedding-Berechnung macht nicht den gesamten Coding-Workflow offline.** [ONNX Runtime](https://onnxruntime.ai/docs/get-started/with-python.html) kann ein vorhandenes Modell lokal ausführen. Paketinstallation und erstmaliger Modelldownload sind davon getrennte Netzwerkvorgänge. Ein cloudbasiertes Coding-Modell kann gespeicherte Inhalte weiterhin erhalten, wenn der Client Werkzeugergebnisse in seinen Kontext übernimmt.

Für mehrsprachige Teams kommt eine weitere Grenze hinzu. Die [Modellkarte von all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) beschreibt das Standardmodell als englischsprachig, mit 384-dimensionalen Vektoren und standardmäßiger Kürzung nach 256 Word Pieces. Eine deutsche Oberfläche belegt keine zuverlässige Suche zwischen deutschen Fragen und englischen Einträgen. Bei langen Gesprächsexporten kann relevanter Inhalt schon vor der Vektorberechnung wegfallen.

Die [Beispielkonfiguration der Umgebungsvariablen](https://github.com/doobidoo/mcp-memory-service/blob/main/.env.example) enthält Einstellungen für Modelle, Anbieter und optionale Funktionen. Prüfen Sie diese konkret. „Local-first“ beweist keine bestimmte Datengrenze. Cloud- oder Hybrid-Speicher, externe Qualitätsbewertung und LLM-gestützte Erfassung müssen gesondert entschieden werden.

Unser vorgeschlagener Sprachtest: Speichern Sie eine genehmigte Entscheidung auf Englisch und fragen Sie mit realistischen Entwicklerformulierungen auf Deutsch, Spanisch und Chinesisch danach. Messen Sie, ob der richtige Eintrag erscheint, nicht ob das Modell eine Antwort übersetzen kann. Ein Modellwechsel erfordert eine abgesicherte Migration mit erneuter Embedding-Berechnung, auch wenn die Vektordimension gleich bleibt.

## Ruft mcp-memory-service Kontext wirklich in 5 ms ab?

**5 ms sind eine Leistungsangabe des Projekts, keine in diesem Artikel nachgewiesene Ende-zu-Ende-Garantie.** Aus der [Aussage im Repository](#source-01) sollte nicht werden: „Jede historische Entscheidung und jede Graphbeziehung wird in 5 ms geliefert.“ Wir haben diesen Wert nicht unabhängig reproduziert.

Trennen Sie für eine sinnvolle Messung Prozessstart, erstmaliges Laden des Modells, Embedding der Anfrage, Datenbanksuche, Graph-Erweiterung und Client-Transport. Messen Sie anschließend den vollständigen Werkzeugaufruf. Eine Datenbankabfrage bei warmem Cache ist etwas anderes als eine kalte Suche, eine Remote-Anfrage oder die fertige Antwort des Coding-Modells.

Dokumentieren Sie Rechner, Modell, Anzahl und Länge der Einträge, Anfragetypen, parallele Clients und Aufwärmbedingungen. Stellen Sie Median und langsame Ausreißer neben die fachliche Richtigkeit der Treffer. Unsere Entscheidungsregel: Ein paar gesparte Millisekunden helfen nicht, wenn der Agent eine überholte Architekturentscheidung überzeugend als aktuell darstellt.

## Kausales Gedächtnis zur Fehlersuche: Verknüpfungen sind noch kein Beweis

Die [Dokumentation zum Wissensgraphen](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/features/knowledge-graph-dashboard.md) beschreibt unter anderem `causes`, `fixes`, `contradicts`, `supports`, `follows` und `related`. Diese Beziehungstypen können eine Untersuchungskette abbilden. Sie beweisen nicht, dass deren Schlussfolgerung stimmt.

Ein **fiktives** Beispiel: Commit `demo-change-A` entfernt einen Idempotenzschutz. Fehler `DEMO-42` dokumentiert doppelte Zahlungsereignisse. Patch `demo-fix-B` stellt den Schutz wieder her. Der Regressionstest `test_duplicate_event` reproduziert den Fehler vor dem Patch und läuft danach erfolgreich. Speichern Sie die Verweise auf diese Belege zusammen mit der Aussage. Unterscheiden Sie „vermutete Ursache“ von „im geprüften Test bestätigt“.

Ersetzt eine spätere Migration das Design, sollte die Historie erhalten bleiben, die alte Empfehlung aber als abgelöst markiert werden. Ein semantisch passender Treffer kann sonst zu einer falschen technischen Empfehlung werden. Vor einer Änderung sollte der Agent aktuellen Code und relevanten Test prüfen.

## Praktische Regeln: Entscheidungen erfassen, gezielt suchen, Altes kennzeichnen

Unser vorgeschlagenes Eintragsmuster enthält Projekt, Komponente, Entscheidung, Begründung, Belegstelle, Quell-Commit, Autor oder Prüfer, Status, Erfassungsdatum und nächsten Prüfanlass. Das ist eine redaktionelle Vorlage für den Inhalt, keine Behauptung über verpflichtende API-Parameter. Speichern Sie pro Eintrag einen dauerhaften Gedanken. Nicht jede vorläufige Überlegung ist eine genehmigte Entscheidung.

Suchen Sie zu Aufgabenbeginn nach der betroffenen Komponente und prüfen Sie den Status der gefundenen Belege. Speichern Sie zum Abschluss nur verifizierte Änderungen und ausdrücklich gekennzeichnete offene Fragen. Trennen Sie „ausprobiert“ von „vom Team genehmigt“. Wichtige betriebliche Bedeutung sollte nicht ohne Prüfung durch automatische Zusammenfassung verändert werden.

Der [Leitfaden zum tokensparenden Abruf](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/token-efficient-retrieval.md) beschreibt begrenzte Trefferzahlen und graphbasierte Exploration. Dieses beispielhafte Argumentobjekt für `memory_search` begrenzt Treffer und Zeichen. `6000` ist unser Beispielbudget, weder eine Leistungsempfehlung des Projekts noch eine Tokenanzahl:

```
{
  "query": "Why does example-app use an outbox for payment events?",
  "tags": [
    "project:example-app"
  ],
  "limit": 5,
  "max_response_chars": 6000
}
```

Der Entity-Graph benötigt eine eigene Funktionsprüfung. Ein leeres Ergebnis von `memory_explore` kann bedeuten, dass noch keine Entitäten angelegt wurden, obwohl Texteinträge vorhanden sind. Die dokumentierte Einstellung `MCP_ENTITY_LINKING_ENABLED=1` wirkt auf neu gespeicherte Einträge. Für bestehende Inhalte ist ein ausdrücklich geplanter Wartungs- oder Nachverarbeitungsschritt erforderlich. Führen Sie keinen schreibenden Wartungsbefehl blind aus, nur um einen leeren Graphen zu füllen.

## Fehlersuche: Erinnerungen fehlen, verschwinden oder passen nicht

| Symptom | Zuerst prüfen | Benötigter Nachweis |
| --- | --- | --- |
| Funktioniert in Claude Code, nicht in Cursor | Programmpfad, Umgebung, absoluter Datenbankpfad und Betriebssystemkonto | Aufgelöste Einstellungen vergleichen und dieselbe Eintragskennung abrufen. |
| Einträge fehlen nach einem Neustart | Erfolgreiches Schreiben, flüchtige Containerpfade und erneut geöffneter Speicher | Speichern, schließen, neu öffnen und suchen, ohne Gesprächshistorie zu verwenden. |
| Werkzeug verbunden, Agent vergisst trotzdem | Ob Memory-Werkzeuge überhaupt aufgerufen wurden | Tatsächliche Aufrufe prüfen und einen ausdrücklichen Abrufablauf festlegen. |
| Textsuche funktioniert, Graph bleibt leer | Entity-Linking-Konfiguration und vorhandene Entitäten | Entitäten zählen, bevor eine geprüfte Nachverarbeitung geplant wird. |
| Deutsche Fragen finden englische Entscheidungen nicht | Embedding-Modell, Sprache, Textlänge und Filter | Bekannte Einträge mit gleichbedeutenden mehrsprachigen Fragen testen. |
| Dimensionsfehler nach einem Modellwechsel | Modellauswahl, Modellcache und Kompatibilität bestehender Vektoren | Neue Schreibvorgänge stoppen, Sicherung erhalten und Neuberechnung planen. |
| Sporadische Fehler bei mehreren Clients | Parallele Schreibzugriffe, Speicherort und Prozessprotokolle | Mit kontrollierten Clients reproduzieren, bevor Datenbankeinstellungen geändert werden. |

## Sicherheitsgrenzen für ein gemeinsames Agentengedächtnis

**Behandeln Sie abgerufene Erinnerungen als ungeprüfte Belege, nicht als übergeordnete Anweisungen.** Ein Eintrag mit „Ignoriere vorherige Anweisungen“ bleibt Dateninhalt. Jedes Projekt sollte nur die erforderlichen Speicher und Werkzeuge erreichen. Ein Kundendokument darf Entwicklungsregeln nicht unbemerkt überschreiben.

Die [MCP-Sicherheitshinweise](https://modelcontextprotocol.io/docs/2025-11-25/tutorials/security/security_best_practices) bieten einen Ausgangspunkt zur Prüfung von Autorisierung und Transport. Unsere betriebliche Empfehlung: Beginnen Sie lokal über stdio, schließen Sie Geheimnisse und Kundentranskripte aus und prüfen Sie einen gemeinsam erreichbaren Endpunkt gesondert. Legen Sie für HTTP Bind-Adresse, Authentifizierung, Berechtigungen, Transportschutz und zulässige Clients ausdrücklich fest. Übernehmen Sie kein Beispiel mit anonymem Zugriff in einen netzwerkseitig erreichbaren Betrieb.

Bestimmen Sie vor automatischer Erfassung, wer Korrekturen, Löschung, Aufbewahrung und Wiederherstellung verantwortet. Testen Sie konsistente Sicherung und Wiederherstellung und prüfen Sie, dass gelöschte oder abgelöste Einträge nicht aus einem zweiten Speicher zurückkehren. Open Source, lokale Embeddings und Tags belegen für sich weder Compliance noch Mandantentrennung.

## Ein kleiner Pilot mit aussagekräftigen Abnahmekriterien

Beginnen Sie vor dem Import eines Archivs mit einem bewusst kleinen Bestand. Unser vorgeschlagener Pilot, kein veröffentlichter Benchmark: zehn genehmigte Entscheidungen, fünf abgelöste Entscheidungen, fünf Fehlerbehebungsketten und fünf sprachübergreifende Fragen. Nehmen Sie auch Einträge auf, die ein anderes Projekt nicht sehen darf.

| Prüfung | Aussagekräftiges Ergebnis |
| --- | --- |
| Kontinuität zwischen Tools | Eine neue Sitzung in jedem Client findet dieselbe Entscheidung mit Kennung und Beleg. |
| Aktualität | Die Antwort nennt die gültige Entscheidung und kennzeichnet die alte als abgelöst. |
| Isolation | Ein Client außerhalb des festgelegten Vertrauensbereichs kann fremde Projekterinnerungen nicht lesen. |
| Belegte Fehlersuche | Der Agent findet Hypothese, Korrektur und Regressionstest, ohne einen Kausalitätsbeweis zu erfinden. |
| Kosten und Latenz | Dauer des Werkzeugaufrufs, Umfang des abgerufenen Kontexts und externe Aufrufe werden getrennt erfasst. |
| Ausfall und Wiederherstellung | Der Agent meldet fehlenden Speicherzugriff ehrlich; eine geprüfte Wiederherstellung erhält die erwarteten Einträge. |

Behalten Sie den Dienst, wenn der Pilot wiederholte Erklärungen reduziert, ohne veraltete oder projektfremde Empfehlungen zu vermehren. Bleiben Sie bei Repository-Anweisungen, wenn vor allem klare Konventionen fehlen. Unser [OpenViking-Review](/de/blog/openviking-agent-memory-review/) behandelt strukturierte Kontextsuche. Der [Supermemory-Leitfaden](/de/blog/supermemory-ai-agent-memory/) betrachtet Anwendungsgedächtnis und andere Betriebsmodelle.

Unterstützung bei der Umsetzung bieten unsere [Leistungen für KI-Entwicklung](/de/services/artificial-intelligence/). Die [Twinsoft-AI-Fallstudie](/de/case-studies/twinsoft-ai/) liefert angrenzenden Projektkontext, belegt aber keinen Einsatz dieses Tools. Mit unserer [Software-QA-Checkliste vor dem Launch](/de/software-development-guide/software-qa-checklist-before-launch/) lassen sich Pilotprüfungen in Freigabekriterien übersetzen. Für eine abgegrenzte Integration [sprechen Sie mit unserem Team](/de/contact/).

## Häufige Fragen zu mcp-memory-service

### Was ist mcp-memory-service?

Ein quelloffener Dienst für dauerhafte Erinnerungen, über den Coding-Agenten Projektkontext speichern und abrufen können. Dieser Leitfaden verbindet Claude Code, Cursor und OpenCode per lokalem MCP mit derselben SQLite-Datenbank.

### Erinnert sich nach der Installation jede Sitzung automatisch?

Nein. Das Paket muss installiert, jeder Client konfiguriert und ein erfolgreicher Schreibvorgang geprüft werden. Zusätzlich braucht es einen Abrufablauf. Automatische Erfassung und Abruf beim Sitzungsstart hängen von der aktivierten Integration ab.

### Können Claude Code und Cursor dieselben Erinnerungen verwenden?

Ja, wenn ihre konfigurierten Dienste auf denselben Speicher mit passendem Zugriff zugreifen. Vergleichen Sie im lokalen Beispiel den aufgelösten absoluten SQLite-Pfad und prüfen Sie, ob ein neuer Client dieselbe Eintragskennung abruft.

### Ersetzt der Dienst CLAUDE.md oder Cursor-Regeln?

Nein. Stabile, prüfbare Projektanweisungen bleiben dort sinnvoll aufgehoben. Gemeinsame Erinnerungen ergänzen veränderliche Entscheidungen und Fehlerhistorie. Abgerufene Empfehlungen müssen mit dem aktuellen Code abgeglichen werden.

### Ist das OpenCode-Memory-Plugin dasselbe wie ein MCP-Server?

Nein. Eine lokale MCP-Konfiguration stellt Memory-Werkzeuge bereit. Das separate Memory-Awareness-Plugin nutzt HTTP REST für Sitzungsautomatisierung und benötigt Dateien aus dem Repository. Die pip-Installation allein installiert dieses Plugin nicht.

### Ist mcp-memory-service vollständig offline und ohne API-Kosten?

Ein lokaler Embedding-Pfad kann externe Embedding-API-Aufrufe vermeiden, sobald die erforderlichen Dateien vorhanden sind. Installation, Modelldownloads, optionale Cloud-Funktionen und das Coding-Modell haben eigene Netzwerk- und Kostengrenzen. Selbstbetrieb verursacht ebenfalls Betriebskosten.

### Gelten die 5 ms für jede Suche und Graphabfrage?

Das weist dieser Artikel nicht nach. Die 5 ms sind eine veröffentlichte Projektangabe, keine Garantie für Embedding-Erzeugung, Kaltstarts, Remote-Transport, Graph-Erweiterung oder eine vollständige Modellantwort. Messen Sie die eigenen Werkzeugaufrufe.

### Warum bleibt memory_explore leer, obwohl Einträge vorhanden sind?

Texteinträge und angelegte Graphentitäten sind unterschiedliche Dinge. Prüfen Sie Entity-Linking und den vorhandenen Entitätenbestand. Aktiviertes Linking betrifft neu gespeicherte Inhalte; die Nachverarbeitung alter Einträge ist ein gesonderter, abzusichernder Wartungsvorgang.

Modelle und Infrastruktur

## In diesem Cluster weiterlesen

Modellauswahl, Inferenzkosten, lokaler Betrieb, Kompression und Serving-Architektur.

[Mit dem Grundlagenartikel starten**LLMs in der EU selbst hosten: Wann sich Open Weights wirklich rechnen**](/de/blog/self-hosting-llms-eu-cost/)

- [Laya vs Jev: Benchmarks und das Risiko für KI-Startups](/de/blog/laya-vs-jev-benchmark-ai-startup-moat/)
- [Jev AI im Test: Entscheidungsmodelle für Agenten](/de/blog/jev-ai-decision-model-review/)
- [SwarmLLM Test 2026: Browser-P2P-Inferenz auf Smartphone und Laptop](/de/blog/swarmllm-browser-p2p-inference-review-2026/)
- [Phonely Alma im Test: Ist das Voice-LLM produktionsreif?](/de/blog/phonely-alma-voice-llm-review/)
- [Utopia: Temporalen Wissensgraph im Unternehmen prüfen](/de/blog/utopia-temporal-knowledge-graph/)

[**Zurück**](/de/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/de/team/kevin-riedl/)

[Kevin Riedl](/de/team/kevin-riedl/) https://linkedin.com/in/wsdt

15 Min. Lesezeit · 24. Sep. 2026 Zuletzt geprüft 24. September 2026

[**Weiter**](/de/blog/openviking-agent-memory-review/)

## Structured Data

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@id": "https://wavect.io/#organization",
      "@type": [
        "Organization",
        "ProfessionalService",
        "LocalBusiness"
      ],
      "employee": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "founder": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "legalRepresentative": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "name": "Wavect GmbH",
      "subjectOf": {
        "@id": "https://wavect.io/verified-claims.json#dataset",
        "@type": "Dataset",
        "creator": {
          "@id": "https://wavect.io/#organization",
          "@type": [
            "Organization",
            "ProfessionalService",
            "LocalBusiness"
          ]
        },
        "description": "A machine-readable registry of quantitative and qualitative claims published by Wavect, with review dates, localized page appearances and public third-party citations where available.",
        "inLanguage": "en",
        "isAccessibleForFree": true,
        "license": "https://creativecommons.org/licenses/by/4.0/",
        "name": "Wavect verified publication claims",
        "url": "https://wavect.io/verified-claims.json"
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/team/kevin-riedl/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Kevin Riedl",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796365",
        "https://www.linkedin.com/in/wsdt",
        "https://github.com/wsdt"
      ],
      "url": "https://wavect.io/team/kevin-riedl/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/team/christof-jori/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Christof Jori",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796367",
        "https://www.linkedin.com/in/jocr77/",
        "https://github.com/jo-chris"
      ],
      "url": "https://wavect.io/team/christof-jori/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/#website",
      "@type": "WebSite",
      "inLanguage": [
        "en",
        "de",
        "es",
        "zh"
      ],
      "name": "Wavect",
      "potentialAction": {
        "@type": "SearchAction",
        "query-input": "required name=search_term_string",
        "target": {
          "@type": "EntryPoint",
          "urlTemplate": "https://wavect.io/search/?q={search_term_string}"
        }
      },
      "publisher": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/#webpage",
      "@type": "WebPage",
      "dateModified": "2026-09-24",
      "inLanguage": "de",
      "isPartOf": {
        "@id": "https://wavect.io/#website",
        "@type": "WebSite"
      },
      "lastReviewed": "2026-09-24",
      "url": "https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "abstract": "mcp-memory-service ist ein dauerhafter gemeinsamer Speicher für KI-Coding-Tools. Sein stärkster Anwendungsfall ist der Abruf von Projektentscheidungen über Claude Code, Cursor und OpenCode hinweg, nicht der Ersatz versionierter Anweisungen. Konfigurieren Sie dieselbe lokale Datenbank, prüfen Sie echte Abrufe zwischen den Clients und speichern Sie Belege sowie Entscheidungsstatus. Lokale ONNX-Berechnung macht ein Cloud-Coding-Modell nicht offline. Die 5 ms sind eine Projektangabe, kein von uns reproduzierter Benchmark.",
  "articleBody": " Blog-Übersicht/AI und Agents/Modelle und Infrastruktur mcp-memory-service: Gemeinsames Gedächtnis für Claude Code und Cursor TL;DR mcp-memory-service ist ein dauerhafter gemeinsamer Speicher für KI-Coding-Tools. Sein stärkster Anwendungsfall ist der Abruf von Projektentscheidungen über Claude Code, Cursor und OpenCode hinweg, nicht der Ersatz versionierter Anweisungen. Konfigurieren Sie dieselbe lokale Datenbank, prüfen Sie echte Abrufe zwischen den Clients und speichern Sie Belege sowie Entscheidungsstatus. Lokale ONNX-Berechnung macht ein Cloud-Coding-Modell nicht offline. Die 5 ms sind eine Projektangabe, kein von uns reproduzierter Benchmark. mcp-memory-service gibt KI-Coding-Agenten einen gemeinsamen, dauerhaften Speicher für Architekturentscheidungen, Fehleranalysen und Projektkonventionen. Der Nutzen besteht nicht darin, ein unbegrenztes Gespräch im Modell zu behalten. Eine neue Sitzung kann relevante Einträge aus einer anderen Sitzung oder einem anderen Tool abrufen, sofern beide Clients denselben Speicher erreichen und die Memory-Werkzeuge tatsächlich verwenden. Das offizielle Repository beschreibt lokale Embeddings, semantische Suche und typisierte Beziehungen in einem Wissensgraphen. Quellenprüfung: 24. September 2026. Dieser Leitfaden basiert auf Dokumentation. Er ist weder ein Bericht über eine praktisch durchgeführte Integration noch ein unabhängig reproduzierter Benchmark. Dokumentierte Funktionen, unsere Konfigurationsbeispiele und vorgeschlagene Abnahmetests werden entsprechend getrennt. Ersetzt das CLAUDE.md, Cursor-Regeln oder das eingebaute Gedächtnis? Nein. Stabile Anweisungen gehören ins Repository, veränderliche und belegte Projekthistorie in den gemeinsamen Speicher. Die Behauptung, Claude Code beginne jede Sitzung völlig ohne dauerhaften Kontext, greift zu kurz: Die Memory-Dokumentation von Claude Code beschreibt Anweisungsdateien und Auto Memory. Auch Cursor-Regeln bewahren Anweisungen. Daraus folgt jedoch nicht, dass verschiedene Tools eine gemeinsame, durchsuchbare Entscheidungshistorie nutzen. Empfohlene Zuständigkeit für den Kontext von Coding-Agenten InformationGeeigneter OrtBegründung Build-Befehle, Verzeichnisregeln und verpflichtende PrüfungenVersionierte Anweisungen, etwa CLAUDE.md, AGENTS.md oder Cursor-RegelnPrüfbare Vorgaben sollen mit dem Code versioniert werden. Warum ein Ansatz verworfen wurde oder welche Migration einen Fehler auslösteAbgegrenzter gemeinsamer Speicher mit Verweisen auf Entscheidungen, Commits und TestsHistorische Begründungen sollen über Sitzungen hinweg auffindbar bleiben. Wie die Anwendung aktuell tatsächlich funktioniertAktueller Code, Konfiguration und ausführbare TestsEine gespeicherte Aussage kann inzwischen überholt sein. Die entscheidende Einstiegsfrage lautet deshalb: Rekonstruiert das Team beim Wechsel zwischen Claude Code, Cursor und OpenCode immer wieder dieselben Begründungen? Beginnen Sie mit diesem Problem, statt ein zweites, widersprüchliches Regelwerk aufzubauen. mcp-memory-service installieren: Installation ist noch keine Integration Der einfache Installationsbefehl lautet: pip install mcp-memory-service Der PyPI-Eintrag nennt Version 11.13.0 vom 19. September 2026, Python ab Version 3.10 und die Apache-2.0-Lizenz. Unser Beispiel fixiert diese geprüfte Version, statt spätere Veröffentlichungen automatisch zu übernehmen. python3 -m venv \"$HOME/.venvs/mcp-memory-service\" \"$HOME/.venvs/mcp-memory-service/bin/python\" -m pip install \"mcp-memory-service==11.13.0\" mkdir -p \"$HOME/.local/share/agent-memory/example-app\" \"$HOME/.venvs/mcp-memory-service/bin/memory\" server --help Diese Shell-Befehle sind für macOS und Linux gedacht. Unter Windows müssen Sie insbesondere die ausführbare Datei der virtuellen Umgebung und die absoluten Speicherpfade anpassen. Übernehmen Sie POSIX-Pfade nicht unverändert. Nutzen Sie das im Team etablierte Verfahren zur Verwaltung von Python-Umgebungen. Der offizielle Einrichtungsleitfaden dokumentiert memory server und die Verbindung zum Client. Die Installation eines Python-Pakets registriert nicht automatisch einen MCP-Server in jeder IDE, importiert keine alten Gespräche und sorgt nicht dafür, dass jede neue Sitzung Erinnerungen abruft. Die entscheidende Einstellung: dieselbe Datenbank für alle Clients Dasselbe Paket mit unterschiedlichen Datenbankpfaden bedeutet getrennte Erinnerungen. Im folgenden Beispiel für einen Benutzer auf einem Rechner verwenden alle drei Clients dieselbe ausführbare Datei und dieselbe absolute SQLite-Datei. Die Konfigurationsreferenz dokumentiert MCP_MEMORY_STORAGE_BACKEND, MCP_MEMORY_SQLITE_PATH und MCP_MEMORY_USE_ONNX. Ersetzen Sie example-app überall einheitlich durch ein Projekt beziehungsweise einen klar abgegrenzten Vertrauensbereich. Trennen Sie die Repositories unterschiedlicher Kunden auch beim Speicher, statt Tags als Zugriffsschutz zu behandeln. Der Pfad verweist auf eine Datei, nicht nur auf deren Verzeichnis. Container, Remote-Entwicklungsrechner und andere",
  "articleSection": "Entwicklung",
  "author": {
    "@id": "https://wavect.io/team/kevin-riedl/#person",
    "@type": "Person",
    "name": "Kevin Riedl",
    "sameAs": [
      "https://www.wikidata.org/wiki/Q139796365",
      "https://www.linkedin.com/in/wsdt",
      "https://github.com/wsdt"
    ],
    "url": "https://wavect.io/team/kevin-riedl/"
  },
  "citation": [
    {
      "@type": "WebPage",
      "name": "offizielle Repository",
      "url": "https://github.com/doobidoo/mcp-memory-service"
    },
    {
      "@type": "WebPage",
      "name": "Memory-Dokumentation von Claude Code",
      "url": "https://code.claude.com/docs/en/memory"
    },
    {
      "@type": "WebPage",
      "name": "Cursor-Regeln",
      "url": "https://cursor.com/docs/rules"
    },
    {
      "@type": "WebPage",
      "name": "PyPI-Eintrag",
      "url": "https://pypi.org/project/mcp-memory-service/"
    },
    {
      "@type": "WebPage",
      "name": "offizielle Einrichtungsleitfaden",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/setup-guide.md"
    },
    {
      "@type": "WebPage",
      "name": "Konfigurationsreferenz",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/mastery/configuration-guide.md"
    },
    {
      "@type": "WebPage",
      "name": "offiziellen MCP-Befehlsformat von Claude Code",
      "url": "https://code.claude.com/docs/en/mcp"
    },
    {
      "@type": "WebPage",
      "name": "MCP-Dokumentation von Cursor",
      "url": "https://cursor.com/docs/mcp"
    },
    {
      "@type": "WebPage",
      "name": "MCP-Referenz von OpenCode",
      "url": "https://opencode.ai/docs/mcp-servers/"
    },
    {
      "@type": "WebPage",
      "name": "Konfigurationsreferenz",
      "url": "https://opencode.ai/docs/config/"
    },
    {
      "@type": "WebPage",
      "name": "Memory-Awareness-Plugin",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/opencode/README.md"
    },
    {
      "@type": "WebPage",
      "name": "ONNX Runtime",
      "url": "https://onnxruntime.ai/docs/get-started/with-python.html"
    },
    {
      "@type": "WebPage",
      "name": "Modellkarte von all-MiniLM-L6-v2",
      "url": "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2"
    },
    {
      "@type": "WebPage",
      "name": "Beispielkonfiguration der Umgebungsvariablen",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/.env.example"
    },
    {
      "@type": "WebPage",
      "name": "Dokumentation zum Wissensgraphen",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/features/knowledge-graph-dashboard.md"
    },
    {
      "@type": "WebPage",
      "name": "Leitfaden zum tokensparenden Abruf",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/token-efficient-retrieval.md"
    },
    {
      "@type": "WebPage",
      "name": "MCP-Sicherheitshinweise",
      "url": "https://modelcontextprotocol.io/docs/2025-11-25/tutorials/security/security_best_practices"
    }
  ],
  "dateModified": "2026-09-24",
  "datePublished": "2026-09-24",
  "description": "mcp-memory-service ist ein dauerhafter gemeinsamer Speicher für KI-Coding-Tools. Sein stärkster Anwendungsfall ist der Abruf von Projektentscheidungen über Claude Code, Cursor und OpenCode hinweg, nicht der Ersatz versionierter Anweisungen. Konfigurieren Sie dieselbe lokale Datenbank, prüfen Sie echte Abrufe zwischen den Clients und speichern Sie Belege sowie Entscheidungsstatus. Lokale ONNX-Berechnung macht ein Cloud-Coding-Modell nicht offline. Die 5 ms sind eine Projektangabe, kein von uns reproduzierter Benchmark.",
  "headline": "mcp-memory-service: Gemeinsames Gedächtnis für Claude Code und Cursor",
  "image": "https://wavect.io/img/blog/headers/header_mcp-memory-service-claude-code-cursor.svg",
  "inLanguage": "de",
  "keywords": "KI-Agenten, MCP, mcp-memory-service, Claude Code, Cursor, OpenCode, Persistentes Gedächtnis",
  "mainEntityOfPage": {
    "@id": "https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/",
    "@type": "WebPage"
  },
  "publisher": {
    "@id": "https://wavect.io/#organization",
    "@type": [
      "Organization",
      "ProfessionalService",
      "LocalBusiness"
    ]
  },
  "url": "https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/",
  "wordCount": 2810
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/",
      "name": "Startseite",
      "position": 1
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/overview/",
      "name": "Blog-Übersicht",
      "position": 2
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/topics/ai-agents/",
      "name": "AI und Agents",
      "position": 3
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/clusters/models-infrastructure/",
      "name": "Modelle und Infrastruktur",
      "position": 4
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/de/blog/mcp-memory-service-claude-code-cursor/",
      "name": "mcp-memory-service: Gedächtnis für Claude Code & Cursor",
      "position": 5
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Ein quelloffener Dienst für dauerhafte Erinnerungen, über den Coding-Agenten Projektkontext speichern und abrufen können. Dieser Leitfaden verbindet Claude Code, Cursor und OpenCode per lokalem MCP mit derselben SQLite-Datenbank."
      },
      "name": "Was ist mcp-memory-service?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Nein. Das Paket muss installiert, jeder Client konfiguriert und ein erfolgreicher Schreibvorgang geprüft werden. Zusätzlich braucht es einen Abrufablauf. Automatische Erfassung und Abruf beim Sitzungsstart hängen von der aktivierten Integration ab."
      },
      "name": "Erinnert sich nach der Installation jede Sitzung automatisch?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Ja, wenn ihre konfigurierten Dienste auf denselben Speicher mit passendem Zugriff zugreifen. Vergleichen Sie im lokalen Beispiel den aufgelösten absoluten SQLite-Pfad und prüfen Sie, ob ein neuer Client dieselbe Eintragskennung abruft."
      },
      "name": "Können Claude Code und Cursor dieselben Erinnerungen verwenden?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Nein. Stabile, prüfbare Projektanweisungen bleiben dort sinnvoll aufgehoben. Gemeinsame Erinnerungen ergänzen veränderliche Entscheidungen und Fehlerhistorie. Abgerufene Empfehlungen müssen mit dem aktuellen Code abgeglichen werden."
      },
      "name": "Ersetzt der Dienst CLAUDE.md oder Cursor-Regeln?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Nein. Eine lokale MCP-Konfiguration stellt Memory-Werkzeuge bereit. Das separate Memory-Awareness-Plugin nutzt HTTP REST für Sitzungsautomatisierung und benötigt Dateien aus dem Repository. Die pip-Installation allein installiert dieses Plugin nicht."
      },
      "name": "Ist das OpenCode-Memory-Plugin dasselbe wie ein MCP-Server?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Ein lokaler Embedding-Pfad kann externe Embedding-API-Aufrufe vermeiden, sobald die erforderlichen Dateien vorhanden sind. Installation, Modelldownloads, optionale Cloud-Funktionen und das Coding-Modell haben eigene Netzwerk- und Kostengrenzen. Selbstbetrieb verursacht ebenfalls Betriebskosten."
      },
      "name": "Ist mcp-memory-service vollständig offline und ohne API-Kosten?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Das weist dieser Artikel nicht nach. Die 5 ms sind eine veröffentlichte Projektangabe, keine Garantie für Embedding-Erzeugung, Kaltstarts, Remote-Transport, Graph-Erweiterung oder eine vollständige Modellantwort. Messen Sie die eigenen Werkzeugaufrufe."
      },
      "name": "Gelten die 5 ms für jede Suche und Graphabfrage?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Texteinträge und angelegte Graphentitäten sind unterschiedliche Dinge. Prüfen Sie Entity-Linking und den vorhandenen Entitätenbestand. Aktiviertes Linking betrifft neu gespeicherte Inhalte; die Nachverarbeitung alter Einträge ist ein gesonderter, abzusichernder Wartungsvorgang."
      },
      "name": "Warum bleibt memory_explore leer, obwohl Einträge vorhanden sind?"
    }
  ]
}
```