MCP.so
Sign In

PLURVerifiedFeatured

@plur-ai

About PLUR

AI agents start every session with amnesia — you re-explain the project, repeat your preferences, and correct the same mistakes over and over. PLUR gives them a memory that persists. Your agent's corrections, preference

Config

Add this server to your MCP-compatible client using the configuration below.

{
  "mcpServers": {
    "plur": {
      "command": "npx",
      "args": [
        "-y",
        "@plur-ai/mcp"
      ]
    }
  }
}

Tools

12

Create an engram — record a reusable learning, preference, or correction. Multi-agent note: in an orchestration that spawns subagents, have the PARENT session own plur_learn writes — spawned subagents should return their findings as text for the parent to persist, rather than each calling plur_learn (tool availability is not guaranteed in every subagent context). See plur-ai/plur#281.

Search engrams by topic. Default mode is hybrid (BM25 + local embeddings via RRF) — set mode:"keyword" for BM25-only. No API calls, fully local. Note: a project-scope filter also returns personal-family engrams (local, global, user:*, agent:*); an explicit scope=global recall returns ALL personal-family engrams — wider than scope=global INJECT, which is targeted to the global namespace only.

Rate an engram's usefulness — trains injection relevance over time. Supports single or batch mode.

Retire an engram by ID or search term — marks it as no longer active without deleting history

Uninstall an engram pack by name — removes the pack and all its engrams

Return system health — running version, engram count, episode count, pack count, storage root. Optionally filter engram counts by domain prefix and/or creation date.

Counted report of what your memory retrieved for you: engrams stored, how many were retrieved and how often, which are most relied on, and how much of the store is dormant. Local and read-only; every figure is directly counted, never estimated. IMPORTANT when relaying to the user: `activation_rate` is COVERAGE over the logging window (≈ how much of the store was surfaced), NOT a quality or effectiveness score — it is naturally low and FALLS as more engrams are added, so never present it as "memory is N% effective". A `summary` line is included; prefer relaying that.

Diagnose the PLUR ENGINE (embedder, hybrid search, remote-store auth) — not hook/MCP wiring. Reports whether the embedding model loaded, whether hybrid search is fully operational, and — for any configured enterprise/remote store — whether its auth is valid (probes /api/v1/me and decodes token expiry), so a dead or soon-to-expire token surfaces instead of hiding behind a "healthy" report. Run this first when recall feels off or team engrams stop syncing. Does NOT check .cursor/mcp.json, .cursor/hooks.json, or the live MCP tool count — for that, run the `plur doctor` CLI command in a terminal (a different, more thorough check with the same name).

Start a session — inject relevant engrams for your task. Call at the beginning of every session.

End a session. BEFORE calling this tool, review the conversation and extract learnings: 1. Corrections the user made ("no, use X not Y") → type: behavioral 2. Preferences stated ("always X", "never Y") → type: behavioral 3. Codebase patterns discovered (naming, structure, conventions) → type: architectural 4. Technical facts learned (API quirks, config, gotchas) → type: procedural 5. Terminology defined or clarified → type: terminological Include at least one engram_suggestion if ANYTHING was learned. An empty suggestions array means nothing worth remembering happened — this should be rare.

Purge all conflict relations from local engrams — removes accumulated false positives from the legacy tension-detection system

Dispatch for less-common PLUR operations (packs, sync, tensions, stores, timeline, ingest, and more), collapsed into one tool so Cursor's ~40-tool-per-workspace limit is not exhausted by PLUR alone. Set "action" to the underlying tool name and "args" to that tool's normal arguments. Valid actions: plur_capture, plur_episode_to_engram, plur_extract_meta, plur_history, plur_ingest, plur_inject, plur_inject_hybrid, plur_learn_batch, plur_meta_engrams, plur_packs_discover, plur_packs_export, plur_packs_install, plur_packs_list, plur_packs_preview, plur_pin, plur_profile, plur_promote, plur_recall_hybrid, plur_report_failure, plur_scopes_discover, plur_similarity_search, plur_stores_add, plur_stores_list, plur_suggest_scope, plur_sync, plur_sync_status, plur_tensions, plur_timeline, plur_validate_meta.

Overview

What is PLUR?

PLUR is open, local-first memory for AI agents. Your agent's corrections, preferences, and conventions are stored as plain-text engrams on your own machine — memory you can read, correct, and delete, not weights baked into a model you can't inspect. One store works across Claude Code, Cursor, Windsurf, OpenClaw, and Hermes over MCP, so what your agent learns in one tool carries over to the next.

Why PLUR

  • Plain-text you own — every engram is human-readable YAML you can read, git diff, edit, and provably delete. Not opaque vectors or model weights.
  • Local-first, zero-cost — hybrid search (BM25 + local embeddings) runs fully offline: no API calls, no per-query cost.
  • Cross-tool — the same ~/.plur/ store is shared across Claude Code, Cursor, Windsurf, OpenClaw, and Hermes.
  • Team-shareableplur sync is git underneath, so the same memory follows you across machines and across a team.
  • It learns and forgets — feedback-trained retrieval with ACT-R activation decay and an on-demand contradiction scan, not a grow-forever store.

Benchmarks

98% R@5 on the full LongMemEval-S corpus (N=500), fully local and reproducible with a pinned corpus SHA. Retrieval and end-to-end answer accuracy are reported separately, never conflated. Harness: plur-ai/plur-bench.

Install

One line sets up storage, MCP config, and hooks:

npx @plur-ai/mcp init

Then ask your agent "What's my PLUR status?" to confirm it works. See the README for Cursor, OpenClaw, Hermes, and Python setup.

Tools

PLUR exposes ~40 MCP tools. Core set: plur_learn (store a correction or preference), plur_recall_hybrid (retrieve relevant memories), plur_inject_hybrid (select engrams within a token budget), plur_feedback (rate relevance), plur_forget (retire a memory), plur_capture and plur_timeline (event episodes), and plur_status.

License

Apache-2.0 — the engram format is an open, versioned standard. Read it, build your own tooling, or run a different engine on the same files.

Comments

More Memory & Knowledge MCP servers