MuninnDB

Memory that strengthens with use, fades when unused, and pushes to you when it matters — accessible over MCP, REST, gRPC, or SDK.

Provisional patent filed Feb 26, 2026 on the core cognitive primitives (engine-native Ebbinghaus decay, Hebbian learning, Bayesian confidence, semantic triggers). This helps protect the project so we can keep it open and innovative for everyone.

Prerequisites: None. Single binary, zero dependencies, zero configuration required. To uninstall: rm $(which muninn) and delete ~/.muninn.

---

Try It — 30 Seconds

macOS / Linux:

# 1. Install
curl -sSL https://muninndb.com/install.sh | sh

# 2. Start (first-run setup is automatic)
muninn start

Windows (PowerShell):

# 1. Install
irm https://muninndb.com/install.ps1 | iex

# 2. Start (first-run setup is automatic)
muninn start

# 3. Store a memory
curl -sX POST http://127.0.0.1:8475/api/engrams \
  -H 'Content-Type: application/json' \
  -d '{"concept":"payment incident","content":"We switched to idempotency keys after the double-charge incident in Q3"}'

# 4. Ask what is relevant RIGHT NOW
curl -sX POST http://127.0.0.1:8475/api/activate \
  -H 'Content-Type: application/json' \
  -d '{"context":["debugging the payment retry logic"]}'

That Q3 incident surfaces. You never mentioned it. MuninnDB connected the concepts.

Web UI: http://127.0.0.1:8476 · Admin: root / password (change after first login)

---

Connect Your AI Tools

MuninnDB auto-detects and configures Claude Desktop, Cursor, OpenClaw, Windsurf, OpenCode, VS Code, and others:

muninn init

Follow the prompts. Done. Your AI tools now have persistent, cognitive memory.

Manual MCP configuration — if you prefer to configure by hand:

<details> <summary>Claude Desktop</summary>

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "muninn": {
      "url": "http://127.0.0.1:8750/mcp"
    }
  }
}

Note: "type" is intentionally omitted. Claude Desktop v1.1.4010+ crashes on startup if "type": "http" is present in any mcpServers entry — the transport is inferred from the URL.

</details> <details> <summary>Claude Code / CLI</summary>

Add to ~/.claude.json:

{
  "mcpServers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp"
    }
  }
}

</details> <details> <summary>Cursor</summary>

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp"
    }
  }
}

</details> <details> <summary>OpenClaw</summary>

Add to ~/.openclaw/openclaw.json:

{
  "mcpServers": {
    "muninn": {
      "command": "muninn",
      "args": ["mcp"],
      "transport": "stdio"
    }
  }
}

OpenClaw uses stdio transport. The muninn mcp proxy (included in the binary) handles bearer token auth automatically — no credential needed in the config file.

</details> <details> <summary>Windsurf</summary>

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp"
    }
  }
}

</details> <details> <summary>VS Code</summary>

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp"
    }
  }
}

</details> <details> <summary>OpenCode</summary>

Add to ~/.config/opencode/opencode.json (macOS/Linux) or %APPDATA%\opencode\opencode.json (Windows):

{
  "mcp": {
    "muninn": {
      "type": "remote",
      "url": "http://127.0.0.1:8750/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {file:~/.muninn/mcp.token}"
      }
    }
  }
}

Omit the headers block if you are running MuninnDB without token authentication.

Note: OpenCode tools are exposed as muninn_muninn_remember, muninn_muninn_recall, etc. (server key + tool name prefix). Users preferring shorter names can register the server under the key memory instead, which yields memory_muninn_remember, memory_muninn_recall, etc.

</details> <details> <summary>GitHub Copilot</summary>

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ADMIN_TOKEN"
      }
    }
  }
}

Replace YOUR_ADMIN_TOKEN with the token from your muninn.env file. Omit the headers block if running without token auth. If Copilot shows an OAuth error, the headers block is missing — adding it resolves it. Full Copilot setup guide →

</details> <details> <summary>Codebuff</summary>

Add to your Codebuff MCP config:

{
  "mcpServers": {
    "muninn": {
      "type": "http",
      "url": "http://127.0.0.1:8750/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ADMIN_TOKEN"
      }
    }
  }
}

For proactive memory behavior — Codebuff storing useful discoveries without being asked — add the memory instructions to your AGENT.md. Full Codebuff setup guide →

</details>

MuninnDB exposes 35 MCP tools — store, activate, search, batch insert, get usage guidance, manage vaults, and more. On first connect, call muninn_guide for vault-aware instructions. No token required against the default vault. Full MCP reference →

---

What Just Happened

Most databases store data and wait. MuninnDB stores memory traces — called engrams — and continuously works on them in the background. When you called activate, it ran a 6-phase pipeline: parallel full-text + vector search, fused the results, applied Hebbian co-activation boosts from past queries, injected predictive candidates from sequential patterns, traversed the association graph, and scored everything with ACT-R temporal weighting — in under 20ms.

The Q3 incident surfaced because MuninnDB understood that "payment retry logic" and "idempotency keys after a double-charge" are part of the same conversation. You never wrote that relationship. It emerged from semantic proximity and how these concepts travel together. That is the difference between a database and memory.

Deep dive: How Memory Works →

---

Why MuninnDB

• Temporal priority — the database continuously recalculates what matters based on how recently and how often you've accessed each memory. Memories you use stay sharp. Memories you ignore fade naturally. The database moves while you sleep.
• Hebbian learning — memories activated together automatically form associations. Edges strengthen with co-activation, fade when the pattern stops. You never define a schema of relationships.
• Predictive activation — the database tracks sequential patterns across activations and learns to surface the next memory before you ask for it. Recall@10 improves 21% in workflow-oriented use cases.
• Semantic triggers — subscribe to a context. The database pushes when something becomes relevant — not because you queried, but because relevance changed. No polling. No cron. The DB initiates.
• Bayesian confidence — every engram tracks how sure MuninnDB is. Reinforcing memories raise confidence; contradictions lower it. Grounded in evidence, not a label you assign.
• Plug-and-play AI onboarding — call muninn_guide and the database tells your AI exactly how to use memory, customized to the vault's configuration. No manual prompt engineering.
• Retroactive enrichment — add the embed or enrich plugin and every existing memory upgrades automatically in the background. No migration. No code change. The database improves what it already holds.
• Bulk insert — batch up to 50 memories in a single call across all protocols (REST, gRPC, MCP). Efficient for data seeding, migration, and high-throughput agents.
• Four protocols — MBP (binary, <10ms ACK), REST (JSON), gRPC (protobuf), MCP (AI agents). Pick your stack; they all hit the same cognitive engine.
• Single binary — no Redis, no Kafka, no Postgres dependency. One process. One install command. Runs on a MacBook or a 3-node cluster.

---

Examples

REST — the full cycle:

# Write
curl -sX POST http://127.0.0.1:8475/api/engrams \
  -H 'Content-Type: application/json' \
  -d '{
    "concept": "auth architecture",
    "content": "Short-lived JWTs (15min), refresh tokens in HttpOnly cookies, sessions server-side in Redis",
    "tags": ["auth", "security"]
  }'

# Activate by context (returns ranked, time-weighted, associated memories)
curl -sX POST http://127.0.0.1:8475/api/activate \
  -H 'Content-Type: application/json' \
  -d '{"context": ["reviewing the login flow for the mobile app"], "max_results": 5}'

# Search by text
curl 'http://127.0.0.1:8475/api/engrams?q=JWT&vault=default'

Python SDK:

from muninn import MuninnClient

async with MuninnClient("http://127.0.0.1:8475") as m:
    # Store
    await m.write(vault="default", concept="auth architecture",
                  content="Short-lived JWTs, refresh in HttpOnly cookies")

    # Activate — context-aware, ranked, cognitively weighted
    result = await m.activate(vault="default",
                              context=["reviewing the login flow"],
                              max_res