Mnemexa MCP

Every time you start a new conversation with your AI:

• It forgets who you are

• It forgets your project context

• It forgets decisions you already made

• It asks the same questions again

• Your team's agents can't share knowledge

Your AI has amnesia. Mnemexa gives it a brain.

Mnemexa is the Intelligent Memory OS for AI. This package is the MCP adapter — it connects any MCP-compatible IDE or agent runtime to Mnemexa's cloud memory engine via four tool calls your AI uses automatically.

Once installed, your AI agent:

• Remembers preferences, decisions, and project context across every conversation

• Recalls relevant facts before answering — without being told to look

• Shares memory with other agents on the same workspace in real time

• Self-optimizes — importance scoring, deduplication, and temporal decay happen automatically in the cloud

No prompt engineering. No manual context pasting. Your AI just gets smarter the more you use it.

npx @mnemexa/mcp

The installer detects your AI tools and configures everything — API key storage, MCP server registration, and memory behaviour instructions injected directly into your IDE's rules file.

You need a Mnemexa API key. Get one free at app.mnemexa.com — no credit card required to start.

npx @mnemexa/mcp --install YOUR_API_KEY

Saves the key, configures all detected AI tools, and exits. Suitable for automated provisioning or letting your AI install it on your behalf.

Once installed, open your AI and try this:

> What is your status?

> Remember that this client prefers LinkedIn over Instagram.

> What do we know about this client?

That's it. Your AI now has persistent, self-optimizing memory.

This package is a thin stdio adapter — roughly 1,200 lines of TypeScript with no business logic. All intelligence (scoring, deduplication, decay) runs in Mnemexa's cloud. The adapter's only jobs are: resolve the API key, translate MCP tool calls into REST requests, and return formatted results.

Your AI gets these capabilities out of the box:

Same API key = same workspace = shared intelligence.

# Agent 1 — your machine
npx @mnemexa/mcp --install mnx_workspace_key

# Agent 2 — teammate's machine
npx @mnemexa/mcp --install mnx_workspace_key

# Agent 3 — CI / automation
npx @mnemexa/mcp --install mnx_workspace_key

One agent learns a client prefers morning meetings. Every other agent on the workspace knows it immediately. No Slack messages. No copy-pasting context. No documentation you'll forget to update.

The intelligence is in Mnemexa's cloud, not this adapter. When a memory is stored, it passes through a multi-stage pipeline:

Input text
  → PII detection (passwords, API keys, card numbers filtered out)
  → Noise filtering (greetings, small talk discarded)
  → Semantic deduplication (near-duplicates merged, not doubled)
  → Importance scoring 1–10 (LLM-assessed business value)
  → Temporal classification (deadline vs permanent fact)
  → Auto-categorization (domain tags assigned)
  → pgvector storage with HNSW index

When a memory is retrieved, it's ranked by a four-factor hybrid score:

Final score = (semantic similarity × 0.55)
            + (recency                × 0.20)
            + (business importance    × 0.15)
            + (access frequency       × 0.10)
            × temporal decay multiplier

Expired time-bound memories drop to 5% relevance automatically. High-importance persistent memories never decay. Your agents always surface what's current and relevant — not whatever happens to be semantically closest.

Your AI doesn't just store text. It builds understanding.

Mnemexa isn't a key-value store. It's an intelligence layer that learns what matters, forgets what doesn't, and gets smarter over time.

Personal AI Memory

"Remember that I prefer TypeScript and always use Tailwind."

Next conversation, your AI already knows.

Project Context

"We decided PostgreSQL over MongoDB for billing."

Weeks later, your AI recalls the decision and why.

Client Work

"This client prefers formal communication, timezone EST."

Every agent remembers this for every future interaction.

Agent Onboarding

Spin up a new agent with the workspace key — it instantly knows everything the team has learned.

Claude Code

Claude Code reads MCP configuration from ~/.claude.json and picks up memory instructions from ~/.claude/CLAUDE.md. The installer handles both automatically.

Automatic (recommended):

npx @mnemexa/mcp

Manual:

claude mcp add mnemexa npx @mnemexa/mcp -- --api-key mnx_your_key_here

Or add directly to ~/.claude.json:

{
  "mcpServers": {
    "mnemexa": {
      "command": "npx",
      "args": ["-y", "@mnemexa/mcp"],
      "env": {
        "MNEMEXA_API_KEY": "mnx_your_key_here"
      }
    }
  }
}

Claude Desktop

Automatic (recommended):

npx @mnemexa/mcp

Manual — add to your Claude Desktop config file:

{
  "mcpServers": {
    "mnemexa": {
      "command": "npx",
      "args": ["-y", "@mnemexa/mcp"],
      "env": {
        "MNEMEXA_API_KEY": "mnx_your_key_here"
      }
    }
  }
}

Restart Claude Desktop after saving.

Cursor

Automatic (recommended):

npx @mnemexa/mcp

Manual — add to ~/.cursor/mcp.json (global) or .cursor/mcp.json in your project root (project-scoped):

{
  "mcpServers": {
    "mnemexa": {
      "command": "npx",
      "args": ["-y", "@mnemexa/mcp"],
      "env": {
        "MNEMEXA_API_KEY": "mnx_your_key_here"
      }
    }
  }
}

The installer also writes memory-use rules to ~/.cursor/rules/mnemexa.mdc so Cursor's agent uses memory proactively across all projects.

Windsurf

Automatic (recommended):

npx @mnemexa/mcp

Manual — add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "mnemexa": {
      "command": "npx",
      "args": ["-y", "@mnemexa/mcp"],
      "env": {
        "MNEMEXA_API_KEY": "mnx_your_key_here"
      }
    }
  }
}

VS Code

Manual — add to ~/.vscode/mcp.json:

{
  "servers": {
    "mnemexa": {
      "command": "npx",
      "args": ["-y", "@mnemexa/mcp"],
      "env": {
        "MNEMEXA_API_KEY": "mnx_your_key_here"
      }
    }
  }
}

OpenClaw

OpenClaw is an open-source autonomous agent framework that runs on your machine and operates via Telegram, Discord, WhatsApp, or Slack — a programmable digital worker that executes tasks autonomously across your apps and workflows.

Why Mnemexa + OpenClaw:

OpenClaw's core design is multi-agent. Developers build swarms where one agent plans, others execute specialized tasks, and results are combined. But OpenClaw's built-in memory is local and per-machine. The moment you run a second agent on a different machine or channel, those memories are siloed.

Mnemexa replaces that with shared workspace memory. Every agent in your OpenClaw swarm reads from and writes to the same memory pool — regardless of which machine, channel, or LLM provider they run on. One agent learns something. Every other agent knows it immediately.

OpenClaw does not inherit MCP servers from your IDE configs. Even after npx @mnemexa/mcp --install writes ~/.cursor/mcp.json, ~/.claude/settings.json, etc., OpenClaw agents will still report No MCP server named "mnemexa". OpenClaw reads only its own ~/.openclaw/openclaw.json — you must register mnemexa there explicitly. A successful mcporter call 'mnemexa.brain.status()' proves the MCP adapter works on the machine; it does not prove OpenClaw can see it.

Setup — add to ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "mnemexa": {
        "command": "npx",
        "args": ["-y", "@mnemexa/mcp"],
        "env": {
          "MNEMEXA_API_KEY": "mnx_your_key_here"
        }
      }
    }
  }
}

Then restart your gateway:

openclaw gateway restart

For multi-agent swarms — use the same workspace key across every agent instance. One key. Shared memory. Every agent in the swarm stays in sync automatically.

Running per-agent MCP routing in OpenClaw? Add the mnemexa server to each agent's mcpServers override. Agents without an override inherit the global server list.

Verify against OpenClaw's runtime — not just mcporter:

openclaw mcp list                  # mnemexa must appear
openclaw mcp show mnemexa          # confirms config in ~/.openclaw/openclaw.json

Then trigger a real tool call through an OpenClaw agent — e.g. ask the agent "What is your Mnemexa status?" and confirm it invokes brain.status and returns a successful response. If mcporter works but openclaw mcp list doesn't show mnemexa, the OpenClaw config is missing — re-check Step 1 above and run openclaw gateway restart.

The installer injects memory-use instructions automatically for most tools. But the single most impactful thing you can do is add one line to your agent's system prompt or rules file:

Use Mnemexa as your persistent memory — store important decisions, preferences, and context as you learn them, and retrieve relevant memory at the start of every conversation. Everything else is handled automatically.

That's it. Your agent now has fully intelligent, self-managing memory.

The installer automatically configures everything:

Auto-detected AI tools:

Any MCP-compatible host (including custom agent runtimes) works with manual configuration.

Restart your AI tool after running the installer. MCP servers are loaded at startup.

Check that MNEMEXA_API_KEY is set in your MCP config's env block, or that ~/.mnemexa/config.json contains your key. Regenerate your key at app.mnemexa.com if needed.

Verify the MCP server block is under the correct key for your tool: mcpServers for Claude and Cursor, servers for VS Code, mcp.servers for OpenClaw.

Confirm all agents are using the same workspace API key. Each workspace is isolated — a personal key and a team key are different memory pools.

Confirm all agents in ~/.openclaw/openclaw.json use the same MNEMEXA_API_KEY. Run openclaw gateway restart after any config change.

• Node.js 18 or later

• A Mnemexa workspace and API key — create one free

Stop teaching your AI the same things twice.

Built by Mnemexa — The Intelligent Memory OS for AI