Persistent Memory for Claude Code, Cursor, Windsurf, Codex & Claude Desktop with OE MCP

Every time you start a new session in Claude Code, Cursor, Windsurf, Codex, or Claude Desktop, your AI assistant starts fresh — no memory of your database hosts, your release process, your team conventions. OE MCP's built-in memory tools fix that. Four simple commands let your AI assistant remember anything across sessions, forever.

What You Need

• OE MCP installed — run npx -y @openenthrium/oe-mcp or follow the setup guide
• Claude Code, Cursor, Windsurf, or any MCP-compatible AI assistant

The Problem: AI Assistants Forget Everything

Every session in Claude Code, Cursor, Windsurf, Codex, or Claude Desktop starts cold. You tell Claude your production database is on prod-db.company.com — it remembers for the session, then forgets. Next session, you explain it again. And again. And again.

The same goes for your release process, your team conventions, which branches are protected, which API keys go where. Valuable context that you repeat endlessly, every single session.

OE MCP solves this with four built-in memory tools that store key-value pairs in a local oe-mcp-memory.json file — right next to your oe-mcp.json — and make them available to Claude in every future session automatically.

The Four Memory Tools

These tools are available in every OE MCP session automatically — no extra configuration needed. As soon as you connect OE MCP to Claude Code, Cursor, Windsurf, Codex, or Claude Desktop, your AI assistant can call them.

How It Works in Practice

Just talk to Claude naturally. It decides when to call the memory tools based on what you say:

# You say:
"Remember that our main database is on prod-db.company.com"

# Claude calls:
memory_set(key="main_db_host", value="prod-db.company.com")

# Next session, Claude already knows. You never repeat it.

# You say:
"On every release, bump all 6 package.json files before tagging"

# Claude calls:
memory_set(key="release_rule", value="Bump all 6 package.json files before tagging: app/package.json, server/package.json, frontend/package.json, processor/package.json, server/cli/npm/package.json, server/mcp/npm/package.json")

# Claude follows this rule automatically in future sessions.

What to Store in Memory

Anything that you find yourself repeating session after session is a good candidate. Here are the most common use cases:

Setting Up OE MCP

If you haven't connected OE MCP to your AI assistant yet, it takes under two minutes.

Step 1 — Create your oe-mcp.json config file:

{
  "connectors": [
    {
      "name": "my-postgres",
      "type": "postgresql",
      "host": "localhost",
      "port": 5432,
      "database": "mydb",
      "user": "postgres",
      "password": "secret"
    },
    {
      "name": "my-github",
      "type": "github",
      "repoUrl": "https://github.com/your-org/your-repo",
      "personalAccessToken": "ghp_xxxxxxxxxxxx"
    },
    {
      "name": "my-codebase",
      "type": "filesystem",
      "basePath": "/home/user/projects/myapp"
    }
  ],
  "memory": [
    { "key": "project_name",    "value": "My Project" },
    { "key": "current_version", "value": "1.6.4" }
  ]
}

Step 2 — Add to your AI assistant.

Add this to your AI app's MCP config (Claude Code, Cursor, Windsurf, Codex, Claude Desktop) — macOS / Linux:

{
  "mcpServers": {
    "oe-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@openenthrium/oe-mcp", "--stdio", "/path/to/oe-mcp.json"]
    }
  }
}

Windows — use npx.cmd instead of npx:

{
  "mcpServers": {
    "oe-mcp": {
      "type": "stdio",
      "command": "npx.cmd",
      "args": ["-y", "@openenthrium/oe-mcp", "--stdio", "C:\\path\\to\\oe-mcp.json"]
    }
  }
}

Step 3 — Reload your AI app. Your connectors and memory tools appear automatically.

Seeing It in Action

Once connected, you can ask Claude to show you everything it remembers:

# You say:
"Show me everything you remember about this project"

# Claude calls memory_list and returns:
current_version: 1.6.3
release_rule: Bump all 6 package.json files before tagging...
main_db_host: prod-db.company.com
monorepo_structure: Tag on enthrium-commercial fans out to 3 public repos...

And when information changes — say you release a new version — Claude updates memory automatically:

# You say:
"We just released v1.7.0"

# Claude calls:
memory_set(key="current_version", value="1.7.0")

# Done. It knows for all future sessions.

Built-in Action Log — See Every Connector Call

Alongside memory, OE MCP ships with a persistent action log. Every connector tool call is automatically recorded to oe-mcp-log.json next to your config — timestamp, connector name, tool, input, and result. No setup needed.

# You say:
"Show me the action log"

# Claude calls log_list and returns:
[2026-08-08T04:59:33Z] my-postgres → query | result: ok
[2026-08-08T04:58:01Z] my-github → list_files | result: ok
[2026-08-07T21:32:44Z] my-slack → post_message | result: ok

Each log entry is a structured JSON object in oe-mcp-log.json:

{
  "ts": "2026-08-08T04:59:33.289Z",
  "connector": "my-postgres",
  "tool": "query",
  "input": { "sql": "SELECT * FROM users LIMIT 10" },
  "result": "ok"
}

Why This Matters for Enterprise Teams

For individual developers, persistent memory is a productivity win. For enterprise teams, it's more significant: it means every developer on the team can share the same memory configuration via oe-mcp.json in version control. Everyone's AI assistant knows the same release process, the same infrastructure layout, the same team conventions — from day one.

New team members get onboarded automatically. Senior engineers encode their tribal knowledge once. And it never drifts out of sync because Claude updates it as things change.