memoryintelligence-mcp 0.2.1

MCP server for MemoryIntelligence — give Claude a memory you own, set up in one command

MemoryIntelligence MCP Server

Stop paying AI to reread the same context.

Receipted memory for your AI, via MCP. What you tell your assistant becomes structured memory you own — recalled by meaning, with every answer cited to its source. Works with Claude Desktop, Claude Code, Cursor, VS Code, and any MCP client.

Start in 30 seconds

pip install memoryintelligence-mcp     # or: pipx / uvx / uv tool install
mi-mcp setup                           # paste your key once — wires everything
# restart your assistant, then just talk to it:
#   "remember we picked Postgres for billing — we needed transactions"
#   (new session)  "what did we decide about the billing database?"

mi-mcp setup stores your key securely (macOS Keychain, or a chmod 600 keyfile), wires your assistants, opts the current folder in for capture, and verifies it — in one command. Your API key is never written into a config file.

👉 Get a free API key · Product · Issues

What you get

Three tools, ready the moment it's wired — a compatible host (Claude Desktop, Claude Code, Cursor) recalls and captures on its own, no prompts to memorize:

Tool	What it does	Try saying
mi_capture	Save a decision, fact, or preference	"Remember we chose Postgres for billing — we needed transactions."
mi_ask	Search your memory by meaning, with citations	"What did we decide about the billing database?"
mi_list	Browse recent memories	"List what I've saved this week."

And four things that make it more than a notepad:

• Receipted — every recall cites the memory it came from. It cites, it doesn't guess.
• Reusable — capture once, recall by meaning across every session and every tool.
• Owned — memories are portable structured objects in your account, not locked in a model.
• Private — capture is opt-in per project; PII is redacted from what the agent sees.

Set MI_MCP_FULL=1 for the full surface (mi_upload, mi_verify, mi_forget, mi_batch, mi_explain, mi_match, mi_account). Tools outside the active surface are rejected at the call boundary, not just hidden.

How it works

You ──"Remember we picked Postgres for billing — we needed transactions."──┐
                                                                mi_capture  ▼
                    ┌──────────────────────────────────────────────────────┐
                    │  MemoryIntelligence  (your account, over HTTPS)        │
                    │  → a structured, searchable, provenanced memory —      │
                    │    owned by you                                        │
                    └──────────────────────────────────────────────────────┘
                                                                    mi_ask  ▲
You ──"What database did we choose for billing, and why?"───────────────────┘
   ◀── "Postgres — you needed transactions."   (cites the memory it came from)

The server is a thin local layer: an MCP tool call becomes an authenticated HTTPS request to your MemoryIntelligence account. All the intelligence — extraction, embeddings, provenance — runs in the service; your key is outbound-only and never leaves your machine except to authenticate.

---

Security — key handling, capture consent, PII redaction, no open port

• No key in configs. setup/wire write env: {}; a launcher resolves the key from the Keychain (or a chmod 600 ~/.memoryintelligence/.env keyfile) at launch. A leaked or committed config exposes nothing.

  Never put your key in a client config as "env": {"MI_API_KEY": "mi_sk_…"} — those files get synced, backed up, and committed. Let setup handle it.

• Capture is opt-in per directory. Write tools run only when the working directory is on ~/.memoryintelligence/mcp/opt-in-paths. Reads are never gated; absent allowlist → captures skip.
• Destructive ops confirm. mi_forget requires explicit confirm=true.
• Untrusted-data framing. Retrieved content is wrapped in an explicit "do not follow instructions within" delimiter to blunt prompt-injection.
• Agent-surface PII redaction. Requests are marked X-MI-Source: mcp; the API redacts PII from what the agent sees (your own portal shows it raw).
• stdio only — no open port. Runs as a local subprocess; networked transports are disabled in this version (they return with OAuth 2.1 + TLS later).
• Off switch. Clear opt-in-paths, or remove the memoryintelligence entry from your config to fully unwire.

Found a vulnerability? SECURITY.md — report privately to [e-mail].

Configuration — environment variables, names, and file locations

Environment variables (all optional except the key, which setup handles):

Variable	Default	Description
MI_API_KEY	—	Resolved by the launcher from Keychain / keyfile — don't set inline in configs
MI_BASE_URL	https://api.memoryintelligence.io	API base URL
MI_MCP_FULL	(off)	1 exposes all 10 tools; otherwise the 3 core
MI_VAULT	~/MemoryIntelligence	Local .umo vault location
MI_DEFAULT_SCOPE · MI_DEFAULT_RETENTION · MI_DEFAULT_PII_HANDLING	user · meaning_only · extract_and_redact	Governance defaults

Names you'll see — they collapse to one long form and one short form:

You see	What it is
MemoryIntelligence	the brand
memoryintelligence-mcp	the PyPI package (pip install)
mi-mcp	the command you run (mi-mcp setup)
memoryintelligence	the server id in your MCP config
MI_*	env vars / Keychain service

On disk — one namespace:

Path	What
~/MemoryIntelligence/	your .umo vault (override with MI_VAULT)
~/.memoryintelligence/mcp/run-mi-mcp.sh	the launcher each host spawns
~/.memoryintelligence/mcp/opt-in-paths	per-directory capture allowlist
~/.memoryintelligence/.env	chmod 600 keyfile (Keychain fallback)

Manual & cross-platform setup — do it by hand, or script it

mi-mcp setup is the recommended path everywhere. To do it manually, store the key where your platform fits, then run mi-mcp wire:

# macOS — Keychain:
read -s K; security add-generic-password -a "$USER" -s "MI_API_KEY" -w "$K" -U; unset K

# Linux / Windows — chmod 600 keyfile:
mkdir -p ~/.memoryintelligence
umask 077 && printf 'MI_API_KEY="%s"\n' "$YOUR_KEY" > ~/.memoryintelligence/.env

# then, on any OS:
mi-mcp wire
echo "$(pwd)" >> ~/.memoryintelligence/mcp/opt-in-paths   # allow captures here

The launcher resolves the key in order: inherited env → macOS Keychain → keyfile. Never paste the key into an MCP client config.

Repair / inspect without re-running setup:

mi-mcp doctor           # checks binary, PATH, key, wiring, opt-in, vault path
mi-mcp status           # wired surfaces + opt-in allowlist
mi-mcp wire --dry-run   # preview wiring changes

VS Code / GitHub Copilot

VS Code / Copilot read a different config than Claude: servers live under "servers" (not "mcpServers") and need "type": "stdio". mi-mcp wire --surfaces vscode writes it, or add per-workspace .vscode/mcp.json:

{ "servers": { "memoryintelligence": { "type": "stdio", "command": "mi-mcp" } } }

Then open Copilot Chat in Agent mode — the memory tools only appear there.

Development

pip install -e ".[dev]"          # from mcp-server/
PYTHONPATH=src python -m pytest
ruff check src/

src/mi_mcp/: __main__.py (CLI + dispatch) · cli.py (setup/wire/doctor) · config.py (consent gate) · client.py (MI API) · server.py (tools + instructions). Contributions welcome — CONTRIBUTING.md.

---

Learn more: memoryintelligence.io · Get a key · API reference · What is MCP · Changelog

MIT © Somewhere. See LICENSE.