# MemoCat — Shared AI Memory (oci · docker.io/montygovernance/memocat-mcp:0.4.3)

One shared, persistent memory across AI agents and systems, with semantic recall and live updates.

- Trust score: 40/100 (low)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- oci · `docker.io/montygovernance/memocat-mcp:0.4.3`: 40/100 (this document), [markdown](https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3.md), [page](https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3)
- pypi · `memocat-mcp`: 31/100, [markdown](https://verifymcp.io/servers/montygovernance-memocat-mcp/memocat-mcp.md), [page](https://verifymcp.io/servers/montygovernance-memocat-mcp/memocat-mcp)

## Channel facts

- Registry: `oci`
- Package: `docker.io/montygovernance/memocat-mcp:0.4.3`
- 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-21.

- **Supply Chain Security**: 0/100
  - Malware scan not yet available for this package.
  - Known CVEs could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
- **Provenance & Transparency**: 19/100
  - Repository check failed: the declared repository URL redirects; it must resolve directly.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 20 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 66/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4038 tokens (~175/item across 23 items; 23 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 67/100
  - Stability observed for 20 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% 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 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 24 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.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the MemoCat — Shared AI Memory MCP server?

MemoCat — Shared AI Memory runs locally as a container image, launched with docker run --rm -i docker.io/montygovernance/memocat-mcp:0.4.3. 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 montygovernance-memocat-mcp -- docker run --rm -i docker.io/montygovernance/memocat-mcp:0.4.3
```

### Cursor

```json
{
  "mcpServers": {
    "montygovernance-memocat-mcp": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/montygovernance/memocat-mcp:0.4.3"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "montygovernance-memocat-mcp": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/montygovernance/memocat-mcp:0.4.3"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add montygovernance-memocat-mcp -- docker run --rm -i docker.io/montygovernance/memocat-mcp:0.4.3
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "montygovernance-memocat-mcp": {
      "type": "local",
      "command": [
        "docker",
        "run",
        "--rm",
        "-i",
        "docker.io/montygovernance/memocat-mcp:0.4.3"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  montygovernance-memocat-mcp:
    command: "docker"
    args: ["run", "--rm", "-i", "docker.io/montygovernance/memocat-mcp:0.4.3"]
```

### Netclaw

```json
{
  "McpServers": {
    "montygovernance-memocat-mcp": {
      "Transport": "stdio",
      "Command": "docker",
      "Arguments": [
        "run",
        "--rm",
        "-i",
        "docker.io/montygovernance/memocat-mcp:0.4.3"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "montygovernance-memocat-mcp": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "docker.io/montygovernance/memocat-mcp:0.4.3"
      ]
    }
  }
}
```

## 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 40, +1)

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

### 2026-09-18 (score 39, +1)

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

### 2026-09-15 (score 38, +1)

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

### 2026-09-13 (score 37, +1)

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

### 2026-09-11 (score 36, +1)

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

### 2026-09-09 (score 35, +1)

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

### 2026-09-08 (score 34, +3)

- [functional improvement] Stability: unverified → 0.23

### 2026-09-02 (score 31, −5)

- [security regression] Source repository: pass → fail

## MCP tools (23)

### `memocat_semantic_search` (~457 tokens)

Search Memories

Search stored memory by MEANING (vector / semantic search), not keywords.

    Use this to recall relevant facts, documents, or past context for RAG and
    agent memory. Returns the top matches ranked by similarity, each with its
    key, a cosine-similarity score, and the stored value.

    Hybrid mode: `filters`, `since`, and `until` restrict WHICH memories are
    ranked — a hard AND constraint over indexed fields; ranking stays pure
    similarity. Combine them freely: "what did we decide about the index"
    + `since` yesterday + `filters={"project": "montycat"}` is one call.
    A filter matching nothing returns []. Requires a Montycat Semantic engine
    with hybrid support (>= 1.2.3); older engines ignore the filter.

    Args:
        query: Natural-language description of what to recall. May be empty
               when `vector` supplies a precomputed query embedding.
        vector: Optional precomputed query embedding. It must match the
                keyspace's enrolled embedding space and dimensions; when set,
                the engine does not embed `query`.
        scope: Owner/user id to scope recall to (searches only that owner's memory,
               keyspace mem_<scope>). Use "shared" for the common keyspace.
        keyspace: Explicit keyspace override (advanced; bypasses scope).
        limit: Max number of results (default 5).
        min_score: Optional similarity floor in [-1, 1]; drops weak matches.
        filters: Optional metadata constraints, e.g. {"project": "x"} — only
                 memories whose indexed fields equal these values are ranked.
        since: Only memories created at/after this time (ISO-8601, UTC —
               matches the auto-stamped `_created_at`).
        until: Only memories created before this time (ISO-8601, UTC).

Input parameters:

- `filters`
- `keyspace`
- `limit` (integer)
- `min_score`
- `query` (string)
- `scope`
- `since`
- `until`
- `vector`

### `memocat_remember` (~389 tokens)

Store Memory

Store a fact or record in memory; it is embedded and indexed automatically.

    Later recall it by meaning with memocat_semantic_search, or by key with
    memocat_recall. Returns the generated key in `payload`.

    Every record is auto-stamped with an indexed `_created_at` (UTC ISO-8601)
    unless the value already carries one — this powers time-range recall
    (`since`/`until` on memocat_semantic_search). Top-level fields are
    indexed, so they can be used as `filters` in hybrid search (e.g. store
    `{"project": "x", ...}`, later filter on it).

    Args:
        value: The record to store (a JSON object).
        scope: Owner/user id to store under (that owner's private memory,
               keyspace mem_<scope>). Use "shared" for the common keyspace.
        keyspace: Explicit keyspace override (advanced; bypasses scope).
        custom_key: Optional stable key to store under (for later exact recall/update).
        timestamp: Index a `_created_at` for time-range recall. Defaults to
                   MONTYCAT_AUTO_TIMESTAMP (on). Pass False to skip the
                   server-side timestamp parse when this memory will never be
                   recalled by time.
        wait_for_index: For persistent keyspaces, wait until secondary indexes
                        have caught up before returning. Defaults to the engine
                        setting; use True when an immediate filtered/semantic
                        recall must see this write.
        vector: Optional precomputed embedding for this record. It must match
                the keyspace's enrolled embedding profile.

Input parameters:

- `custom_key`
- `keyspace`
- `scope`
- `timestamp`
- `value` (object, required)
- `vector`
- `wait_for_index`

### `memocat_recall` (~185 tokens)

Recall Memories

Recall memory by exact key or by field filter (not by meaning).

    Provide `key`/`custom_key` to fetch a single record, or `filters` (a map of
    field -> value) to look up all records matching those fields. For meaning-based
    recall use memocat_semantic_search instead.

    Args:
        keyspace: Memory namespace (defaults to the configured one).
        key: Montycat-generated key to fetch.
        custom_key: Custom key to fetch.
        filters: Field equality filters, e.g. {"user": "alice", "topic": "billing"}.
        limit: Max results for a filter lookup (default 25).

Input parameters:

- `custom_key`
- `filters`
- `key`
- `keyspace`
- `limit` (integer)
- `scope`

### `memocat_install_engine` (~187 tokens)

Install Montycat Engine

Install the Montycat engine on THIS computer, then start it.

    Call this only when memory tools report that no engine is running and the
    user has agreed to install one. Tell them what it does first: it downloads
    the Montycat Semantic package (~18 MB) and opens your operating system's
    installer, which asks for an administrator password. On Linux it runs the
    documented APT installation with `sudo`.

    Refuses when MONTYCAT_URI is set or the configured host is not this
    machine — MemoCat is pointed at an engine elsewhere, and installing a local
    one would create a second database and write memories where nobody is
    looking. Does nothing if an engine is already reachable.

    Not needed when Docker is available: engine startup falls back to a
    container automatically, with no prompt.

### `memocat_list_keyspaces` (~26 tokens)

List Memory Keyspaces

List the available memory stores and keyspaces on this Montycat engine.

### `memocat_policy_view` (~107 tokens)

View Memory Policy

View the configured owner's effective Montycat governance policy.

    This is read-only. It reports the authenticated owner's effective grants,
    denials, accessible and owned keyspaces, automatic creator capabilities,
    provisioning constraints, and policy health. The engine filters the result
    and remains the authorization boundary.

    Args:
        store: Optional store to inspect. Defaults to the store configured by
               MONTYCAT_URI or MONTYCAT_STORE.

Input parameters:

- `store`

### `memocat_policy_history` (~101 tokens)

View Policy History

View governance history visible to the configured owner.

    This is read-only and owner-scoped by the authenticated Montycat
    credential. It can show when authority was delegated, denied, revoked, or
    transferred without allowing the MCP caller to select another owner.

    Args:
        store: Optional store filter. Defaults to the configured store.
        keyspace: Optional keyspace filter.

Input parameters:

- `keyspace`
- `store`

### `memocat_policy_explain` (~213 tokens)

Explain Policy Decision

Explain whether the configured owner may perform a proposed action.

    This is a read-only policy check for planning and diagnostics; executing
    the action still requires a separate tool call and fresh engine
    authorization. The explanation identifies applicable grants, denials,
    creator authority, and storage/model constraints.

    Args:
        capability: One of "provision-keyspace", "remove-keyspace",
                    "manage-snapshots", "manage-semantic", "manage-schema",
                    or "manage-access".
        store: Target store. Defaults to the configured store.
        keyspace: Optional target keyspace.
        storage: Optional keyspace type: "persistent", "inmemory", or
                 "distributed".
        semantic_model: Optional model constraint: "minilm", "bge-small",
                        "bge-base", or "e5-small".

Input parameters:

- `capability` (string, required)
- `keyspace`
- `semantic_model`
- `storage`
- `store`

### `memocat_create_keyspace` (~286 tokens)

Create Memory Keyspace

Create a new memory namespace using the configured owner's authority.

    A delegated owner can create a keyspace when its governance policy grants
    `provision-keyspace` for the requested store, storage type, and semantic
    model, but its store must already exist. With superowner credentials, the
    engine creates a missing configured store and this first keyspace together
    in the same provisioning request. The engine remains the final
    authorization boundary.

    Args:
        keyspace: Name of the keyspace to create.
        storage: Preferred storage type: "persistent" or "inmemory". Defaults
                 to "persistent".
        semantic: Enable semantic search for this keyspace after creation.
        semantic_model: Optional embedding model: "minilm", "bge-small",
                        "bge-base", or "e5-small". Supplying a model implies
                        semantic=True.
        persistent: Deprecated compatibility option. True maps to
                    storage="persistent"; False maps to storage="inmemory".
        cache: Optional cache size in MB (persistent only; min/default 10).
        compression: Enable compression (persistent only).

Input parameters:

- `cache`
- `compression` (boolean)
- `keyspace` (string, required)
- `persistent`
- `semantic` (boolean)
- `semantic_model`
- `storage`

### `memocat_remove_keyspace` (~143 tokens)

Delete Memory Keyspace

Permanently remove a memory namespace using the owner's authority.

    This is a destructive lifecycle operation. Before removal MemoCat closes
    the keyspace's live watch and releases MCP resource-subscription ownership
    so the engine cannot deadlock on a lingering subscriber. The engine then
    enforces `remove-keyspace`, creator authority, and explicit denials.

    Args:
        scope: Owner/user scope to remove (maps to keyspace mem_<scope>).
               Use "shared" for the configured shared keyspace.
        keyspace: Explicit keyspace override (advanced; bypasses scope).

Input parameters:

- `keyspace`
- `scope`

### `memocat_enable_semantic` (~169 tokens)

Enable Semantic Search

Enable semantic search for one explicit keyspace.

    The engine enforces `manage-semantic`, creator authority, explicit denials,
    and allowed-model constraints. Existing records are backfilled by the
    engine. This tool never enables semantic search database-wide.

    Args:
        keyspace: Explicit keyspace to enroll and backfill.
        store: Target store. Defaults to the configured store.
        semantic_model: Optional model: "minilm", "bge-small", "bge-base",
                        or "e5-small". Omit to use the engine/policy default.
        field: Optional JSON field to embed instead of the whole stored value.

Input parameters:

- `field`
- `keyspace` (string, required)
- `semantic_model`
- `store`

### `memocat_semantic_status` (~70 tokens)

View Semantic Search Status

Read the engine's actual semantic configuration and backfill state.

    Pass both `store` and `keyspace` for one keyspace. Omitting both asks for
    the database-wide view, which may require superowner authority.

Input parameters:

- `keyspace`
- `store`

### `memocat_enable_external_vectors` (~55 tokens)

Enable External Vectors

Enroll a keyspace for caller-supplied embeddings instead of text embedding.

Input parameters:

- `dimensions` (integer, required)
- `embedding_space` (string, required)
- `keyspace` (string, required)
- `store`

### `memocat_reembed_semantic` (~83 tokens)

Rebuild Semantic Vectors

Replace an enrolled keyspace's text embedding model and backfill it.

    This clears its current vectors, then has the engine rebuild them. Use
    `memocat_semantic_status` to observe the resulting configuration.

Input parameters:

- `field`
- `keyspace` (string, required)
- `semantic_model` (string, required)
- `store`

### `memocat_disable_semantic` (~134 tokens)

Disable Semantic Search

Disable semantic search for one explicit keyspace.

    Stored vectors are retained by default so re-enabling can resume without a
    full rebuild. Set `drop_vectors` only when intentionally clearing vectors,
    such as before changing embedding models. The engine enforces all
    governance authority and explicit denials.

    Args:
        keyspace: Explicit keyspace to unenroll.
        store: Target store. Defaults to the configured store.
        drop_vectors: Also delete stored vectors for this keyspace.

Input parameters:

- `drop_vectors` (boolean)
- `keyspace` (string, required)
- `store`

### `memocat_start_snapshots` (~115 tokens)

Start Memory Snapshots

Start scheduled snapshots for one existing in-memory keyspace.

    Montycat enforces `manage-snapshots`, creator authority, and explicit
    denials. If the response says "Snapshot rate is not set", snapshot
    scheduling is not configured on the engine; that is an environmental
    configuration error, not an authorization denial. This tool cannot alter
    the global snapshot rate.

    Args:
        keyspace: Explicit in-memory keyspace to snapshot.

Input parameters:

- `keyspace` (string, required)

### `memocat_stop_snapshots` (~66 tokens)

Stop Memory Snapshots

Stop scheduled snapshots for one existing in-memory keyspace.

    Existing snapshot files are retained. Montycat performs the final
    authorization check.

    Args:
        keyspace: Explicit in-memory keyspace whose snapshot schedule stops.

Input parameters:

- `keyspace` (string, required)

### `memocat_clean_snapshots` (~83 tokens)

Delete Memory Snapshots

Delete snapshot files for one existing in-memory keyspace.

    This is destructive to the keyspace's snapshot history but does not delete
    its currently loaded in-memory records. Montycat performs the final
    authorization check.

    Args:
        keyspace: Explicit in-memory keyspace whose snapshots are cleaned.

Input parameters:

- `keyspace` (string, required)

### `memocat_forget` (~113 tokens)

Delete Memory

Delete a stored record from memory by key or custom key.

    Args:
        keyspace: Memory namespace (defaults to the configured one).
        key: Montycat-generated key to delete.
        custom_key: Custom key to delete.
        wait_for_index: For persistent keyspaces, wait for secondary indexes
                        before returning. Defaults to the engine setting.

Input parameters:

- `custom_key`
- `key`
- `keyspace`
- `scope`
- `wait_for_index`

### `memocat_update` (~201 tokens)

Update Memory

Revise an existing memory in place (memory is mutable).

    Use this when a stored fact changes — a corrected value, an updated
    preference — instead of storing a duplicate. Only the fields you pass are
    changed. Identify the record by `key` or `custom_key`.

    Args:
        updates: Fields to change, e.g. {"status": "resolved"} or {"name": "Alice"}.
        keyspace: Memory namespace (defaults to the configured one).
        key: Montycat-generated key of the record to update.
        custom_key: Custom key of the record to update.
        wait_for_index: For persistent keyspaces, wait for secondary indexes
                        before returning. Defaults to the engine setting.

Input parameters:

- `custom_key`
- `key`
- `keyspace`
- `scope`
- `updates` (object, required)
- `vector`
- `wait_for_index`

### `memocat_list_memories` (~154 tokens)

List Memories

Browse stored memories — enumerate what is remembered, not search by meaning.

    Returns up to `limit` records with their keys. Use this to review or list
    memory; for meaning-based recall use memocat_semantic_search, and for exact
    lookups use memocat_recall.

    Args:
        keyspace: Memory namespace (defaults to the configured one).
        limit: Max records to return (default 25).
        recent: Bias toward the most recently written records (default True).
                Ordering is approximate (by storage volume), not a strict timestamp sort.

Input parameters:

- `keyspace`
- `limit` (integer)
- `recent` (boolean)
- `scope`

### `memocat_remember_bulk` (~171 tokens)

Store Multiple Memories

Store many memories at once; all are embedded and indexed automatically.

    Args:
        values: A list of records (JSON objects) to store.
        keyspace: Memory namespace (defaults to the configured one).
        timestamp: Index a `_created_at` on each record for time-range recall.
                   Defaults to MONTYCAT_AUTO_TIMESTAMP (on). Pass False for
                   large imports that will never be recalled by time — it skips
                   a server-side timestamp parse per record.
        wait_for_index: For persistent keyspaces, wait for secondary indexes
                        before returning. Defaults to the engine setting.

Input parameters:

- `keyspace`
- `scope`
- `timestamp`
- `values` (array, required)
- `vectors`
- `wait_for_index`

### `memocat_await_memory_change` (~404 tokens)

Wait for Memory Change

Wait until memory CHANGES — returns the moment another agent or session
    writes, updates, or deletes something in this memory.

    This is a live subscription to the database, not a poll: it sleeps until a
    change actually happens and then returns immediately. Use it to coordinate
    with other agents sharing a scope ("tell me when someone adds to our shared
    memory"), or to confirm a write from another session landed. Do NOT call it
    in a tight loop as a substitute for searching — to *find* things, use
    memocat_semantic_search.

    Returns `{changes: [...], next_seq, oldest_seq, cursor_expired, timed_out}`.
    Each change is
    `{seq, key, event, value}` where event is "inserted" (covers create and
    update) or "removed". Pass the returned `next_seq` back as `since_seq` on
    the next call to resume exactly where you left off. If the bounded buffer
    has discarded part of that history, `cursor_expired` is true and
    `oldest_seq` identifies the earliest retained record.

    Args:
        scope: Owner/user id whose memory to watch (keyspace mem_<scope>).
               Use "shared" for the common keyspace — the usual choice when
               coordinating between agents.
        keyspace: Explicit keyspace override (advanced; bypasses scope).
        timeout_sec: How long to wait before giving up (default 30). On timeout
                     the result is empty with `timed_out: true` — that is a
                     normal outcome, not an error.
        since_seq: Resume cursor from a previous call. Omit on the first call to
                   watch only for changes from now on.

Input parameters:

- `keyspace`
- `scope`
- `since_seq`
- `timeout_sec` (integer)

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3#diagnostics

## Score history

- 2026-09-21: 40
- 2026-09-20: 40
- 2026-09-19: 39
- 2026-09-18: 39
- 2026-09-17: 38
- 2026-09-16: 38
- 2026-09-15: 38
- 2026-09-14: 37
- 2026-09-13: 37
- 2026-09-12: 36
- 2026-09-11: 36
- 2026-09-10: 35
- 2026-09-09: 35
- 2026-09-08: 34
- 2026-09-07: 31
- 2026-09-06: 31
- 2026-09-05: 31
- 2026-09-04: 31
- 2026-09-03: 31
- 2026-09-02: 31
- 2026-09-01: 36

## Common questions

### What is the MemoCat — Shared AI Memory MCP server?

MemoCat — Shared AI Memory is an MCP server listed in the public MCP registry as io.github.MontyGovernance/memocat-mcp. One shared, persistent memory across AI agents and systems, with semantic recall and live updates. This page covers its container image (docker.io/montygovernance/memocat-mcp:0.4.3).

### Is the MemoCat — Shared AI Memory MCP server safe to use?

MemoCat — Shared AI Memory scores 40 out of 100 on VerifyMCP. 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 MemoCat — Shared AI Memory MCP server expose?

MemoCat — Shared AI Memory exposes 23 tools: memocat_semantic_search, memocat_remember, memocat_recall, memocat_install_engine, memocat_list_keyspaces, and 18 more. Their descriptions and schemas cost roughly 3,912 tokens of context every time the server is loaded.

### Is the MemoCat — Shared AI Memory MCP server still maintained?

MemoCat — Shared AI Memory is still listed as active in the MCP registry. We last reached this channel on 21 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 MemoCat — Shared AI Memory MCP server under?

MemoCat — Shared AI 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.

## Links

- Changelog RSS feed: https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3.xml
- Changelog JSON feed: https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3.json
- HTML version of this page: https://verifymcp.io/servers/montygovernance-memocat-mcp/docker-io-montygovernance-memocat-mcp-0-4-3