---
title: "mcp-memory-service: Claude Code + Cursor Memory"
canonical: https://wavect.io/blog/mcp-memory-service-claude-code-cursor/
language: en
description: "Set up shared memory for Claude Code, Cursor and OpenCode with mcp-memory-service. Check SQLite paths, local ONNX embeddings, 5 ms claims and stale decisions."
image: "https://wavect.io/img/blog/headers/header_mcp-memory-service-claude-code-cursor.png"
---

[**Back**](/blog/overview/)

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

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

14 min read · 24 Sep 2026 Last reviewed September 24, 2026

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

# mcp-memory-service: Shared Memory for Claude Code and Cursor

TL;DR

mcp-memory-service is a persistent, shared memory backend for AI coding tools. Its strongest use case is retrieving project decisions across Claude Code, Cursor and OpenCode, not replacing repository instructions or proving that every agent starts with no memory. Configure the same local database, verify real cross-client retrieval, and keep evidence and decision status with each record. Local ONNX inference does not make a cloud coding model offline; 5 ms is an upstream claim, not our benchmark.

**mcp-memory-service gives AI coding agents a shared, persistent store for project decisions, debugging history and conventions.** Its useful promise is not that a model remembers an unlimited conversation. It is that a new session can retrieve relevant records written by another session or tool, provided both clients reach the same store and actually use its memory tools. The [upstream repository](https://github.com/doobidoo/mcp-memory-service) describes local embeddings, semantic retrieval and typed knowledge-graph relationships.

**Source review: 24 September 2026.** This is a documentation-based implementation guide, not a hands-on integration report or an independently reproduced benchmark. It separates the project's published capabilities from our proposed configuration and acceptance tests.

## Does this replace CLAUDE.md, Cursor rules or native memory?

**No. Keep stable instructions in the repository and use shared memory for evolving, evidence-backed history.** The claim that Claude Code starts every session with no persistent context is too broad: [Claude Code's memory documentation](https://code.claude.com/docs/en/memory) describes instruction files and auto memory. [Cursor rules](https://cursor.com/docs/rules) also preserve instructions. Neither fact alone establishes that your different tools share one queryable decision history.

| Information | Preferred home | Reason |
| --- | --- | --- |
| Build commands, directory conventions, mandatory checks | Version-controlled instructions, such as CLAUDE.md, AGENTS.md or Cursor rules | Reviewable policy should travel with the code. |
| Why an approach was rejected; which migration caused a regression | Scoped shared memory with links to decisions, commits and tests | Historical explanations should remain discoverable across sessions. |
| What the application actually does now | Current code, configuration and executable tests | A recalled statement may have become obsolete. |

The adoption question is therefore specific: are developers repeatedly reconstructing the same reasoning when they switch from Claude Code to Cursor or OpenCode? Start there rather than building a second, conflicting policy system.

## Install mcp-memory-service without confusing installation with integration

The requested one-line installation is:

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

The [PyPI listing](https://pypi.org/project/mcp-memory-service/) identifies version **11.13.0**, released on 19 September 2026, Python 3.10 or later and the Apache-2.0 license. The walkthrough pins that reviewed version rather than silently following later releases.

```
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
```

These shell commands target macOS and Linux. On Windows, adapt the virtual-environment executable and absolute storage paths; do not paste POSIX paths unchanged. Use the existing environment-management approach your team supports.

The [upstream setup guide](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/setup-guide.md) documents `memory server` and the client connection step. Installing a Python package does not itself register an MCP server in every IDE, import old conversations or ensure that every new session retrieves memory.

## The important setting: every client must use the same memory database

**Same package, different database path means different memory.** For this single-user, single-machine example, all three clients use the same executable and the same absolute SQLite file. The [configuration reference](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/mastery/configuration-guide.md) documents `MCP_MEMORY_STORAGE_BACKEND`, `MCP_MEMORY_SQLITE_PATH` and `MCP_MEMORY_USE_ONNX`.

Replace `example-app` consistently with one project or trust boundary. Keep unrelated clients' repositories in separate stores rather than expecting a tag to enforce access control. The path points to a file, not just its parent directory. A container, remote development host or different operating-system account will not share your home directory merely because the text of its configuration looks similar.

In the following examples, each MCP client launches a stdio process against that local store. This is not a multi-user deployment design. Test concurrent use before depending on it, and do not put a live SQLite database in Git or treat a synchronized folder as a database replication service.

## Connect Claude Code through local MCP

Run this from the project where the memory connection should be available:

```
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
```

This follows the [official Claude Code MCP command format](https://code.claude.com/docs/en/mcp). `--scope local` keeps the registration private to your local project configuration. Options precede the server name; the `--` separator precedes the executable. The explicit executable path avoids relying on an IDE inheriting your terminal's PATH.

Restart or reconnect the client as appropriate, confirm the server is connected, then check that `memory_store` and `memory_search` are available. Approve only the operations you expect. A connected server is not evidence that a session has already stored anything.

## Configure Cursor to use the same store

Merge the following entry into the project's `.cursor/mcp.json`; preserve any other configured servers:

```
{
  "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"
      }
    }
  }
}
```

The [Cursor MCP documentation](https://cursor.com/docs/mcp) specifies the stdio fields and supports `${userHome}` interpolation. Check the resulting path, reconnect the server and inspect MCP output when a tool is missing. A project config should not contain credentials or a database copied from a customer project.

Do not assume that seeing “memory” in both clients proves they share state. The cross-client test below verifies the database and tool workflow together.

## OpenCode: standard MCP connection versus the auto-capture plugin

For the same local MCP approach, merge this into `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"
      }
    }
  }
}
```

[OpenCode's MCP reference](https://opencode.ai/docs/mcp-servers/) uses `type: local`, a command array and `environment`, not Cursor's `env` field. Its [configuration reference](https://opencode.ai/docs/config/) documents `{env:HOME}` substitution. This example combines those documented client settings with the upstream server command; we have not run this three-client configuration live.

The separate [Memory Awareness plugin](https://github.com/doobidoo/mcp-memory-service/blob/main/opencode/README.md) uses the service's HTTP REST API for session-start retrieval and automatic capture. Its files come from the repository, not from the pip installation alone. Standard MCP makes tools available; the plugin adds lifecycle automation. They are different integration paths.

Choose one path first. Adding both without a capture policy can make ownership harder to understand. The stdio walkthrough does not require an HTTP listener. An optional plugin deployment needs its own endpoint, authentication and network review.

## Verify that memory survives a restart and a change of IDE

**Test retrieval, not the agent's assurance that it remembers.** In Claude Code, explicitly ask it to use `memory_store` for a fictional decision tagged `project:example-app`: “Payment events use an outbox so a committed payment cannot lose its downstream event.” Add a fictional decision reference, status and date, and keep this test free of real customer data.

Inspect the store tool's success result. Close the session. Open a fresh Cursor session and ask it to call `memory_search` for the reason behind the payment outbox. Confirm the returned record identifier and content rather than accepting a plausible answer from general model knowledge. Repeat in OpenCode and once after restarting the client processes.

Then test a negative case: a different project should not be able to retrieve that decision under the isolation design you selected. A search tag can narrow results, but it is not a security boundary. Test both absent results and unwanted results before enabling automatic capture.

## Local ONNX embeddings: what “zero external API calls” actually covers

**Local embedding inference does not make the entire coding workflow offline.** [ONNX Runtime](https://onnxruntime.ai/docs/get-started/with-python.html) can execute an available model locally. Package installation and initial model downloads are separate network events. A cloud-hosted coding model can still receive memories when its client inserts tool results into its context.

There is a second trap for multilingual teams. The default model's [all-MiniLM-L6-v2 model card](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) identifies an English model with 384-dimensional vectors and default truncation beyond 256 word pieces. A German interface is not evidence of strong German-to-English retrieval. Long session dumps can also lose relevant detail before an embedding is produced.

The project's [environment configuration example](https://github.com/doobidoo/mcp-memory-service/blob/main/.env.example) exposes model, provider and optional feature settings. Review those settings rather than treating “local-first” as proof of a particular data boundary. Cloud or hybrid storage, external scoring and LLM-assisted harvesting need separate decisions.

Our suggested multilingual test is simple: store one approved decision in English and ask for it in German, Spanish and Chinese using realistic developer wording. Measure whether the correct record appears, not whether the assistant can translate its own answer. Changing the embedding model calls for a backed-up re-embedding migration even when the new model has the same vector dimensions.

## Does mcp-memory-service really retrieve context in 5 ms?

**5 ms is an upstream performance claim, not an end-to-end guarantee established by this article.** The [repository's headline](#source-01) should not be expanded into “every historical decision and graph relationship is returned in 5 ms.” We have not independently reproduced that number.

For a useful local evaluation, separate process startup, first model load, query embedding, database retrieval, graph expansion and client transport. Then measure the complete tool round trip. A warm database lookup is a different measurement from a cold search, a remote request or the coding model's completed answer.

Record the machine, model, number and length of memories, query types, concurrent clients and warm-up conditions. Report median and slow-tail latency alongside whether the returned evidence is correct. Our decision rule: saving a few milliseconds is not progress when the agent confidently recalls a superseded architecture decision.

## Causal memory for debugging: useful links are not proof of causation

The [knowledge-graph documentation](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/features/knowledge-graph-dashboard.md) describes relationship types including `causes`, `fixes`, `contradicts`, `supports`, `follows` and `related`. They can express an investigation chain; they do not establish that the investigation's conclusion is true.

Consider this **fictional** chain: commit `demo-change-A` removes an idempotency guard; bug `DEMO-42` records duplicate payment events; patch `demo-fix-B` restores the guard; regression test `test_duplicate_event` reproduces the failure before the patch and passes afterward. Store the links to those artifacts with the claim, and distinguish “suspected cause” from “confirmed in the reviewed test.”

When a later migration replaces the design, preserve the historical record but mark the old recommendation superseded. Otherwise, a good semantic match can become bad engineering advice. An agent should inspect the current code and relevant test before acting on the recalled chain.

## A practical memory policy: capture decisions, retrieve narrowly, retire stale advice

Our proposed record template contains: project, component, decision, rationale, evidence location, source commit, author or reviewer, status, recorded date and next review trigger. This is an editorial template for record content, not a claim that every field is a required API parameter. Keep one durable idea per memory. Do not archive every transient thought as an approved decision.

At task start, search for the affected component and check the status of the returned evidence. At task end, store only verified changes and unresolved questions with explicit labels. Keep “we tried this” separate from “the team approved this.” Require review before automated consolidation overwrites important operational meaning.

The [token-efficient retrieval guide](https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/token-efficient-retrieval.md) documents bounded retrieval and graph-first exploration. This illustrative `memory_search` argument object sets a result limit and character budget; `6000` is our example budget, not an upstream performance recommendation or a token count:

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

Entity-graph retrieval is a separate readiness check. An empty `memory_explore` result can mean that entities were never populated, even when text memories exist. The documented `MCP_ENTITY_LINKING_ENABLED=1` setting affects newly stored records; existing records need an explicitly planned maintenance/backfill step. Do not run a mutating maintenance command blindly to make an empty graph look healthy.

## Troubleshooting memory that does not persist or recall correctly

| Symptom | Check first | Evidence to collect |
| --- | --- | --- |
| Works in Claude Code, not Cursor | Executable, environment, absolute database path and operating-system account | Compare resolved settings and retrieve the same record ID. |
| Memory disappears after restarting | Write success, ephemeral container paths and which store was reopened | Repeat a store-close-reopen-search test without relying on conversation history. |
| Tool connected but the agent forgets | Whether memory tools were invoked at all | Inspect the actual tool calls; configure an explicit retrieval workflow. |
| Text search works, graph exploration is empty | Entity-linking configuration and entity population | Inspect entity counts before considering a reviewed backfill. |
| Non-English questions miss English decisions | Embedding model, query language, chunk length and filters | Run paired multilingual queries against known records. |
| Embedding dimensions fail after a model change | Model selection, cached model and existing vector compatibility | Stop new writes, preserve a backup and plan re-embedding. |
| Intermittent failures with several clients | Concurrent writes, storage location and process logs | Reproduce with controlled clients before changing database settings. |

## Security boundaries for a shared coding-agent memory

**Treat a recalled memory as untrusted evidence, not as a higher-priority instruction.** A record quoting “ignore previous instructions” must remain data. Give each project only the storage and tools it needs; do not let a customer-supplied document silently rewrite your development policy.

The [MCP security guidance](https://modelcontextprotocol.io/docs/2025-11-25/tutorials/security/security_best_practices) is a starting point for reviewing authorization and transport risks. Our operational recommendation is to keep the initial stdio setup local, exclude secrets and customer transcripts, and require a separate review before exposing a shared endpoint. For HTTP, explicitly choose the bind address, authentication, authorization, transport protection and permitted clients. Do not copy an anonymous-access demonstration into a network-accessible deployment.

Assign ownership for correction, deletion, retention and recovery before enabling automatic capture. Test a consistent backup and restore procedure and ensure deleted or superseded records do not reappear through a second store. “Open source,” “on-device embeddings” and “tags” do not by themselves establish compliance or tenant isolation.

## A small adoption test with meaningful pass criteria

Use a deliberately small corpus before importing your archive. The following is our proposed pilot, not a published benchmark: ten approved decisions, five superseded decisions, five bug-and-fix chains and five cross-language queries. Include records that should not be visible to another project.

| Test | What a useful result looks like |
| --- | --- |
| Cross-tool continuity | A fresh session in each client retrieves the same stored decision with its identifier and evidence. |
| Decision freshness | The answer identifies the current decision and labels the old one superseded. |
| Isolation | A client outside the chosen trust boundary cannot read another project's memory. |
| Debugging provenance | The agent retrieves the hypothesis, fixing change and regression evidence without inventing a causal proof. |
| Cost and latency | Tool round-trip timings, retrieved context size and any external calls are recorded separately. |
| Failure and recovery | The agent reports unavailable memory instead of pretending to remember; a tested restore preserves expected records. |

Keep the service when this pilot reduces repeated explanation without increasing stale or cross-project advice. Stay with repository instructions when the real problem is missing conventions. For broader context architecture, our [OpenViking review](/blog/openviking-agent-memory-review/) covers structured context retrieval; our [Supermemory guide](/blog/supermemory-ai-agent-memory/) addresses application-level memory and different deployment trade-offs.

For implementation support, see Wavect's [AI engineering services](/services/artificial-intelligence/). The [Twinsoft AI case study](/case-studies/twinsoft-ai/) provides adjacent delivery context, not evidence that this tool was deployed there. Use our [pre-launch software QA checklist](/software-development-guide/software-qa-checklist-before-launch/) to turn the pilot into release criteria, or [discuss a scoped memory integration](/contact/) with the team.

## Frequently asked questions about mcp-memory-service

### What is mcp-memory-service?

It is an open-source persistent memory backend that coding agents can use to store and retrieve project context. This guide uses local MCP connections so Claude Code, Cursor and OpenCode can reach the same SQLite store.

### Does installing it make every session remember automatically?

No. Install the package, configure each client, verify successful writes and establish a retrieval workflow. Session-start retrieval and automatic capture depend on the integration or automation you enable.

### Can Claude Code and Cursor share the same memory?

Yes, when their configured service processes reach the same underlying store with suitable access. In this local example, compare the resolved absolute SQLite path and confirm that a fresh client retrieves the same record identifier.

### Does it replace CLAUDE.md or Cursor rules?

No. Those remain appropriate for stable, reviewable project instructions. Shared memory is a complementary place for evolving decisions and debugging history, and recalled advice must be checked against current code.

### Is the OpenCode memory plugin the same as an MCP server?

No. A standard local MCP configuration exposes memory tools. The separate Memory Awareness plugin uses HTTP REST for lifecycle automation and requires its repository files; pip installation alone does not install that plugin.

### Is mcp-memory-service fully offline and free of API costs?

A local embedding path can avoid external embedding API calls after required assets are available. Installation, model downloads, optional cloud features and the coding model itself have separate network and cost boundaries. Self-hosting also has operating costs.

### Does the 5 ms claim include every search and graph query?

This article does not establish that. Treat 5 ms as the project's published claim, not a guarantee for embedding generation, cold starts, remote transport, graph expansion or a complete model answer. Measure your own tool round trips.

### Why is memory_explore empty when memories exist?

Text records and populated graph entities are different things. Check entity-linking settings and existing entities. Enabling linking affects newly stored records; backfilling old records is a separate maintenance operation that should be reviewed and backed up.

Models and infrastructure

## Continue through this cluster

Model selection, inference economics, local deployment, compression and serving architecture.

[Start with the cornerstone**Self-Hosting LLMs in the EU: When Open Weights Actually Pay Off**](/blog/self-hosting-llms-eu-cost/)

- [Laya vs Jev: What the Benchmarks Mean for AI Startups](/blog/laya-vs-jev-benchmark-ai-startup-moat/)
- [Jev AI Review: Decision Models for Agent Workflows](/blog/jev-ai-decision-model-review/)
- [SwarmLLM Review 2026: Browser P2P LLM Inference Across Phones and Laptops](/blog/swarmllm-browser-p2p-inference-review-2026/)
- [Phonely Alma Review: Is the Voice LLM Ready for Production?](/blog/phonely-alma-voice-llm-review/)
- [Utopia Review: Temporal Knowledge Graph for Enterprise](/blog/utopia-temporal-knowledge-graph/)

[**Back**](/blog/overview/)

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

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

14 min read · 24 Sep 2026 Last reviewed September 24, 2026

[**Next**](/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/blog/mcp-memory-service-claude-code-cursor/#webpage",
      "@type": "WebPage",
      "dateModified": "2026-09-24",
      "inLanguage": "en",
      "isPartOf": {
        "@id": "https://wavect.io/#website",
        "@type": "WebSite"
      },
      "lastReviewed": "2026-09-24",
      "url": "https://wavect.io/blog/mcp-memory-service-claude-code-cursor/"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "abstract": "mcp-memory-service is a persistent, shared memory backend for AI coding tools. Its strongest use case is retrieving project decisions across Claude Code, Cursor and OpenCode, not replacing repository instructions or proving that every agent starts with no memory. Configure the same local database, verify real cross-client retrieval, and keep evidence and decision status with each record. Local ONNX inference does not make a cloud coding model offline; 5 ms is an upstream claim, not our benchmark.",
  "articleBody": " Blog overview/AI and agents/Models and infrastructure mcp-memory-service: Shared Memory for Claude Code and Cursor TL;DR mcp-memory-service is a persistent, shared memory backend for AI coding tools. Its strongest use case is retrieving project decisions across Claude Code, Cursor and OpenCode, not replacing repository instructions or proving that every agent starts with no memory. Configure the same local database, verify real cross-client retrieval, and keep evidence and decision status with each record. Local ONNX inference does not make a cloud coding model offline; 5 ms is an upstream claim, not our benchmark. mcp-memory-service gives AI coding agents a shared, persistent store for project decisions, debugging history and conventions. Its useful promise is not that a model remembers an unlimited conversation. It is that a new session can retrieve relevant records written by another session or tool, provided both clients reach the same store and actually use its memory tools. The upstream repository describes local embeddings, semantic retrieval and typed knowledge-graph relationships. Source review: 24 September 2026. This is a documentation-based implementation guide, not a hands-on integration report or an independently reproduced benchmark. It separates the project's published capabilities from our proposed configuration and acceptance tests. Does this replace CLAUDE.md, Cursor rules or native memory? No. Keep stable instructions in the repository and use shared memory for evolving, evidence-backed history. The claim that Claude Code starts every session with no persistent context is too broad: Claude Code's memory documentation describes instruction files and auto memory. Cursor rules also preserve instructions. Neither fact alone establishes that your different tools share one queryable decision history. Suggested ownership of coding-agent context InformationPreferred homeReason Build commands, directory conventions, mandatory checksVersion-controlled instructions, such as CLAUDE.md, AGENTS.md or Cursor rulesReviewable policy should travel with the code. Why an approach was rejected; which migration caused a regressionScoped shared memory with links to decisions, commits and testsHistorical explanations should remain discoverable across sessions. What the application actually does nowCurrent code, configuration and executable testsA recalled statement may have become obsolete. The adoption question is therefore specific: are developers repeatedly reconstructing the same reasoning when they switch from Claude Code to Cursor or OpenCode? Start there rather than building a second, conflicting policy system. Install mcp-memory-service without confusing installation with integration The requested one-line installation is: pip install mcp-memory-service The PyPI listing identifies version 11.13.0, released on 19 September 2026, Python 3.10 or later and the Apache-2.0 license. The walkthrough pins that reviewed version rather than silently following later releases. 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 These shell commands target macOS and Linux. On Windows, adapt the virtual-environment executable and absolute storage paths; do not paste POSIX paths unchanged. Use the existing environment-management approach your team supports. The upstream setup guide documents memory server and the client connection step. Installing a Python package does not itself register an MCP server in every IDE, import old conversations or ensure that every new session retrieves memory. The important setting: every client must use the same memory database Same package, different database path means different memory. For this single-user, single-machine example, all three clients use the same executable and the same absolute SQLite file. The configuration reference documents MCP_MEMORY_STORAGE_BACKEND, MCP_MEMORY_SQLITE_PATH and MCP_MEMORY_USE_ONNX. Replace example-app consistently with one project or trust boundary. Keep unrelated clients' repositories in separate stores rather than expecting a tag to enforce access control. The path points to a file, not just its parent directory. A container, remote development host or different operating-system account will not share your home directory merely because the text of its configuration looks similar. In the following examples, each MCP client launches a stdio process against that local store. This is not a multi-user deployment design. Test concurrent use before depending on it, and do not put a live SQLite database in Git or treat a synchronized folder as a database replication service. Connect Claude Code through local MCP Run this from the project where the memory connection should be available: claude mcp add \\ --env MCP_MEMORY_STORAGE_BACKEND=sqlite_vec \\ --env",
  "articleSection": "Engineering",
  "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": "upstream repository",
      "url": "https://github.com/doobidoo/mcp-memory-service"
    },
    {
      "@type": "WebPage",
      "name": "Claude Code's memory documentation",
      "url": "https://code.claude.com/docs/en/memory"
    },
    {
      "@type": "WebPage",
      "name": "Cursor rules",
      "url": "https://cursor.com/docs/rules"
    },
    {
      "@type": "WebPage",
      "name": "PyPI listing",
      "url": "https://pypi.org/project/mcp-memory-service/"
    },
    {
      "@type": "WebPage",
      "name": "upstream setup guide",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/setup-guide.md"
    },
    {
      "@type": "WebPage",
      "name": "configuration reference",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/mastery/configuration-guide.md"
    },
    {
      "@type": "WebPage",
      "name": "official Claude Code MCP command format",
      "url": "https://code.claude.com/docs/en/mcp"
    },
    {
      "@type": "WebPage",
      "name": "Cursor MCP documentation",
      "url": "https://cursor.com/docs/mcp"
    },
    {
      "@type": "WebPage",
      "name": "OpenCode's MCP reference",
      "url": "https://opencode.ai/docs/mcp-servers/"
    },
    {
      "@type": "WebPage",
      "name": "configuration reference",
      "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": "all-MiniLM-L6-v2 model card",
      "url": "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2"
    },
    {
      "@type": "WebPage",
      "name": "environment configuration example",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/.env.example"
    },
    {
      "@type": "WebPage",
      "name": "knowledge-graph documentation",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/features/knowledge-graph-dashboard.md"
    },
    {
      "@type": "WebPage",
      "name": "token-efficient retrieval guide",
      "url": "https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/token-efficient-retrieval.md"
    },
    {
      "@type": "WebPage",
      "name": "MCP security guidance",
      "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 is a persistent, shared memory backend for AI coding tools. Its strongest use case is retrieving project decisions across Claude Code, Cursor and OpenCode, not replacing repository instructions or proving that every agent starts with no memory. Configure the same local database, verify real cross-client retrieval, and keep evidence and decision status with each record. Local ONNX inference does not make a cloud coding model offline; 5 ms is an upstream claim, not our benchmark.",
  "headline": "mcp-memory-service: Shared Memory for Claude Code and Cursor",
  "image": "https://wavect.io/img/blog/headers/header_mcp-memory-service-claude-code-cursor.svg",
  "inLanguage": "en",
  "keywords": "AI agents, MCP, mcp-memory-service, Claude Code, Cursor, OpenCode, Persistent memory",
  "mainEntityOfPage": {
    "@id": "https://wavect.io/blog/mcp-memory-service-claude-code-cursor/",
    "@type": "WebPage"
  },
  "publisher": {
    "@id": "https://wavect.io/#organization",
    "@type": [
      "Organization",
      "ProfessionalService",
      "LocalBusiness"
    ]
  },
  "url": "https://wavect.io/blog/mcp-memory-service-claude-code-cursor/",
  "wordCount": 3058
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "item": "https://wavect.io/",
      "name": "Home",
      "position": 1
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/blog/overview/",
      "name": "Blog overview",
      "position": 2
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/blog/topics/ai-agents/",
      "name": "AI and agents",
      "position": 3
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/blog/clusters/models-infrastructure/",
      "name": "Models and infrastructure",
      "position": 4
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/blog/mcp-memory-service-claude-code-cursor/",
      "name": "mcp-memory-service: Claude Code + Cursor Memory",
      "position": 5
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "It is an open-source persistent memory backend that coding agents can use to store and retrieve project context. This guide uses local MCP connections so Claude Code, Cursor and OpenCode can reach the same SQLite store."
      },
      "name": "What is mcp-memory-service?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Install the package, configure each client, verify successful writes and establish a retrieval workflow. Session-start retrieval and automatic capture depend on the integration or automation you enable."
      },
      "name": "Does installing it make every session remember automatically?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes, when their configured service processes reach the same underlying store with suitable access. In this local example, compare the resolved absolute SQLite path and confirm that a fresh client retrieves the same record identifier."
      },
      "name": "Can Claude Code and Cursor share the same memory?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Those remain appropriate for stable, reviewable project instructions. Shared memory is a complementary place for evolving decisions and debugging history, and recalled advice must be checked against current code."
      },
      "name": "Does it replace CLAUDE.md or Cursor rules?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. A standard local MCP configuration exposes memory tools. The separate Memory Awareness plugin uses HTTP REST for lifecycle automation and requires its repository files; pip installation alone does not install that plugin."
      },
      "name": "Is the OpenCode memory plugin the same as an MCP server?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A local embedding path can avoid external embedding API calls after required assets are available. Installation, model downloads, optional cloud features and the coding model itself have separate network and cost boundaries. Self-hosting also has operating costs."
      },
      "name": "Is mcp-memory-service fully offline and free of API costs?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "This article does not establish that. Treat 5 ms as the project's published claim, not a guarantee for embedding generation, cold starts, remote transport, graph expansion or a complete model answer. Measure your own tool round trips."
      },
      "name": "Does the 5 ms claim include every search and graph query?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Text records and populated graph entities are different things. Check entity-linking settings and existing entities. Enabling linking affects newly stored records; backfilling old records is a separate maintenance operation that should be reviewed and backed up."
      },
      "name": "Why is memory_explore empty when memories exist?"
    }
  ]
}
```