MemVault MCP server
Commit Nov 15, 2026Provides a shared, local-first memory layer that allows multiple AI agents to persist and recall preferences, project context, and past decisions.
Also known as dreamor/memvault, memvault
- Stars
- 2
- Tools
- 21
- Downloads, 30 days
- —
- Latest version
- 0.7.2
- Last commit
- Nov 15, 2026
- License
- MIT
What is MemVault MCP?
MemVault provides a shared, local-first memory layer that allows multiple AI agents to persist and recall preferences, project context, and past decisions. It exposes 21 tools, such as add_evidence, confirm_read, delete_memory.
Summary generated from the project's README
About MemVault MCP server
MemVault provides a shared, local-first memory layer designed to bridge the gap between different AI agents. Instead of every session starting from scratch, this tool allows multiple MCP-compatible clients like Claude Desktop, Cursor, and Claude Code to access a unified repository of preferences, project context, and past decisions. It functions as a memory router that sits between your agents and their context, ensuring that information learned in one tool is available to others without manual repetition.
The system is self-hosted and private, utilizing a SQLite backend with bundled full-text search. It supports hybrid retrieval by combining keyword search with vector embeddings, which can be powered by a native in-process embedder or a local Ollama instance. Users can manage their memory through a command-line interface, including commands to save preferences, search across all stored data, and extract structured memories from free text. The server also features an auto-injection pipeline that prioritizes critical rules as direct instructions for the connected agent.
What you can do with it
- 1Persist project conventions across toolsA developer can ensure that coding standards learned in one IDE are automatically applied when using a CLI agent.
- 2Automate preference injectionYou can save high-priority user preferences that the AI must follow as direct instructions during a session.
- 3Extract structured knowledge from chatConvert unstructured conversational text into organized, searchable memory entries.
- 4Maintain local privacy with OllamaRun the entire memory and extraction pipeline on your own hardware using local models.
Written from the project's README. Every use case is checked against a quote from it.
How to install MemVault MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall MemVault MCP in Claude Code
$ claude mcp add memvault -- docker run -i --rm ghcr.io/dreamor/memvault:v0.7.2Install MemVault MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"memvault": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/dreamor/memvault:v0.7.2"
]
}
}
}Install MemVault MCP in VS Code
.vscode/mcp.json
{
"servers": {
"memvault": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/dreamor/memvault:v0.7.2"
]
}
}
}Install MemVault MCP in VS Code CLI
$ code --add-mcp '{"name":"memvault","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/dreamor/memvault:v0.7.2"]}'Install MemVault MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"memvault": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/dreamor/memvault:v0.7.2"
]
}
}
}Install MemVault MCP in Codex
$ codex mcp add memvault -- docker run -i --rm ghcr.io/dreamor/memvault:v0.7.2Install MemVault MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.memvault] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/dreamor/memvault:v0.7.2"]
Install MemVault MCP in Gemini CLI
$ gemini mcp add -s user memvault docker -- run -i --rm ghcr.io/dreamor/memvault:v0.7.2Install MemVault MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"memvault": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/dreamor/memvault:v0.7.2"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for ghcr.io/dreamor/memvault:v0.7.2 v0.7.2 in an isolated container with no network and no keys. It answered and listed 21 tools. It ran on an x86 (amd64) build; ARM machines may need emulation.
MemVault MCP tools 21
Read from the server with tools/listadd_evidenceActionRecord evidence for a memory. relation="supports"/"contradicts" links evidence_id → memory_id (a memory supporting or contradicting it); relation="sourced_from" records memory_id's external provenance via `source` (URL/document). Writes one relation and returns its relation_id; an identical relation is rejected rather than duplicated. Contradictions accelerate the contradicted memory's decay; superseded or archived evidence stops counting. Requires agent auth when the agent has a registered key.
confirm_readActionConfirm that one or more memories have been read by the agent. Increments access_count and sets last_read_at for the specified memory IDs; unknown IDs are skipped and the response reports how many rows were confirmed. Repeated calls increment the counters again (not idempotent). Requires agent auth when the agent has a registered key.
delete_memoryActionSoft-delete one memory by its ID: removes its live row, FTS entry, and cascaded evidence relations so it is no longer searchable or injected. A full snapshot is written to memory_history first; restore is available through the CLI (`memvault restore`), not through this MCP tool. Use forget_memory for an irreversible GDPR-style purge. Requires agent auth when the agent has a registered key; a second delete of the same ID returns NotFound.
extract_memoriesActionExtract structured memories from conversation text. mode="rule" (default) detects preferences, facts, and skills via keyword pattern matching. mode="llm" instead understands the full context (optionally pairing assistant_text) semantically — uses the configured LLM extraction provider, and degrades to rule-based extraction (reported via fallback_used/fallback_reason) when no provider is configured or the LLM call fails. Returns extracted items; with auto_save=true it also writes them through delta-write (near-identical memories are merged or skipped, not duplicated) and requires agent auth when the agent has a registered key. Use save_memory instead when you already know the exact memory to store. Invalid occurred_at is an error, never a silent drop.
forget_memoryActionPermanently erase (GDPR-style) one memory by id or a bulk set matched by criteria (namespace/namespace_prefix/source_agent_id/tag/memory_type/before_days). Unlike delete_memory, this also purges memory_history snapshots and any orphaned compliance rows, leaving only a content-hash audit entry in the forgotten-log — irreversible. dry_run defaults to true: call once to preview, then again with dry_run=false to execute. Priority::Must memories are excluded unless allow_must=true. Gated by the same per-agent API-key auth as delete_memory — there is no separate admin tier at the MCP layer.
get_compliance_reportRead-onlyGet a compliance report for injection sessions: with inject_session_id, followed/violated/pending counts plus compliance_rate for that session; without it, an aggregate summary (total_sessions, overall_rate, must_rate, recent_sessions) filtered by optional agent_id and limit (default 10). compliance_rate/overall_rate/must_rate are null when no real MUST verdict exists yet (all pending/unknown); null never means 100%. Use report_compliance to record follow/violation status — this tool only reads it.
get_effectiveness_reportRead-onlyGet automatic effectiveness judgments for injected memories: useful/neutral/harmful/insufficient_context rates, judged automatically from record_outcome — independent of manual report_compliance. Optional agent_id filters the summary and limit defaults to 10. Read-only; returns JSON and does not change records.
get_memory_evidenceRead-onlyGet the raw-evidence chain a memory was distilled from (its L0 trace rows), plus its evidence profile. Read-only grounding: lets an agent quote the original session text and name its sources. Use add_evidence to write a new relation or source — this tool only reads the existing chain. Missing or pruned evidence yields an empty chain rather than a write; requires agent auth when the agent has a registered key.
import_skillsActionImport skills from a Markdown SOP document. Each #/## heading becomes a skill (trigger:/verification: metadata lines + list-item steps). Sections without steps are skipped. Imported skills enter the review inbox unless approve=true. Writes new skill memories; repeating the same import can create duplicates. Requires agent auth when the agent has a registered key.
infer_outcomeActionClassify and record a task outcome from host-provided evidence rather than raw transcript text — for hosts whose event model doesn't produce a Claude-Code-shaped JSONL transcript (e.g. dsh/Cordis session events). Pass pre-computed friction counts and terminal state in `evidence`; this runs the same rule-floor-plus-optional-LLM-judge classification as the Claude Code Stop hook's `outcome --infer`, then records exactly like record_outcome. Returns status 'skipped' (not an error) when nothing was inferred — a clean session, below the friction threshold, or no task evidence at all. Repeated calls for the same session/evidence are deduped. Requires agent auth when the agent has a registered key.
list_inboxRead-onlyList memories pending human review, sorted by created_at ascending (oldest first). Read-only. Supports an optional namespace and limit (default 20); there is no offset/pagination, so a full page silently truncates older pending memories. Requires agent auth when the agent has a registered key.
propose_memory_editActionPropose a text edit to an existing memory, for human review. Creates a PENDING memory carrying the edit; the target is left completely untouched and keeps injecting until a human approves. Approving it (review_memory action='approve') supersedes the target with the edited version; rejecting discards the proposal. old_text must occur exactly once — an ambiguous or absent anchor is an error, never a guess. field='content' (default) edits the body, field='instruction' edits the directive that injection renders. Use this instead of delete+save when you are correcting a memory you did not author: it keeps the current truth live until a person decides, and it cannot be used to silently rewrite a binding MUST.
Show all 21 toolsShow fewer tools
record_outcomeActionRecord the outcome of a task you just executed (episodic memory). Call this after finishing a task so past successes and failures can inform future sessions. Status must be 'success', 'failure', or 'partial'. Failures with a cause are reflected into lessons that get injected into similar future tasks. Repeated calls for the same session/outcome are deduped rather than creating a second episode. Use infer_outcome instead when the host supplies structured evidence rather than a transcript; use add_evidence to attach provenance to an existing memory. Returns status (recorded | duplicate), the episode id, and any distilled lesson. Requires agent auth when the agent has a registered key.
report_complianceActionReport compliance for a previous injection session returned by session_start. Call this to mark which injected memories were followed or violated, with optional evidence. Reports are processed item by item: a bad item is logged and skipped while the call still succeeds, so the response's updated/total counts must be checked rather than assuming all reports were stored. Requires a compliance-enabled server; no agent API key is required by this tool.
review_memoryActionReview or edit a memory. action='approve' marks it human-reviewed; action='edit' updates content/instruction and re-embeds or clears the stale vector (this also works on already-approved memories); action='reject' soft-deletes a pending memory and is rejected for already-approved memories (use delete_memory instead). Approved memories rank higher in future injections. Writes immediately; requires agent auth when the agent has a registered key.
run_decayActionRun a memory decay cycle: reduces decay_score for old memories and archives memories that fall below the threshold or whose `expires_at` valid-time bound has passed. MUST memories are exempt from score-based decay, but NOT from expiry — a MUST whose window has closed is a binding instruction that is no longer true. This is not purely reversible: if MEMVAULT_FORGET_AUTO_ENABLED=1, the same run also permanently forgets archived memories older than MEMVAULT_FORGET_RETENTION_DAYS (default 90); otherwise auto-forget is off. Requires agent auth when the agent has a registered key. Returns updated/archived/expired_archived/contradicted/harmful_flagged/auto_forgotten counts.
run_dedupRead-onlyScan for duplicate memories and report findings. Uses lexical text similarity (Jaccard) to detect near-duplicates in one namespace or all namespaces. Read-only: reports existing_id/new_content/similarity/action but does not merge or delete anything. Returns at most 20 duplicate findings.
run_promoteActionRun the promote pipeline: consolidates atomic L1 memories into L2 scenario summaries, and promotes stable L2 memories into L3 core persona rules. Requires L1 memories to exist; run run_dedup first so near-duplicates don't become separate scenarios. Source memories are archived to L0 after promotion (not deleted). A maintenance step, not a substitute for run_decay. Mutates the store, is not idempotent, and requires agent auth when the agent has a registered key. Returns promoted/consolidated/merged/source counts.
save_memoryActionSave a new memory. Memories are persistent user preferences, facts, episodes, or skills that should be recalled in future conversations. Embeddings are generated automatically for semantic search. Delta-write is on by default: near-duplicate saves are skipped and similar existing memories absorb the new content instead of a new row being created (status in the response: saved | merged | skipped). Pass force_insert=true to bypass. Writes persist immediately; requires agent auth when the agent has a registered key.
search_memoryRead-onlySearch stored memories. mode defaults to 'hybrid' (keyword + vector via RRF); 'keyword' is text-only and 'semantic' is vector-only. Semantic/hybrid need an embedding provider — when embeddings are unavailable the query falls back to keyword and each result reports search_mode='keyword'. Supports namespace, type_filter, priority_filter, top_k (default 10), min_score, and optional expand_relations for one-hop relation context. TWO INDEPENDENT TIME AXES: as_of is valid-time — 'what did MemVault believe at T' — and returns each hit reconstructed to the state it held then, recalling from the historical index too so a memory reworded since T is still found by the words it had (keyword path only; such hits are tagged hist-kw#N); occurred_from/occurred_to filter event-time — 'what happened in March' — and never match memories saved without a date. They answer different questions and are not interchangeable. Read-only; does not mutate memories.
session_startActionStart an agent session. Returns relevant memories filtered by agent identity, formatted as MUST/REF instructions ready for injection into the conversation context; overflow memories are summarized with a hint to use search_memory for details. If this agent's canonical inject channel is not MCP, returns a skip explanation instead of injecting. When compliance tracking is enabled, records the injected memories and returns inject_session_id in structured_content for a later report_compliance call. Not read-only; requires agent auth when the agent has a registered key.
Configuration
MEMVAULT_EMBEDDING_PROVIDERMEMVAULT_LLM_EXTRACTION_MODELMEMVAULT_LLM_EXTRACTION_PROVIDEROPENAI_API_KEY
Automated checks
Ran Nov 17, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachabledreamor/memvault is public and reachablegithub.com/dreamor/memvault ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-16github.com/dreamor/memvault ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model21 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledDestructive tools carry destructiveHintPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubMemVault
The Shared Memory Layer for Every AI Agent You Run
Not "agent learns to search memory" — memory finds the agent.
MCP Native · Hybrid Retrieval · Auto-Injection · Zero-Config Sync
Open Source · Self-Hosted · Private · MIT Licensed
English · 简体中文
If MemVault solves a real problem for you, a star helps others find it.
curl -fsSL https://raw.githubusercontent.com/dreamor/memvault/master/scripts/install.sh | bash
Every AI agent session starts from scratch. Claude Desktop doesn't know what Cursor just learned. DeepSeek Harness (dsh) doesn't know what you told Claude Code yesterday. Whatever agent you're running — international or domestic, IDE plugin or CLI harness — it forgets your preferences every time you start a new conversation.
You've been manually repeating context — project conventions, personal preferences, past decisions — across agents that should already know. This isn't a limitation of the models. It's a missing infrastructure layer.
MemVault is that layer. A lightweight, self-hosted memory router that sits between your agents and their context. It speaks plain MCP — no MemVault-specific SDK, no per-agent API integration. Any MCP-compatible agent, from any vendor, automatically shares the same persistent memory the moment it connects.
Who it's for:
- Anyone running an MCP-capable agent — Claude Code, Claude Desktop, Cursor, Cline, Continue, DeepSeek Harness (dsh), or any other MCP client, domestic or international — who wants preferences, project context, and past decisions to persist across sessions without repeating yourself
- Multi-agent power users running several of the above side by side, on different models, from different vendors — all sharing the same memory without configuration
- Platform teams deploying AI-assisted workflows where consistency matters across a mixed agent fleet: code review conventions, architecture decisions, project-specific preferences
- Anyone tired of telling their AI the same thing twice — MemVault works the way your brain should: you say it once, it's there when you need it, no matter which agent is asking
Quick Start · How It Works · What MemVault Gives You · Why MemVault · MCP Server · CLI Reference · Integrations · Architecture · Project Status · Testing · Documentation · Contributing · License
Quick Start
Don't install MemVault by hand — paste this one prompt into Claude Code, Codex, Cursor, dsh, or any other MCP-capable agent. It points the agent at a machine-readable install guide, so the agent does the whole setup itself:
Install MemVault as your long-term memory and wire it into this agent. Fetch and follow https://raw.githubusercontent.com/dreamor/memvault/master/docs/AGENT-INSTALL.md — install the binaries, register MemVault as an MCP server for this host, and verify recall works. Then keep saving my preferences, project decisions, and lessons from each session so my next agent starts with them instead of from scratch.
Or install manually:
# Install (Linux / macOS): official script, auto-verifies SHA-256
curl -fsSL https://raw.githubusercontent.com/dreamor/memvault/master/scripts/install.sh | bash
export PATH="$HOME/.memvault/bin:$PATH"
# Windows (PowerShell):
# powershell -ExecutionPolicy Bypass -File scripts\install.ps1
# Homebrew (Apple Silicon):
# brew install dreamor/tap/memvault
# Or from crates.io:
# cargo install memvault-cli memvault-mcp
# The installers auto-start the local REST backend (host of the Web
# Dashboard). Open it, or start it on demand:
memvault-cli dashboard
# Save a MUST-level preference (injected as instruction, agent must follow)
memvault-cli save --content "User prefers Python" --priority MUST --type preference \
--instruction "Use Python for code, not Java" --tags "coding,python"
# Search across all memory (hybrid: keyword + semantic when embedding is enabled)
memvault-cli search --query "Python"
# See what context gets injected when a specific agent connects
memvault-cli session-start --agent-id claude-desktop --context "Help me write code"
# Extract structured memories from free text
memvault-cli extract --text "I prefer dark mode. Our project uses Rust." --save
# Auto-generate agent instruction files from memory
memvault-cli sync
# All in one: dedup, decay, archive stale memories
memvault-cli dedup && memvault-cli decay
System requirements:
- Prebuilt Linux binaries (install script / GitHub release): glibc ≥ 2.39 + GLIBCXX_3.4.31 (GCC 13-era runtime — Ubuntu 24.04+ / Fedora 40+ / Arch). Release builds are pinned to Ubuntu 24.04 runners, and the release workflow gates the highest glibc/GLIBCXX symbol version every binary may require plus a startup smoke test, so this floor cannot silently drift upward (0.6.9 shipped x86_64 binaries requiring glibc 2.43 that way). TLS is rustls, so no OpenSSL dependency. Ubuntu 22.04 / RHEL or EL8/EL9 users: use the Docker image (
dreamor/memvault) or build from source.- Building from source (
cargo install/cargo build): links fastembed's prebuilt ONNX Runtime static library and needs a GCC 13-class toolchain. Older toolchains (e.g. GCC 8, CentOS 7/8-era libstdc++) fail at link time with missing C++20/23 stdlib symbols (std::format,std::to_chars). macOS / Windows (MSVC) / Homebrew / Docker are unaffected.
Verify your install in 5 seconds:
memvault-cli --version
# memvault 0.7.0
# sanity check: list saved memories (verifies DB is healthy)
memvault-cli list
Local Ollama Demo (Zero Cost, Stays on Your Machine)
MemVault is plug-and-play with a local Ollama: unconfigured LLM extraction (full-text understanding / failure reflection / relation extraction) auto-detects a local Ollama; embeddings use the local model with the ollama or auto provider.
# 1. Install and start Ollama
brew install ollama && brew services start ollama # or the official installer
# 2. Pull models
ollama pull nomic-embed-text # embeddings, 768-dim (default for ollama/auto)
ollama pull qwen2.5:3b-instruct # chat: LLM extraction/reflection (default qwen2.5:7b, use 3b on small machines)
# 3. (Optional) Pin the providers explicitly — persist them in ~/.memvault/.env
# (shell exports also work — env vars take precedence over the file — but the file survives reboots)
mkdir -p ~/.memvault
cat >> ~/.memvault/.env <<'EOF'
MEMVAULT_EMBEDDING_PROVIDER=ollama
MEMVAULT_LLM_EXTRACTION_PROVIDER=ollama
MEMVAULT_LLM_EXTRACTION_MODEL=qwen2.5:3b-instruct
EOF
# 4. Verify
memvault-cli status # Embedding provider: configured and reachable
memvault-cli save --content "Build server IP is 10.20.30.40" # output (embedded int8)
memvault-cli outcome --task "Deploy trading service" --status failure --cause "Disk space insufficient" --task-type deploy
# → Lesson (Llm): ... means failure reflection ran through the local LLM (not the rule-based fallback)
With no configuration at all (neither env vars nor ~/.memvault/.env), LLM extraction auto-detects a local Ollama and enables itself (default model qwen2.5:7b; pull it in advance with ollama pull qwen2.5:7b, or point MEMVAULT_LLM_EXTRACTION_MODEL at an installed model). Embeddings still default to the in-process native embedder; set MEMVAULT_EMBEDDING_PROVIDER=auto in ~/.memvault/.env to prefer Ollama and fall back to native when it isn't running. The native model's first launch downloads the weights from HuggingFace silently in the background — the server/dashboard come up immediately and hot-swap to semantic search once the download finishes, so a fresh install never blocks on it (set MEMVAULT_EMBEDDING_PROVIDER=none to run pure keyword and skip the download).
How It Works
MemVault is a pipeline, not a single script. Every stage below is a shipping module:
Agent connects (MCP stdio/SSE)
│
▼
┌───────────────────┐
│ Agent Router │ ← match agent type/tag → filter relevant memory
│ (Agent Registry) │
└────────┬──────────┘
│
▼
┌───────────────────┐
│ Memory Retrieval │ ← keyword (BM25) + vector (embedding) + RRF fusion
│ (3 search modes) │ synonym expansion · scoring · soft filtering
└────────┬──────────┘
│
▼
┌───────────────────┐
│ Auto-Injection │ ← MUST-level → instruction prompt
│ │ REFERENCE → context resource
│ │ NORMAL → search result
└────────┬──────────┘
│
▼
Agent receives context ──→ makes better decisions
- Storage: SQLite with bundled FTS5 (full-text search); embeddings stored int8-quantized (~1/4 the size of f32 at near-identical ranking quality, legacy f32 rows still readable)
- Retrieval: BM25 keyword search over FTS5 with CJK bigram tokenization (Chinese two-character words match correctly) and tiered match fallback (strict → relaxed unigram → synonym OR; relaxations are reported, never silent), local-first embedding (in-process native by default — switch to local Ollama or any OpenAI-compatible model), RRF fusion with per-result recall provenance (
kw#2/vec#5), synonym expansion, relevance scoring, soft intent filtering - Pipeline: Automatic entity extraction, delta-write on save (near-duplicates skipped, similar memories absorb only the residual), semantic deduplication, time-based decay, archive of stale memories
- Sync: Zero-invasion file generation —
memvault-cli syncproduces CLAUDE.md, AGENTS.md, etc. directly from database contents
What MemVault Gives You
- Auto-Injected Context: Session start automatically pulls relevant memory by agent identity — MUST-level rules land as instructions, not just chat history
- Hybrid Retrieval: BM25 + vector + RRF fusion with synonym expansion, relevance scoring, and per-result provenance (which path recalled each memory, at what rank) — available via CLI, MCP tool, and REST API
- Explainable Injection: every candidate dropped on the way into an agent's context is recorded with a reason (budget, caps, intent/type penalties) — "why didn't the agent get this memory?" always has an answer
- Degrade Before Dropping: when the token budget runs out, a memory is shortened — excerpt, then summary — rather than cut, so more of the ranked list stays reachable at a lower per-memory cost. Shortened text always carries a
[…]marker and the level is reported separately from the dropped list, because an abbreviation that looks complete is worse than a drop. MUST is never shortened: a binding rule with its qualifying clause summarised away is worse than one that overflowed - MUST Enforcement: MUST-priority memories are never filtered or truncated. Always in context, always obeyed — trust comes from provenance (human-authored/reviewed), with an opt-in fallback for memories independently corroborated by multiple identity-verified agents (
MEMVAULT_CORROBORATION_GATE), so a single spoofed/compromised agent can't unilaterally inject a binding MUST - Multi-Agent Awareness: Agent Registry with type/tag-based soft filtering (score demotion, not hard exclusion)
agent_idIs Provenance, Not a Filter: retrieval never filters byagent_id— the field only records which agent wrote a memory (source_agent). Every agent searches the same shared corpus; per-agent differences apply only at injection time (type/tag soft scoring viaagents.yamlinject_rules)- MCP Proxy: Transparent proxy that injects memory into ANY upstream MCP server's responses — zero client changes
- Compliance Tracking:
inject_session_idtraces what was injected and measures follow-through rate - Cross-Platform: CLI + MCP Server (stdio & SSE) + Web Dashboard (browser) + Obsidian Plugin
- Zero-Invasion Sync: Generate AGENTS.md / CLAUDE.md from memory — no per-agent config files to edit. Applies the same exclusions as session injection (unreviewed drafts behind the review gate, superseded facts, pending edit proposals, expired memories) and reports how many it held back and why, so "why isn't this rule in my AGENTS.md" has an answer
- Contextual Extraction, Local-First: Rule-based keyword extraction by default; optionally understands a full user+assistant exchange via an LLM, auto-detecting a local Ollama for free before ever touching a remote API
- History & Rollback: Every update/delete is snapshotted into
memory_history—memvault-cli checkpoints+memvault-cli restoreroll one memory back without touching the rest - Time Travel (
as_of): ask what MemVault believed at any past instant —memvault-cli as-of <id> --at 2026-08-01T00:00:00Z,list --as-of,search --as-of,search_memory,POST /api/search. Reconstructed from the same snapshot chain that powers rollback, so it needed no new version schema. Memories deleted or superseded after that instant still come back, because they were the current truth then. Search also recalls from a historical full-text index, so a memory reworded sinceas_ofis still found by the words it had — those hits are taggedhist-kw#Nto keep "matched today" distinct from "matched then". Each answer says where it came from (live row vs. a named history snapshot), so a far-back result is never mistaken for a current one - Two Time Axes, Never Folded:
as_ofasks what did MemVault believe in March;--occurred-from/--occurred-toask what happened in March. A memory can be true for both answers at once, so they are separate parameters rather than onesince/untilrange — folding them is what makes one of the two questions permanently unanswerable. Undated memories never match an event-time window, and the CLI says so whenever the flag is used rather than only when the result comes back empty - Self-Expiring Facts (
expires_at): a temporary fact ("the deploy freeze runs until Friday") retires itself instead of decaying slowly and being re-injected as stale truth.save --expires-at <RFC3339>or--ttl 7d. Past the bound it leaves retrieval and injection but stays inspectable and restorable — expiry retires a fact, onlyforgeterases one. Honored even for MUST: an explicit bound is not the inferred disuse signal thatmust_exemptprotects against - Self-Diagnostics:
memvault-cli statusreports exactly which features are degraded when no embedding provider is configured, plus a schema fingerprint (migration version + checksum) for cross-database comparison - Episodic Memory:
record_outcomerecords task results; failures are distilled into lessons and auto-injected next time (REFERENCE → MUST only with human approval), so the same trap isn't hit twice - Procedural Skill Activation: skills whose
triggermatches intent are injected as structured[SKILL]blocks with success-rate stats (shown after ≥3 runs); failures flag the skill for revision (version++on human edit), repeated successes auto-draft new skills into the review inbox - Semantic Knowledge Links: lightweight relation triples, repeated facts consolidated into a linked semantic fact with provenance, and superseded facts archived (never re-injected, still listable & restorable)
- Team Shared Pool & SOP Import: memories marked
sharedare injected into every session (capped at 20); Markdown SOPs can be batch-imported as verifiable skills - Delta-Write on Save: every save is checked against its namespace first — near-duplicates are skipped, similar memories absorb only the residual (what's genuinely new) and get their strength refreshed, so the library converges instead of accumulating near-copies;
--force/force_insertbypasses - Task-Level Evaluation:
memvault-cli benchsamples your own failure history (episodes that distilled a lesson) and measures lesson retrieval/injection rates — and with--judge, an LLM scores "plan without vs. with memory" against the known failure cause, so you see task-success lift, not just retrieval recall - Two-Phase Injection (never blocks): MUST rules resolve deterministically with zero embedding calls and are served immediately; the semantic pipeline prefetches in the background and lands within a short window (250ms) — if it doesn't, the deterministic baseline is served and the request moves on (two-phase design)
- Conversation-N-Gram Retrieval: retrieval keys are conditioned on the recent turn window, weighted by recency so the current focus dominates — not a single flat query
- Single Canonical Injection Channel: per-agent
inject_channel(mcp/proxy/syncinagents.yaml) restricts automatic injection to one delivery path, so the same memory is never sent to the same agent twice - Data You Own: Single SQLite file. Full export/import. No cloud dependency. Your data, your machine.
- The Index Is Disposable, the Memory Is Not: every derived structure in MemVault can be thrown away and rebuilt, so a corrupt or stale index is never a data-loss event.
- markdown backend — the
.mdfiles are the memory;.memvault-cache.dbis a shadow index derived from them. Delete the cache and the next open rebuilds it from the vault. Edit a file by hand in Obsidian, in an editor, or viagit checkout, andmemvault-cli reindex(or--watch) reconciles it — content is diffed against the cached row and resynced on any mismatch. Your memories are plain text you cangrep,git blame, and take to any other tool. - sqlite backend —
data.dbis the source of truth, and the derived parts inside it still self-heal: the FTS index is rebuilt automatically on open whenever its row count disagrees withmemories, and the embedding column can be dropped and backfilled (switch embedding models, or run with no provider configured and add vectors later). - What is never derived: your content, your review state, your provenance, and the
memory_historysnapshot chain that powers rollback andas_oftime travel. Note the one asymmetry — history snapshots live in the cache, so on the markdown backend a rebuilt cache loses the version chain and point-in-time reads fall back to the live row (docs/DESIGN.md§9.6). Expiry and everything else survive a rebuild intact.
- markdown backend — the
Why MemVault
Storing and retrieving memories is solved — a dozen products do it well, and since 2025 the Code Agents do it natively. What is not solved is the part after retrieval: getting one shared corpus into every agent you run, deciding what entitles a memory to bind that agent, and knowing whether it obeyed.
The claims below come from a 15-product survey refreshed 2026-11
(docs/DESIGN.md §2). They
are falsifiable — the table there names every product and every source.
What only MemVault does
| Capability | What it actually means | Who else has it |
|---|---|---|
| Follow-through tracking | inject_session_id traces what was injected into which session and measures whether the agent obeyed. Not "was it retrieved" — was it followed |
Nobody. The closest is agent-memory's audit, which records who changed a memory, not whether an agent listened to one |
| Instruction-layer enforcement | MUST memories are never filtered, never truncated, and are rendered as directives rather than context. A memory becomes a constraint, not a suggestion | Nobody. MemoryTier.CORE in agent-memory and core blocks in Letta mean "resident in context", which is not the same claim |
| Trust-gated binding | What entitles a memory to bind an agent: provenance, identity verification, and an opt-in corroboration gate so one spoofed or compromised agent cannot unilaterally inject a MUST everyone obeys | Nobody. Multi-tenant ACLs answer who may access; this answers what may be believed. Different axis, and the survey has no column for it |
| Injection explainability | Every candidate dropped on the way into an agent's context is recorded with a reason — budget, cap, intent penalty, review gate. "Why didn't the agent get this memory?" always has an answer | agent-memory has retrieval trajectory (what was recalled). Nobody reports what was dropped and why |
| Review-gated agent edits | An agent can propose a correction to any memory, including a MUST — as a pending proposal that leaves the target live until a human decides | Nobody. Letta's agent self-edits memory directly, which is its own listed weakness |
| Task-level evaluation | bench --judge samples your own failure history and scores "plan without memory vs. plan with memory" against the known failure cause — task success, not retrieval recall |
Nobody. Every published number in this space is a recall metric |
MemVault MCP questions
How do I add MemVault MCP to Claude Code?
Run claude mcp add memvault -- docker run -i --rm ghcr.io/dreamor/memvault:v0.7.2 in your terminal. Add --scope user to make it available in every project.
How do I add MemVault MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does MemVault MCP provide?
It exposes 21 tools, including add_evidence, confirm_read, delete_memory, extract_memories, forget_memory.
How do I install MemVault?
You can install it using a curl script, Homebrew on Apple Silicon, or via cargo install memvault-cli memvault-mcp.
Does MemVault work with local LLMs?
Yes, it features plug-and-play support for local Ollama, using it for both LLM extraction and embeddings.
What happens if I run out of token budget for memories?
Instead of being cut entirely, memories are shortened into excerpts or summaries to ensure more ranked information stays within the budget.
Can I use MemVault with different AI agents?
Yes, any MCP-compatible agent like Claude Desktop, Cursor, or Cline can automatically share the same persistent memory.