# Memoryintelligence Mcp

> Stop paying AI to reread the same context — receipted memory via MCP. Capture once, recall with citations; one-command setup for Claude Desktop, Claude Code & Cursor.

- **Type:** MCP server
- **Install:** `agentstack add mcp-somewhere11-memoryintelligence-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [somewhere11](https://agentstack.voostack.com/s/somewhere11)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [somewhere11](https://github.com/somewhere11)
- **Source:** https://github.com/somewhere11/memoryintelligence-mcp
- **Website:** https://memoryintelligence.io

## Install

```sh
agentstack add mcp-somewhere11-memoryintelligence-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# MemoryIntelligence MCP Server

[](https://pypi.org/project/memoryintelligence-mcp/)
[](https://pypi.org/project/memoryintelligence-mcp/)
[](LICENSE)
[](https://modelcontextprotocol.io)

> ## 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

```bash
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](https://memoryintelligence.io) ·
[Issues](https://github.com/somewhere11/memoryintelligence-mcp/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](SECURITY.md) — report privately to connect@somewheremedia.com.

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`:

```bash
# 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:**
```bash
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`:

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

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

Development

```bash
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](CONTRIBUTING.md).

---

**Learn more:** [memoryintelligence.io](https://memoryintelligence.io) ·
[Get a key](https://memoryintelligence.io/portal) ·
[API reference](https://memoryintelligence.io/docs/api-reference) ·
[What is MCP](https://modelcontextprotocol.io) ·
[Changelog](CHANGELOG.md)

MIT © Somewhere. See [LICENSE](LICENSE).

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [somewhere11](https://github.com/somewhere11)
- **Source:** [somewhere11/memoryintelligence-mcp](https://github.com/somewhere11/memoryintelligence-mcp)
- **License:** MIT
- **Homepage:** https://memoryintelligence.io

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** yes
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-somewhere11-memoryintelligence-mcp
- Seller: https://agentstack.voostack.com/s/somewhere11
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.