MemoryIntelligence MCP Server

## ⚠️ DEPRECATED — 0.2.14 is the final release

>

This package (mi-local) is retired. It keeps working but receives no further updates, fixes, or new tools. Replace it with:

>

- On your computer: the MemoryIntelligence desktop app's built-in MCP (Connect Claude inside the app). It sees everything you connect to MI and enforces the per-category disclosure you choose there, which this package never could. - On the web and phone: the claude.ai MemoryIntelligence connector.

>

Every start of mi-mcp, mi-mcp setup and mi-mcp doctor prints this notice to stderr. Decision and rationale: MemoryIntelligence#2186.

## 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](https://memoryintelligence.io/portal) · 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:

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.

The default surface is 7 tools (also mi_upload, mi_verify, mi_forget, mi_workspaces). Set MI_MCP_FULL=1 for the full 11-tool surface (adds mi_batch, mi_explain, mi_match, mi_account). Tools outside the active surface are rejected at the call boundary, not just hidden.

Capturing into a shared workspace

By default every capture is personal — it lands in your home workspace and nobody else sees it. To put one in a team space, name it:

"List my workspaces." → mi_workspaces "Save that to Somewhere Inc." → mi_capture(workspace_id=…)

Two rules keep a shared space from filling up by accident:

• A workspace with more than one member needs an explicit confirm. The first

call returns a preview — "this posts to Somewhere Inc, visible to 4 members" — and saves nothing. Only after you say yes does the agent re-call with confirm=true. A fresh chat can't inherit that approval.

• Every capture tells you where it went, and a workspace you don't belong to is

refused rather than quietly saved somewhere else.

Reading works the same way — mi_ask and mi_list take the same workspace_id:

"What did the team decide about billing?" → mi_ask(workspace_id=…)

Omit it and you search your own memories. One caveat worth knowing: whether a workspace read returns other members' memories is a server-side setting that is off by default. The result's scope block reports member_wide_reads so the assistant can tell you what it actually searched instead of assuming.

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.

<details> <summary><b>Security</b> — key handling, capture consent, PII redaction, no open port</summary>

• No key in configs. The key is resolved from the Keychain (or a `chmod 600

~/.memoryintelligence/.env keyfile) **at launch** — in-process for Claude Desktop (direct python -m mi_mcp` entry; its sandbox blocks shell scripts), via the launcher script for Code/Cursor. 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 mi-local entry from

your config to fully unwire.

Found a vulnerability? SECURITY.md — report privately to [email protected]. </details>

<details> <summary><b>Configuration</b> — environment variables, names, and file locations</summary>

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

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

On disk — one namespace:

</details>

<details> <summary><b>Manual & cross-platform setup</b> — do it by hand, or script it</summary>

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 version, binary, PATH, key, wiring, opt-in, vault path
mi-mcp status           # wired surfaces + opt-in allowlist
mi-mcp wire --dry-run   # preview wiring changes

Staying current. doctor compares your installed version against both channels this package ships on — PyPI and the public GitHub mirror — and prints the upgrade command for how you actually installed it:

[✗] version  0.2.5 installed, 0.2.8 available — `uv tool upgrade memoryintelligence-mcp && mi-mcp wire`

Both channels are checked because they can diverge, and reading one alone told mirror users they were current when they were not (0.2.6 was installable from the mirror while PyPI went straight 0.2.5 → 0.2.7). When the channels disagree, doctor names them — even if you are on the newest of the two — because that divergence is worth knowing about:

[✓] version  0.2.6 (latest)  [channels differ: PyPI 0.2.5, mirror 0.2.6]

An unreachable channel reads as unknown, never as up to date, and never as a disagreement.

Run mi-mcp wire after any upgrade — 0.2.6 renamed the server, and a config left pointing at the old id loses its tools silently. The checks are anonymous fetches of the PyPI index and the mirror's pyproject.toml; skip them entirely with --no-version-check or MI_MCP_NO_VERSION_CHECK=1, and they fail quietly when you're offline.

Which server am I talking to? The local server announces mi-local; the remote MCP surface announces memoryintelligence-remote. The local default surface is 7 tools; the remote is 4 — if the tool list doesn't match what you expect, the client resolved the other surface (#1320). </details>

<details> <summary><b>VS Code / GitHub Copilot</b></summary>

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": { "mi-local": { "type": "stdio", "command": "mi-mcp" } } }

Then open Copilot Chat in Agent mode — the memory tools only appear there. </details>

<details> <summary><b>Development</b></summary>

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. </details>

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

Apache-2.0 © Somewhere Media, LLC. See LICENSE.