# Auditable memory (memory3l) (pypi · memory3l-mcp)

Audited memory over MCP: an append-only fact ledger plus verifiable invariants I1-I5.

- Trust score: 34/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- pypi · `memory3l-mcp`: 34/100 (this document), [markdown](https://verifymcp.io/servers/jayzht-memory3l-mcp/memory3l-mcp.md), [page](https://verifymcp.io/servers/jayzht-memory3l-mcp/memory3l-mcp)

## Channel facts

- Registry: `pypi`
- Package: `memory3l-mcp`
- Version: `0.2.0`
- 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-09-20.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised native-build step with no shell scripting around it.
  - 2 of 34 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 19/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 0/100
  - Schema quality not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- **Tool Coverage**: 0/100
  - Tool coverage not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- **Tool Safety**: 0/100
  - Tool safety not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- **Capabilities**: 0/100
  - Protocol version not yet verified: we do not have a sandbox capture of the MCP handshake this version of the package performs yet.

**Unverified: 5 categories.** Categories scored 0 because our sandbox run of this package has not given us the schema these checks need to read. That is a gap on our side rather than a finding about the package, and we only credit what we can confirm, so the score stands at 0 until the capture succeeds. We are working through the fleet, so this normally clears without any action from you.

## Install

### How do I install the Auditable memory (memory3l) MCP server?

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

### Claude

```bash
claude mcp add jayzht-memory3l-mcp -- uvx memory3l-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "jayzht-memory3l-mcp": {
      "command": "uvx",
      "args": [
        "memory3l-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "jayzht-memory3l-mcp": {
      "command": "uvx",
      "args": [
        "memory3l-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add jayzht-memory3l-mcp -- uvx memory3l-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add jayzht-memory3l-mcp --command uvx --arg memory3l-mcp
```

### Hermes

```yaml
mcp_servers:
  jayzht-memory3l-mcp:
    command: "uvx"
    args: ["memory3l-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "jayzht-memory3l-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "memory3l-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add jayzht-memory3l-mcp -t stdio -c uvx -a memory3l-mcp
```

### Other

```json
{
  "mcpServers": {
    "jayzht-memory3l-mcp": {
      "command": "uvx",
      "args": [
        "memory3l-mcp"
      ]
    }
  }
}
```

## 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-09-20 (score 34)

First indexed and scored.

## MCP tools (10)

### `store_info` (~55 tokens)

Which ledger is being served

Report the database this server reads, whether it exists, its size, and how many episodes carry an audit ledger. Call this first when a query returns nothing: an empty or wrong path is the usual cause, not an absent feature.

Output parameters:

- `result` (string)

### `list_episodes` (~40 tokens)

List audited episodes

List the episode ids that have an audit ledger. Every other tool needs one of these ids, so call this when you do not already know the episode.

Output parameters:

- `result` (string)

### `audit` (~154 tokens)

Audit one episode against I1-I5

Run the invariant checks over one episode and return the violations. This is the tool to call to answer 'did this memory lose anything?'. I1 = a fact in the ledger no longer reaches any summary (silent loss); I2 = a slot's newest value is not visible at the top level, so the model is never told it; I3 = a fact's evidence no longer resolves to stored dialogue; I4 = extraction completeness against the raw turns; I5 = an erasure is verifiable and its evidence is gone. `ok: true` with no violations means none of the checked failure modes is present -- report that as the result, not as a guarantee about meanings.

Input parameters:

- `episode_id` (string, required)

Output parameters:

- `result` (string)

### `audit_summary` (~50 tokens)

Audit every episode

Aggregate the invariant checks over every episode that has a ledger, including the `silent_loss_rate`. Use this for an overall health answer; use `audit` when you already know the episode and want the detail.

Output parameters:

- `result` (string)

### `current` (~75 tokens)

Current value of every known slot

Return the derived current-value registry for an episode: the newest value of each attribute, with the summary it came from. This is what the model should be told at the top level. If a value the conversation established is missing here, that is an I2 failure -- confirm it with `audit`.

Input parameters:

- `episode_id` (string, required)

Output parameters:

- `result` (string)

### `history` (~117 tokens)

Every value a slot ever held

Return one slot's value over time, oldest first, bounded by `upto_turn` when given. Use this for 'what was it before?' and for any question about change; `current` only answers 'what is it now?'. A slot is a lower-case attribute name such as `工位` or `office` -- call `current` first if you do not know the exact spelling, since this matches the slot literally.

Input parameters:

- `episode_id` (string, required)
- `slot` (string, required)
- `upto_turn`

Output parameters:

- `result` (string)

### `fact` (~106 tokens)

Why a fact left the working set

Given a `fact_id`, report the fact's full record and where it now lives: `live` (still in an active summary), `archived` (moved to the permanent archive, reachable by id) or `MISSING` (in the ledger but unreachable, which is an I1 silent loss). Also returns `reason` and `superseded_by`. Use this when asked why a piece of information is no longer in context.

Input parameters:

- `fact_id` (string, required)

Output parameters:

- `result` (string)

### `evidence` (~84 tokens)

Original dialogue behind a fact

Return the raw user/agent turns a fact was extracted from, resolved through its evidence pointers. Use this to justify a stored value with the actual conversation rather than the summary's paraphrase. `resolved: false` means at least one evidence pointer no longer resolves -- an I3 provenance failure; that matters and should be reported, not hidden.

Input parameters:

- `fact_id` (string, required)

Output parameters:

- `result` (string)

### `tombstones` (~97 tokens)

What was erased, and what remains

List the compliance tombstones for an episode: facts deliberately erased, with their evidence pointers, which of those are still readable, and how many residual prose mentions survive. This is the deletion-verification view (I5). A non-empty `residual_prose_mentions` or a readable evidence pointer means the content is not fully gone from the store -- report that plainly instead of calling the erasure complete.

Input parameters:

- `episode_id` (string, required)

Output parameters:

- `result` (string)

### `temporal` (~74 tokens)

Versioned projection and its anomalies

Return the episode's temporal (bitemporal-style) projection: row count, whether it is consistent with the ledger, any anomalies, and the DDL for recreating the table. Use this when memory state is projected into an external store and you need to know whether the two still agree.

Input parameters:

- `episode_id` (string, required)

Output parameters:

- `result` (string)

## Diagnostics

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

## Score history

- 2026-09-20: 34

## Common questions

### What is the Auditable memory (memory3l) MCP server?

Auditable memory (memory3l) is an MCP server listed in the public MCP registry as io.github.jayzht/memory3l-mcp. Audited memory over MCP: an append-only fact ledger plus verifiable invariants I1-I5. This page covers its PyPI package (memory3l-mcp).

### Is the Auditable memory (memory3l) MCP server safe to use?

Auditable memory (memory3l) scores 34 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 20 September 2026. 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 Auditable memory (memory3l) MCP server expose?

Auditable memory (memory3l) exposes 10 tools: store_info, list_episodes, audit, audit_summary, current, and 5 more. Their descriptions and schemas cost roughly 852 tokens of context every time the server is loaded.

### Is the Auditable memory (memory3l) MCP server still maintained?

Auditable memory (memory3l) is still listed as active in the MCP registry. We last reached this channel on 20 September 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 Auditable memory (memory3l) MCP server under?

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

## Links

- PyPI project: https://pypi.org/project/memory3l-mcp/
- Socket report: https://socket.dev/pypi/package/memory3l-mcp
- Changelog RSS feed: https://verifymcp.io/servers/jayzht-memory3l-mcp/memory3l-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/jayzht-memory3l-mcp/memory3l-mcp.json
- HTML version of this page: https://verifymcp.io/servers/jayzht-memory3l-mcp/memory3l-mcp