Cursor is the fastest AI pair-programmer most teams have ever used. It’s also amnesiac — and, worse, it’s an island.

Every chat session starts cold. Every repo is its own universe. When your teammate hits the same bug you fixed yesterday, their Cursor has no idea you already solved it. When you switch machines, every convention, decision, and hard-won insight dies with the .cursor-session file.

You end up re-pasting context. Re-explaining the architecture. Watching three people on your team re-discover the same pgvector gotcha in the same week.

MemClaw fixes that with one MCP config block — and that’s just the beginning.

What you’re actually connecting is persistent, shared, governed memory designed for fleets of AI agents — not just one Cursor, but every Cursor, every Claude Code, every Windsurf, every bespoke agent your org runs. One memory store. Row-level tenant isolation. Audit trails on every read and write. Visibility scopes so Marketing’s Cursor doesn’t read R&D’s secrets.

Today: your Cursor stops forgetting across sessions.
Tomorrow: your team’s Cursors share what they learn.
Next quarter: every AI tool in your org pulls from one governed memory layer.

This post gets you the first rung in under five minutes. One config. No SDK. No infra.

What you get

Ten tools appear in Cursor the moment you connect — memory, reflection, and structured documents (which is also how skills are shared across a team):

memclaw_write       Store content (single or batch of up to 100)
memclaw_recall      Hybrid semantic + keyword + graph search
memclaw_manage      Read / update / transition / delete memories
memclaw_list        Filter by type, status, agent, weight, date
memclaw_doc         Structured JSON documents (customer records, configs)
memclaw_entity_get  Look up an entity with linked memories + relations
memclaw_tune        Tune this agent's retrieval profile
memclaw_insights    Analyze the memory store (contradictions, patterns)
memclaw_evolve      Report outcomes; MemClaw auto-generates prevention rules
memclaw_stats       Aggregate counts: total + breakdowns by type, agent, status

For multi-agent teams: skill sharing rides on memclaw_doc with collection="skills" — op=write to publish a SKILL.md to the tenant catalog, op=search / op=query for other agents to discover it, op=delete to retire. The server validates the slug and auto-embeds the description.

You don’t pick between a vector DB and a knowledge graph — MemClaw runs both under every write. Every memory is embedded (for semantic similarity), indexed for full-text search, auto-classified into one of 14 types, tagged, scored for importance, scanned for PII, and decomposed into entities + relations for graph-aware recall. From a single content field.

Install in 5 minutes — managed platform

1. Get an API key

Sign up at memclaw.net. In the dashboard go to Settings → API Keys, hit Create key, and copy the mc_…value. Free tier is generous enough to evaluate; no credit card.

2. Add MemClaw to Cursor’s MCP config

In Cursor: Settings → MCP Servers → Add Server. Or edit the JSON file directly at ~/.cursor/mcp.json(macOS/Linux) or %USERPROFILE%\.cursor\mcp.json (Windows).

{
  "mcpServers": {
    "memclaw": {
      "url": "https://memclaw.net/mcp/",
      "headers": {
        "X-API-Key": "mc_your_api_key_here"
      }
    }
  }
}

The trailing slash matters. Without it, the gateway issues a 307 Temporary Redirect to the raw Cloud Run host, which strips the X-API-Key header. Cursor shows the server as “installed” with a green toggle but the tools never actually load.

3. Restart Cursor

MCP discovery runs on cold start. Close Cursor completely (kill it from Activity Monitor / Task Manager to be sure) and reopen.

4. Verify

In any Cursor chat, ask:

List the MCP tools available.

You should see the ten memclaw_* tools. If you don’t, check Settings → MCP Servers for a red error indicator — it’s almost always a mistyped API key or URL.

Self-hosting instead? 5 minutes the other way.

Prefer to run on your own infra? MemClaw is Apache 2.0 on GitHub. Clone and start the stack:

git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw
cp .env.example .env
docker compose up -d
curl http://localhost:8000/api/v1/health

Then point Cursor at localhost instead:

{
  "mcpServers": {
    "memclaw": {
      "url": "http://localhost:8000/mcp",
      "headers": {
        "X-API-Key": "standalone"
      }
    }
  }
}

Default OSS config runs in single-tenant standalone mode. MCP still requires a non-empty X-API-Key header — any string works.

Teach Cursor to use the tools (the 30-second polish)

Claude Code and Codex users get a skill file — an instruction sheet MemClaw ships that tells the agent when to recall, when to write, and how to handle contradictions. Cursor doesn’t support skills the same way, but it supports Cursor Rules, which does the same job.

Open Settings → Rules in Cursor and paste this at the bottom of your global rules:

## MemClaw memory usage

- Before answering questions about this project, team, or my work,
  use memclaw_recall with a clear query. Treat what you find as ground truth.
- When I tell you a decision, convention, or fact I want preserved,
  use memclaw_write with a concise title and descriptive content.
- If memclaw_recall returns conflicting memories, use memclaw_manage
  to transition the older one to "superseded" instead of silently picking.
- When you finish a task that used recalled memories, call memclaw_evolve
  with the outcome so MemClaw learns what works.

Four lines. Cursor now uses MemClaw instinctively instead of waiting to be asked.

Why “multi-agent” is the real win

Single-agent memory is a feature. Multi-agent shared memory is a category.

Your Cursor writes a memory. Your Claude Code recalls it in a different repo. Your Windsurf sees the pattern during code review. Your bespoke customer-support agent surfaces the same fact to the customer. None of them re-derive. None of them leak across tenant boundaries they shouldn’t cross. All of it is audited.

That’s not a vector DB with extra sauce. It’s the infrastructure layer AI orgs have been building ad-hoc inside every company, poorly, for the last two years.

MemClaw does it once, centrally, with row-level tenant isolation, four-tier agent trust scopes, visibility rules per memory, automatic PII quarantine, contradiction detection across writes, and a crystallizer that merges near-duplicate facts into canonical entries with full provenance.

You don’t have to build any of that. You just connect Cursor today, and the rest of the ladder is there when you’re ready to climb.

Next steps

Check out the For Agents guide for patterns on when to call each of the ten tools.
Star the GitHub repoif you want to self-host or just follow along.
Read Shared Governed Memoryfor the architectural thinking behind multi-agent memory.
When you’re ready to go from personal memory to fleet infrastructure, our Pro and Business plansadd per-fleet governance, audit exports, and SSO.

Five minutes of setup. A whole new kind of Cursor afterwards.