mcp

The Problem

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.

What This Is

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.

Install

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.

Try It in 10 Seconds

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.

Architecture

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.

Tools

Your AI gets these capabilities out of the box:

Multi-Agent Memory

Give your entire AI team a shared brain.

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.

How the Memory Engine Works

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.

Why Mnemexa?

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.

Use Cases

Setup by Tool

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 One Thing Worth Adding to Your Agent Instructions

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.

What Gets Installed

The installer automatically configures everything:

Auto-detected AI tools:

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

Security

Environment Variables

Troubleshooting

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.

Requirements

• Node.js 18 or later
• A Mnemexa workspace and API key — create one free

Built With