Skip to main content
Glama
mem9-guard-mcp

mem9-guard-mcp

by Riku-KANO

mem9-guard-mcp

An MCP server that exposes mem9 (the TiDB team's persistent memory backend for AI agents) behind OWASP agent-memory-guard.

Agents never touch the raw mem9 API — every read and write goes through the guard:

MCP client (agent)
        │  memory_read / memory_write / ...
        ▼
  mem9-guard-mcp (this server)
        │  MemoryGuard + Policy.strict()   ← inspect, then block / quarantine / redact
        ▼
  Mem9Store adapter (MemoryStore Protocol)
        │  REST (X-API-Key)
        ▼
      mem9 (api.mem9.ai or self-hosted)

This protects agent memory against prompt injection, secret leakage, and memory poisoning: malicious or sensitive content is blocked, quarantined, or redacted according to policy before it ever reaches — or returns from — the store.

Tools

Tool

Description

memory_write(key, value, source_class, memory_class)

Guarded write. Result is allow / redact / quarantine / blocked

memory_read(key, default)

Read with integrity verification and outbound screening

memory_delete(key)

Delete a key (protected keys are blocked)

memory_list()

List stored keys

security_events(limit)

Recent security events emitted by the guard (for auditing)

quarantine_list()

Writes currently held in quarantine

rollback / snapshot restore is intentionally not exposed. Recovery is an operator action; giving it to agents would let them discard legitimate writes or cover up poisoned data.

Related MCP server: elephantasm-mcp

Configuration (environment variables)

Variable

Description

MEM9_API_KEY

mem9 API key. Falls back to a local JSON store when unset

MEM9_API_URL

Defaults to https://api.mem9.ai. Override for self-hosted mem9

MEM9_AGENT_ID

X-Mnemo-Agent-Id header (optional)

MEM9_GUARD_POLICY

Path to a policy YAML. Defaults to Policy.strict()

MEM9_GUARD_LOCAL_PATH

Path of the fallback JSON store (default mem9_local_store.json)

Installing into Claude Code

Straight from GitHub (no clone needed — uvx fetches and builds on first run):

claude mcp add mem9-guard \
  --env MEM9_API_KEY=<your-key> \
  -- uvx --from git+https://github.com/Riku-KANO/mem9-guard-mcp mem9-guard-mcp

Or from a local clone (recommended while developing):

claude mcp add mem9-guard \
  --env MEM9_API_KEY=<your-key> \
  -- uv run --project <path-to-this-repo> mem9-guard-mcp

Notes:

  • MEM9_API_KEY is optional — omit the --env line to use the local JSON store fallback.

  • The server is registered for the current project by default; add --scope user to make it available in every project.

  • For self-hosted mem9, add --env MEM9_API_URL=<url>.

  • Verify with claude mcp list, or run /mcp in a new session to see the memory_write / memory_read / ... tools.

Other MCP clients

Any MCP client that supports stdio servers works, e.g.:

{
  "mcpServers": {
    "mem9-guard": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/Riku-KANO/mem9-guard-mcp", "mem9-guard-mcp"],
      "env": { "MEM9_API_KEY": "<your-key>" }
    }
  }
}

Development

uv sync
uv run pytest

# End-to-end smoke test over stdio (no LLM involved)
uv run python scripts/smoke_stdio.py

Notes

The mem9 v1alpha2 JSON field names (content / metadata / id) are not yet covered by a published official schema, so they are centralized as assumptions in src/mem9_guard_mcp/client.py. If the real API differs, that is the only file that needs to change.

License

MIT

Available Tools

6 tools
memory_deleteC

Delete a key from guarded mem9 memory. Protected keys cannot be deleted.

Inputs: key (required). Returns: object

memory_listA

List all keys currently stored in guarded mem9 memory.

Inputs: no named parameters. Returns: object

memory_readB

Read a value from guarded mem9 memory.

Reads run integrity verification and outbound screening; sensitive content may come back redacted, and tampered or policy-violating entries are blocked.

Inputs: key (required), default. Returns: object

memory_writeA

Write a value to guarded mem9 memory.

The value is screened by agent-memory-guard before persisting; the result may be
allow / redact / quarantine / block. Declare provenance honestly via source_class
(user_input | external_tool | agent_authored | system) — it drives self-poisoning
detection. Optionally classify with memory_class (e.g. "ephemeral").

Inputs: key (required), value (required), source_class, memory_class. Returns: object

quarantine_listA

List writes currently held in quarantine (detected anomalies pending review).

Inputs: no named parameters. Returns: object

security_eventsA

Return recent security events emitted by the guard (newest first).

Useful for auditing why a write was blocked, redacted, or quarantined.

Inputs: limit. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clear, distinct purpose: core memory operations (delete, list, read, write) plus quarantine and security events. No overlap ambiguity.

    Naming Consistency4/5

    Main tools follow a consistent 'memory_' prefix pattern. 'quarantine_list' and 'security_events' deviate slightly but are still descriptive and follow a sensible scheme.

    Tool Count5/5

    Six tools is an appropriate number for a guarded memory system, covering essential operations without being overwhelming.

    Completeness4/5

    Covers CRUD (memory_write as create/update, memory_read, memory_delete, memory_list) plus quarantine and security auditing. Missing an explicit update operation, but write can serve that role.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      An MCP-native, local-first memory server that gives AI agents persistent, structured memory across sessions and tools, enabling them to maintain identity and context without reconfiguration.
      3
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that provides persistent memory capabilities for AI agents using Mem0, enabling storage, search, and management of contextual information across conversations with support for multiple backends and LLM providers.
      18
      112 PyPI
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      An MCP server offering hybrid memory recall and continuity tools for AI agents. It also provides a governance gateway that pre-approves risky shell/file/git actions before execution.
      19
      Apache 2.0