# Montycat MCP - Shared Memory for AI Agents (oci · docker.io/montygovernance/montycat-mcp:1.1.5)

Shared, persistent memory for AI agents, with semantic recall and live updates.

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

## Components

- oci · `docker.io/montygovernance/montycat-mcp:1.1.5`: 36/100 (this document), [markdown](https://verifymcp.io/servers/montygovernance-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5.md), [page](https://verifymcp.io/servers/montygovernance-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5)
- pypi · `montycat-mcp`: 21/100, [markdown](https://verifymcp.io/servers/montygovernance-montycat-mcp/montycat-mcp.md), [page](https://verifymcp.io/servers/montygovernance-montycat-mcp/montycat-mcp)

## Channel facts

- Registry: `oci`
- Package: `docker.io/montygovernance/montycat-mcp:1.1.5`
- 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**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 64/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4669 tokens (~194/item across 24 items; 24 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **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 25 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: 2 categories.** Categories scored 0 because we could not verify them: 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 Montycat MCP - Shared Memory for AI Agents server?

Montycat MCP - Shared Memory for AI Agents runs locally as a container image, launched with docker run --rm -i docker.io/montygovernance/montycat-mcp:1.1.5. 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-montycat-mcp -- docker run --rm -i docker.io/montygovernance/montycat-mcp:1.1.5
```

### Cursor

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

### VS Code

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

### Codex

```bash
codex mcp add montygovernance-montycat-mcp -- docker run --rm -i docker.io/montygovernance/montycat-mcp:1.1.5
```

### opencode

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

### Hermes

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

### Netclaw

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

### Other

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

## 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-19 (score 36)

First indexed and scored.

## MCP tools (24)

### `montycat_semantic_search` (~762 tokens)

Search Memories

Search stored memory by MEANING, by KEYWORD, or both.

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

    Ranking modes (`mode`):
      - "semantic" (default) — vector similarity. Finds a memory whose wording
        differs from the query. Scores are cosine similarity in [-1, 1].
      - "keyword" — BM25 over the stored text. Use it when the query contains an
        exact term that must appear: an identifier, error code, or file name.
        BM25 scores are unbounded and comparable only within one query.
      - "hybrid" — runs both and fuses them with reciprocal rank fusion. The
        safest default when a query mixes meaning with an exact term. Scores are
        normalized to [0, 1].
    Keyword and hybrid need a Montycat Semantic engine >= 1.3.4; older engines
    reject the request rather than silently returning semantic-only results.

    Narrowing is separate from ranking: `filters`, `since`, and `until` restrict
    WHICH memories are ranked — a hard AND over indexed fields — and never
    change the order within that set. Combine them freely: "what did we decide
    about the index" + `since` yesterday + `filters={"project": "montycat"}` is
    one call. A filter matching nothing returns [].

    Args:
        query: Natural-language description of what to recall. May be empty
               when `vector` supplies a precomputed query embedding.
        mode: Ranking strategy — "semantic", "keyword", or "hybrid".
        vector: Optional precomputed query embedding, for the vector half of
                "semantic" and "hybrid". 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"…

Input parameters:

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

### `montycat_remember` (~393 tokens)

Store Memory

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

    Later recall it by meaning with montycat_semantic_search, or by key with
    montycat_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 montycat_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`

### `montycat_recall` (~187 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 montycat_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`

### `montycat_install_engine` (~190 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 — Montycat MCP 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.

### `montycat_list_keyspaces` (~27 tokens)

List Memory Keyspaces

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

### `montycat_list_enforced_schemas` (~150 tokens)

List Enforced Schemas

List schemas enforced on a keyspace, including field data types.

    Use this before a structured write or retrieval when the target keyspace's
    required fields or types are unknown. For retrieval, it helps construct
    correctly typed field filters. This inspection is read-only and never
    creates a missing keyspace.

    Args:
        keyspace: Explicit keyspace name. Takes precedence over scope.
        scope: Owner/user memory scope (maps to its configured keyspace). Use
               "shared" for the common keyspace. When both inputs are omitted,
               the configured default keyspace is inspected.

Input parameters:

- `keyspace`
- `scope`

### `montycat_policy_view` (~108 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`

### `montycat_policy_history` (~102 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`

### `montycat_policy_explain` (~214 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`

### `montycat_create_keyspace` (~287 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`

### `montycat_remove_keyspace` (~146 tokens)

Delete Memory Keyspace

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

    This is a destructive lifecycle operation. Before removal Montycat MCP 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`

### `montycat_enable_semantic` (~170 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`

### `montycat_semantic_status` (~71 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`

### `montycat_enable_external_vectors` (~56 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`

### `montycat_reembed_semantic` (~85 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
    `montycat_semantic_status` to observe the resulting configuration.

Input parameters:

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

### `montycat_disable_semantic` (~135 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`

### `montycat_start_snapshots` (~116 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)

### `montycat_stop_snapshots` (~67 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)

### `montycat_clean_snapshots` (~84 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)

### `montycat_forget` (~114 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`

### `montycat_update` (~202 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`

### `montycat_list_memories` (~209 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 montycat_semantic_search, and for exact
    lookups use montycat_recall.

    Args:
        keyspace: Memory namespace (defaults to the configured one).
        limit: Max records to return (default 25).
        recent: Return the most recently written records first (default True).
                Persistent keyspaces order by key, which is a strict write
                order; in-memory keyspaces have no ordered read, so there the
                bias stays approximate (by storage volume) and falls back to a
                full scan when the latest volume is empty. Pass False to read
                from the oldest record forward.

Input parameters:

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

### `montycat_remember_bulk` (~172 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`

### `montycat_await_memory_change` (~406 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
    montycat_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-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5#diagnostics

## Score history

- 2026-09-21: 36
- 2026-09-20: 36
- 2026-09-19: 36

## Common questions

### What is the Montycat MCP - Shared Memory for AI Agents server?

Montycat MCP - Shared Memory for AI Agents is listed in the public MCP registry as io.github.MontyGovernance/montycat-mcp. Shared, persistent memory for AI agents, with semantic recall and live updates. This page covers its container image (docker.io/montygovernance/montycat-mcp:1.1.5).

### Is the Montycat MCP - Shared Memory for AI Agents server safe to use?

Montycat MCP - Shared Memory for AI Agents scores 36 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 Montycat MCP - Shared Memory for AI Agents server expose?

Montycat MCP - Shared Memory for AI Agents exposes 24 tools: montycat_semantic_search, montycat_remember, montycat_recall, montycat_install_engine, montycat_list_keyspaces, and 19 more. Their descriptions and schemas cost roughly 4,453 tokens of context every time the server is loaded.

### Is the Montycat MCP - Shared Memory for AI Agents server still maintained?

Montycat MCP - Shared Memory for AI Agents 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 Montycat MCP - Shared Memory for AI Agents server under?

Montycat MCP - Shared Memory for AI Agents 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

- Repository: https://github.com/MontyGovernance/montycat-mcp
- Changelog RSS feed: https://verifymcp.io/servers/montygovernance-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5.xml
- Changelog JSON feed: https://verifymcp.io/servers/montygovernance-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5.json
- HTML version of this page: https://verifymcp.io/servers/montygovernance-montycat-mcp/docker-io-montygovernance-montycat-mcp-1-1-5