# persistent-memory (pypi · persistent-memory-mcp)

Agent memory that tracks sources and stops serving what depends on corrected or withdrawn facts.

- Trust score: 67/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `persistent-memory-mcp`: 67/100 (this document), [markdown](https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp.md), [page](https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp)

## Channel facts

- Registry: `pypi`
- Package: `persistent-memory-mcp`
- Version: `0.4.0a4`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Musyg/persistent-memory).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2060 tokens (~206/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 17/100
  - Stability observed for 5 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 11 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the persistent-memory MCP server?

persistent-memory runs locally as a PyPI package, launched with uvx persistent-memory-mcp --create. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add musyg-persistent-memory -- uvx persistent-memory-mcp --create
```

### Cursor

```json
{
  "mcpServers": {
    "musyg-persistent-memory": {
      "command": "uvx",
      "args": [
        "persistent-memory-mcp",
        "--create"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "musyg-persistent-memory": {
      "command": "uvx",
      "args": [
        "persistent-memory-mcp",
        "--create"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add musyg-persistent-memory -- uvx persistent-memory-mcp --create
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "musyg-persistent-memory": {
      "type": "local",
      "command": [
        "uvx",
        "persistent-memory-mcp",
        "--create"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  musyg-persistent-memory:
    command: "uvx"
    args: ["persistent-memory-mcp", "--create"]
```

### Netclaw

```json
{
  "McpServers": {
    "musyg-persistent-memory": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "persistent-memory-mcp",
        "--create"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "musyg-persistent-memory": {
      "command": "uvx",
      "args": [
        "persistent-memory-mcp",
        "--create"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 67, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-20 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-19 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 65, +2)

- [functional regression] Schema quality: pass → fail
- [functional improvement] Tool coverage: 59% → 100%
- [functional improvement] Stability: unverified → 0.03
- [functional] Schema quality: good → excellent
- [functional] Package version: 0.4.0a3 → 0.4.0a4

### 2026-11-16 (score 63)

First indexed and scored.

## MCP tools (10)

### `memory_search` (~204 tokens)

Search memory

Find stored facts, decisions and procedures by keywords. Use it before answering about anything the user said or decided earlier. Returns only current, valid versions, each with its text, kind, artifact_id and exact ref; withdrawn, superseded and expired versions are left out, and an empty list means nothing valid matches. Read-only. To re-read one version you already hold, use memory_read.

Input parameters:

- `as_of` (string): UTC time to check validity at. Leave out for now.
- `conditions` (object): Facts about the current situation, matched exactly against stored preconditions. Leave out unless the user describes a situation.
- `kinds` (array): Only these kinds. Leave out to search all.
- `max_chars` (integer): Maximum characters of text returned in total, default 2000.
- `query` (string, required): Keywords or a question.
- `top_k` (integer): Maximum number of results, default 5. Leave out unless you need more.

### `memory_read` (~107 tokens)

Read one version

Re-read one exact version you got from memory_search or a write, for example before relying on it again later in a conversation. Returns its text if it is still valid; otherwise allowed is false and reason and state say why (superseded, withdrawn, expired), with no text. Read-only. To look for something, use memory_search.

Input parameters:

- `ref` (object, required): An exact version: the ref object returned by memory_search, memory_remember or memory_derive, copied unchanged.

### `memory_remember` (~335 tokens)

Remember a source

Store a new fact, decision, document or procedure the user stated or confirmed, as a source. Do not use it for your own conclusions (memory_derive), for lessons after a task (memory_learn), or to change something already stored (memory_correct). Returns artifact_id and ref, plus similar when existing entries are worded almost the same. A source_id that already exists is refused with version_conflict, except an identical retry in the same second; to change it, use memory_correct.

Input parameters:

- `aliases` (array): Short names to find it again.
- `confidence` (number): Declared, not computed. Leave out unless the user gave one.
- `kind` (string): observation for a fact, document for a text, procedure for how to do something, task, feedback, or hypothesis for a guess nobody confirmed.
- `preconditions` (object): Exact conditions a search must supply to see it. Leave out unless the user said it only holds under a condition: a search without these conditions will not return it.
- `source_id` (string): Stable name you choose, such as 'db-port', to correct or withdraw it later. Leave out to get one.
- `text` (string, required): Self-contained statement, with its date if known.
- `valid_from` (string): UTC time it starts to apply, e.g. 2026-01-31T00:00:00Z. Leave out unless the user gave one; by default it applies now.
- `valid_until` (string): UTC time after which it no longer applies. Leave out unless the user gave one.

### `memory_derive` (~305 tokens)

Derive from exact parents

Store a summary, conclusion or procedure you built from entries already in memory, linked to the exact versions it came from. Use it instead of memory_remember whenever the text depends on stored entries: if one of them is later corrected or withdrawn, this artifact stops being served and sessions that saw it are notified. Returns artifact_id and ref.

Input parameters:

- `aliases` (array): Short names to find it again.
- `artifact_id` (string): Stable name you choose. Leave out to get one.
- `confidence` (number): Declared, not computed. Leave out unless the user gave one.
- `kind` (string): observation for a fact, document for a text, procedure for how to do something, task, feedback, or hypothesis for a guess nobody confirmed.
- `parents` (array, required): The refs it was built from, as returned by memory_search.
- `preconditions` (object): Exact conditions a search must supply to see it. Leave out unless the user said it only holds under a condition: a search without these conditions will not return it.
- `text` (string, required): The derived statement, self-contained.
- `valid_from` (string): UTC time it starts to apply, e.g. 2026-01-31T00:00:00Z. Leave out unless the user gave one; by default it applies now.
- `valid_until` (string): UTC time after which it no longer applies. Leave out unless the user gave one.

### `memory_correct` (~293 tokens)

Correct an artifact

Replace an artifact's text when the user corrects it, keeping its history. Only applies if expected_version is still its current version; otherwise it is refused with version_conflict, and you search again. Metadata you leave out is kept. Whatever was derived from the old version stops being served and its readers are notified. To remove something entirely, use memory_withdraw.

Input parameters:

- `aliases` (array): Short names to find it again.
- `artifact_id` (string, required): The artifact_id returned when it was stored or found by memory_search.
- `confidence` (number): Declared, not computed. Leave out unless the user gave one.
- `expected_version` (string, required): The version_id of the ref you read.
- `parents` (array): For a derived artifact: its new parents. Leave out to keep them.
- `preconditions` (object): Exact conditions a search must supply to see it. Leave out unless the user said it only holds under a condition: a search without these conditions will not return it.
- `text` (string, required): The corrected statement.
- `valid_from` (string): UTC time it starts to apply, e.g. 2026-01-31T00:00:00Z. Leave out unless the user gave one; by default it applies now.
- `valid_until` (string): UTC time after which it no longer applies. Leave out unless the user gave one.

### `memory_explain` (~127 tokens)

Explain an artifact

Explain why an artifact is or is not served: its state, its versions, what it was derived from and what depends on it. Metadata only, never text. Use it when a search leaves out something the user expects, or before a correction. Read-only; unknown_artifact if it does not exist. Give artifact_id or ref.

Input parameters:

- `artifact_id` (string): The artifact_id returned when it was stored or found by memory_search.
- `ref` (object): An exact version: the ref object returned by memory_search, memory_remember or memory_derive, copied unchanged.

### `memory_plan_withdrawal` (~70 tokens)

Plan a withdrawal

Preview a withdrawal: list every version that memory_withdraw would stop serving, the artifact and everything derived from it, without changing anything. Use it to show the user the consequences before withdrawing.

Input parameters:

- `artifact_id` (string, required): The artifact_id returned when it was stored or found by memory_search.

### `memory_withdraw` (~136 tokens)

Withdraw an artifact

Stop serving an artifact the user says is wrong, outdated or must be forgotten, together with everything derived from it; sessions that saw them are notified. The text is not physically erased and the history keeps the reason. Run memory_plan_withdrawal first when the user should see what it blocks. To replace a text with a better one, use memory_correct instead.

Input parameters:

- `artifact_id` (string, required): The artifact_id returned when it was stored or found by memory_search.
- `event_id` (string): Optional key; repeating a call with the same key changes nothing.
- `reason` (string, required): Why, in the user's words.

### `memory_learn` (~309 tokens)

Learn a lesson

After a task, store the lesson drawn from it, with the task trace and the feedback it got kept as its provenance. Only the lesson is returned by searches; withdrawing the trace or the feedback stops serving the lesson. For a fact the user states, use memory_remember.

Input parameters:

- `aliases` (array): Short names to find it again.
- `confidence` (number): Declared, not computed. Leave out unless the user gave one.
- `feedback` (required): What the user or a check said about the result.
- `kind` (string): observation for a fact, document for a text, procedure for how to do something, task, feedback, or hypothesis for a guess nobody confirmed.
- `lesson` (string, required): The rule to apply next time, self-contained.
- `lesson_id` (string): Stable name you choose. Leave out to get one.
- `preconditions` (object): Exact conditions a search must supply to see it. Leave out unless the user said it only holds under a condition: a search without these conditions will not return it.
- `trace` (required): What was done: steps, commands or a summary of them.
- `valid_from` (string): UTC time it starts to apply, e.g. 2026-01-31T00:00:00Z. Leave out unless the user gave one; by default it applies now.
- `valid_until` (string): UTC time after which it no longer applies. Leave out unless the user gave one.

### `memory_notices` (~75 tokens)

Check notices

List the artifacts this session was shown that have since been withdrawn, invalidated or superseded, so you stop relying on them and on what you said from them. Each is reported once. Other tool results already carry new notices as memory_notices; call this when you need to check explicitly, for example before a final answer.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp#diagnostics

## Score history

- 2026-11-21: 67
- 2026-11-20: 81
- 2026-11-19: 66
- 2026-11-18: 65
- 2026-11-17: 65
- 2026-11-16: 63

## Common questions

### What is the persistent-memory MCP server?

persistent-memory is an MCP server listed in the public MCP registry as io.github.Musyg/persistent-memory. Agent memory that tracks sources and stops serving what depends on corrected or withdrawn facts. This page covers its PyPI package (persistent-memory-mcp).

### Is the persistent-memory MCP server safe to use?

persistent-memory scores 67 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the persistent-memory MCP server expose?

persistent-memory exposes 10 tools: memory_search, memory_read, memory_remember, memory_derive, memory_correct, and 5 more. Their descriptions and schemas cost roughly 1,961 tokens of context every time the server is loaded.

### Is the persistent-memory MCP server still maintained?

persistent-memory is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the persistent-memory MCP server under?

persistent-memory declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the persistent-memory MCP server?

VerifyMCP ran 15 checks on persistent-memory, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about persistent-memory: Malware scan. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/persistent-memory-mcp/
- Socket report: https://socket.dev/pypi/package/persistent-memory-mcp
- Repository: https://github.com/Musyg/persistent-memory
- Changelog RSS feed: https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp.json
- HTML version of this page: https://verifymcp.io/servers/musyg-persistent-memory/persistent-memory-mcp
