How do I install Mind Mem?

Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.

Does Mind Mem need an API key?

No required environment variable is listed on this record.

What transport does Mind Mem use?

Mind Mem runs locally over stdio.

When was Mind Mem last checked?

Last checked 2026-11-13. Persistent AI memory for Claude Code, OpenClaw, and any MCP-compatible agent. BM25F + vector hybrid, governance-aware, local-first, zero-infrastructure.

Mind Mem MCP 服务器

MIND-Mem is a deterministic AI memory system: recall is defined by the query, admitted corpus, configuration, scoring instant, and execution providers. With those inputs held constant, its canonical audit/evidence encoding is byte-identical across replay; ranking scores themselves remain standard floating-point. The Q16.16 fixed-point audit chain is embedded in every applied decision.

scoring_instant is a UTC date and is the honest part of that claim: recency ranking is load-bearing for a coding agent, so it is not deleted, it is named. Omit it and it resolves to today in UTC — the one clock read on the whole path, taken once at the boundary, never inside the scoring loop. Its resolved value is bound into the recall attestation, so any attested run replays exactly by passing that date back.

Built on the MIND substrate. Governed-write (propose → review → approve_apply). 107 MCP tools as the surface — but the differentiator is the substrate underneath. On the same workspace, recall uses the query, admitted corpus, configuration, scoring_instant, and execution providers. With those inputs held constant, the canonical audit/evidence encoding is byte-identical across replay; ranking scores remain standard floating-point, so this does not promise universal cross-provider result identity.

Most memory layers ship tools. That is table-stakes. MIND-Mem ships a substrate: Q16.16 fixed-point encoding in the audit-hash preimage, a governance pipeline that rejects every unreviewed write, and an audit chain where every applied proposal is hash-anchored. The scoring path itself is pure Python (mind_kernels.py): the wheel ships MIND-language kernel sources under mind/ and no compiled kernel, and the optional native libmindmem.so is built from lib/kernels.c (C99). The substrate claim is the encoding, the gate and the chain — not the kernels, which are not compiled yet. The same query on the same workspace with the same admitted corpus, configuration, scoring instant and execution providers produces repeatable ranked recall; that recall's canonical audit/replay encoding is byte-identical under those held-constant conditions. That property is what makes MIND-Mem suitable as a canonical memory layer across heterogeneous agent stacks.

If your agent runs for weeks, it will drift. MIND-Mem prevents silent drift.

MIND-Mem powers the Memory Plane of the MIND Cognitive Kernel — the deterministic AI runtime architecture.

30-Second Demo

pip install mind-mem
mind-mem-init ~/my-workspace        # Create workspace
mind-mem-recall -q "API decisions" --workspace ~/my-workspace  # Hybrid BM25F search
mind-mem-scan ~/my-workspace        # Detect drift & contradictions

Output:

[1.204] D-20260215-001 (decision) — Use async/await for all API endpoints
        decisions/DECISIONS.md:11
[1.094] D-20260210-003 (decision) — REST over GraphQL for public API
        decisions/DECISIONS.md:20

Current release: v5.0.4 (candidate; publication pending) — corrects lifecycle ranking and graph admission, strengthens release validation, and adds source-only training preparation. See CHANGELOG.md for candidate changes and published release history.

Substrate Properties

Property	What it means
Byte-identical replay	Replay fixes the query, admitted corpus, configuration, `scoring_instant`, execution providers and dependencies. Canonical Q16.16 audit encoding produces identical bytes and hashes for identical preimages. Ranking uses floating-point scores; provider behavior, access-state updates and receipt metadata can change the inputs and results.
Governed-write	Nothing reaches the source of truth without `propose → review → approve_apply`. No silent mutations. Ever.
Auditable	Every apply logged with timestamp, receipt, and DIFF. Full traceability from signal to decision.
Deterministic	No ML in the retrieval core. Q16.16 fixed-point encoding in the audit-hash preimage. The same preimage produces the same hash.
Local-first	The default retrieval path stores data locally. External storage and model providers are optional and must be configured.
No vendor lock-in	Plain Markdown files. Move to any system, any time.
Zero infrastructure	Core requires only Python 3.10+ stdlib. Postgres, Redis, Docker, and GPU are opt-in extras.
100% NIAH	250/250 Needle In A Haystack retrieval, every needle/depth/size — full-matrix repro package committed, first-party verified; no independent reproduction yet (EVIDENCE.md row 1).

Why MIND-Mem
Features
Integrations are the substrate working
Benchmark Results
Quick Start
Health Summary
Commands
Architecture
How It Compares
Companion Tools
Recall
MIND Kernels
Auto-Capture
Multi-Agent Memory
Governance Modes
Block Format
Configuration
MCP Server
Security
Troubleshooting
MIND language sources
Contributing
License

Deep-dive docs

docs/setup.md — install, configure, wire MCP, opt in to MIND native kernels
docs/usage.md — every surface (MCP tools by category, mm CLI, mind-mem-verify, Python library) with worked examples
docs/client-integrations.md — 69 AI client integrations (Claude Code, Claude Desktop, Codex, Grok Build, Vibe, OpenCode, Gemini, Cursor, Windsurf, VS Code, Zed, Copilot CLI, Qwen Code, Kimi Code, Amp, goose, Kiro, Junie, Cline, Roo, Continue, Antigravity and more; manual steps for UI-only apps) with mm install-all auto-detection and a per-client source table
docs/task-frames.md — task frames + the dead-end registry: [TF-...] multi-session continuity (resume_brief, mm resume) and [DE-...] negative action-space memory, matched by a deterministic declarative overlap that warns and never blocks
docs/review.md — mm review: batch approval for the HITL queue — pending proposals with their pre-apply diff, provenance, chain status and staleness inline, approved or rejected many at once through the governed approve_apply path, with no auto-approve at any risk level
docs/mind-mem-4b-setup.md — download + run the star-ga/mind-mem-4b full-FT model locally (transformers, exllamav2, vLLM, llama.cpp, Ollama, MindLLM)
docs/companion-tools.md — companion tools that complement (not compete with) mind-mem: MindLLM (STARGA, commercial) for deterministic + evidence-chained inference, GitNexus for code knowledge-graph
ROADMAP.md — feature roadmap (genuinely-open items at the top; bulk of v3.2.0→v4.0.0 shipped)

Why MIND-Mem

Most memory plugins store and retrieve. That's table stakes.

MIND-Mem also detects when your memory is wrong — contradictions between decisions, drift from informal choices never formalized, dead decisions nobody references, orphan tasks pointing at nothing — and offers a safe path to fix it.

Problem	Without MIND-Mem	With MIND-Mem
Contradicting decisions	Follows whichever seen last	Flags, links both, proposes fix
Informal chat decision	Lost after session ends	Auto-captured, proposed to formalize
Stale decision	Zombie confuses future sessions	Detected as dead, flagged
Orphan task reference	Silent breakage	Caught in integrity scan
Scattered recall quality	Single-mode search misses context	Hybrid BM25+Vector+RRF fusion finds it
Ambiguous query intent	One-size-fits-all retrieval	9-type intent router optimizes parameters

Novel Contributions

MIND-Mem introduces several techniques not found in existing memory systems:

Technique	What's new	Why it matters
Co-retrieval graph	PageRank-like score propagation across blocks frequently retrieved together	Surfaces structurally relevant blocks with zero lexical overlap (+2.0pp accuracy)
Fact card sub-block indexing	Atomic fact extraction → small-to-big retrieval with parent score blending	Catches fine-grained facts that full-block BM25 misses (+2.6pp accuracy)
Adaptive knee cutoff	Score-drop-based truncation instead of fixed top-K	Eliminates noise that hurts LLM judges — returns 3-15 results adaptively
Hard negative mining	Logs BM25-high / cross-encoder-low blocks as misleading, penalizes in future queries	Self-improving retrieval: precision increases over time without retraining
Deterministic abstention	Pre-LLM confidence gate using 5-signal scoring (entity, BM25, speaker, evidence, negation)	Prevents hallucinated answers to unanswerable questions — no ML required
Governance pipeline	Contradiction detection + drift analysis + safe apply with audit trail	Detects contradictions and drift before a change is applied, and keeps the audit trail
Agent-agnostic shared memory	Single MCP workspace shared across Claude Code, Codex, Gemini, Cursor, Windsurf, Zed	Memory compounds across tools instead of fragmenting

Features

Hybrid BM25+Vector Search with RRF Fusion

Thread-parallel BM25 and vector search with Reciprocal Rank Fusion (k=60). Configurable weights per signal. Vector is optional — works with just BM25 out of the box.

RM3 Dynamic Query Expansion

Pseudo-relevance feedback using JM-smoothed language models. Expands queries with top terms from initial result set. Falls back to static synonyms for adversarial queries. Zero dependencies.

9-Type Intent Router

Classifies queries into WHY, WHEN, ENTITY, WHAT, HOW, LIST, VERIFY, COMPARE, or TRACE. Each intent type maps to optimized retrieval parameters (limits, expansion settings, graph traversal depth).

A-MEM Metadata Evolution

Auto-maintained per-block metadata: access counts, importance scores (clamped to [0.8, 1.5] reranking boost), keyword evolution, and co-occurrence tracking. Importance decays with exponential recency.

Deterministic Reranking

Four-signal reranking pipeline: negation awareness (penalizes contradicting results), date proximity (Gaussian decay), 20-category taxonomy matching, and recency boosting. No ML required.

Optional Cross-Encoder

Drop-in ms-marco-MiniLM-L-6-v2 cross-encoder (80MB). Blends 0.6 * CE + 0.4 * original score. Falls back gracefully when unavailable. Enabled via config.

MIND Kernel Sources and Configuration

The mind/ directory contains 26 .mind files: 18 INI-style pipeline configurations and eight MIND-language tensor-source prototypes. The configuration files are parsed by mind_ffi.py; the source prototypes are migration work and are not a native serving backend. See docs/MIND_CONFIG_VS_MIND_LANG.md for the verified split. The pure-Python scoring logic in src/mind_mem/mind_kernels.py remains authoritative. An optional C library implements the existing native scoring ABI when a compatible library is provided.

MIC/MAP — MIND IR graph serialization

Pure-Python codec for the STARGA wire formats: mic@2 (line-oriented text, LLM-readable, git-friendly) and MIC-B (varint binary, ~4× smaller). Both encode typed dataflow graphs (symbols + types + values + output) with byte-identical round-trip. Streaming parser for bounded peak memory; optional Cython accelerator via mind-mem[accelerated] (+16/+20/+36 % on parse). Two MCP tools (mic_convert, mic_inspect) and a mm mic CLI surface it for agents and operators. See docs/mic-map.md. Note that the canonical IR per RFC 0021 is mic@1 text + mic@3 binary (see mindlang.dev/docs/mic); the mic@2/MIC-B codec mind-mem ships is the back-compat lineage.

BM25F Hybrid Recall

BM25F field-weighted scoring (k1=1.2, b=0.75) with per-field weighting (Statement: 3x, Title: 2.5x, Name: 2x, Summary: 1.5x), Porter stemming, bigram phrase matching (25% boost per hit), overlapping sentence chunking (3-sentence windows with 1-sentence overlap), domain-aware query expansion, and optional 2-hop graph-based cross-reference neighbor boosting. Zero dependencies. Fast and deterministic.

Graph-Based Recall

2-hop cross-reference neighbor boosting — when a keyword match is found, blocks that reference or are referenced by the match get boosted (1-hop: 0.3x decay, 2-hop: 0.1x decay). Surfaces related decisions, tasks, and entities that share no keywords but are structurally connected. Auto-enabled for multi-hop queries.

Vector Recall (optional)

Pluggable embedding backend — local ONNX (all-MiniLM-L6-v2, no server needed) or cloud (Pinecone). Falls back to BM25 when unavailable.

Persistent Memory

Structured, validated, append-only decisions / tasks / entities / incidents with provenance and supersede chains. Plain Markdown files — readable by humans, parseable by machines.

Immune System

Continuous integrity checking: contradictions, drift, dead decisions, orphan tasks, coverage scoring, regression detection. Structural validation via validate.sh / validate_py (17 checks on a fresh workspace; the count grows with the blocks present).

Safe Governance

All changes flow through graduated modes: detect_only → propose → enforce. Apply engine with snapshot, receipt, DIFF, and automatic rollback on validation failure.

Adversarial Abstention Classifier

Deterministic pre-LLM confidence gate for adversarial/verification queries. Computes confidence from entity overlap, BM25 score, speaker coverage, evidence density, and negation asymmetry. Below threshold → forces abstention without calling the LLM, preventing hallucinated answers to unanswerable questions.

Auto-Capture with Structured Extraction

Session-end hook detects decision/task language (27 patterns with confidence classification), extracts structured metadata (subject, object, tags), and writes to SIGNALS.md only. Never touches source of truth directly. All signals go through /apply.

Tool-Output Offload (v4.2.0)

A single cargo test / pytest / build run dumps 10k–50k lines into an agent's context — the biggest single token sink for coding agents. mm tool-run -- <cmd> stores the full output out-of-context (a tool_outputs sibling table; SQLite by default, reuses the Postgres connection with no new DB) and returns only a compact {handle, summary}; mm tool-recall <handle> returns the full text on demand. The summary is bounded regardless of input (a 10 MB line or 100k error lines can't blow it up), fail-safe (the full text is always stored and every truncation is explicit and counted — a failure line is never silently dropped), and deterministic (pure pattern extraction, no LLM; versioned config). See docs/tool-output-architecture.md.

Concurrency Safety

Cross-platform advisory file locking (fcntl/msvcrt/atomic create) protects all concurrent write paths. Stale lock detection with PID-based cleanup. Zero dependencies.

Compaction & GC

Automated workspace maintenance: archive completed blocks, clean up old snapshots, compact resolved signals, archive daily logs into yearly files. Configurable thresholds with dry-run mode.

Observability

Structured JSON logging (via stdlib), in-process metrics counters, and timing context managers. All scripts emit machine-parseable events. Controlled via MIND_MEM_LOG_LEVEL env var.

Multi-Agent Namespaces & ACL

Workspace-level + per-agent private namespaces with JSON-based ACL. fnmatch pattern matching for agent policies. Shared fact ledger for cross-agent propagation with dedup and review gate.

Automated Conflict Resolution

Graduated resolution pipeline: timestamp priority, confidence priority, scope specificity, manual fallback. Generates supersede proposals with integrity hashes. Human veto loop — never auto-applies without review.

Write-Ahead Log (WAL) + Backup/Restore

Crash-safe writes via journal-based WAL. Full workspace backup (tar.gz), git-friendly JSONL export, selective restore with conflict detection and path traversal protection.

Transcript JSONL Capture

Scans Claude Code transcript files for user corrections, convention discoveries, bug fix insights, and architectural decisions. 16 transcript-specific patterns with role filtering and confidence classification.

MCP Server (107 tools, 8 resources)

Full Model Context Protocol server with 107 distinct tools and 8 read-only resources (6 static + 2 templated). Works with Claude Code, Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. HTTP and stdio transports; HTTP requires bearer-token auth (fail-closed) — see Token Auth (HTTP). v3.8.11 added mic_convert_tool / mic_inspect_tool (MIC/MAP wire format); v3.9.0 added compile_truth_walkthrough, recall_with_persona, pipeline_status, and reindex_dirty; v3.11.0 added validate_block, block_lineage, and add_block_edge (deterministic quality gates + typed lineage edges).

Structural Validation + 13,258 Test Functions

validate.sh checks schemas, cross-references, ID formats, status values, supersede chains, ConstraintSignatures, and more. The repository contains 13,258 test functions across the core and optional surfaces; collected case counts also depend on parametrization, optional dependencies and test selectors.

Audit Trail

Every applied proposal logged with timestamp, receipt, and DIFF. Full traceability from signal → proposal → decision.

Calibration Feedback Loop

Per-block quality tracking with Bayesian weight computation. When users provide feedback (thumbs up/down) via calibration_feedback, the system maintains a rolling quality score per block over a 30-day window. Bayesian smoothing constrains calibration weights to the 0.5-1.5 range, preventing any single block from dominating or being silenced. Calibration weights integrate directly into the BM25 + FTS5 retrieval pipeline — high-quality blocks rank higher, low-quality blocks are naturally demoted. Use calibration_stats to inspect per-block quality distributions and global calibration health. With v4.llm_noise_profile enabled (default off), it also carries an llm_reliability section: a per-provider, per-domain reliability EMA fed by report_outcome and persisted to intelligence/llm_profiles.json. Reliability is evidence for an operator reading the record — nothing on the retrieval scoring path reads it.

LLM-Guided Multi-Query Expansion

Generates semantically diverse query reformulations before search — synonym expansion, specificity shifts, temporal rephrasing, and negation variants. Combines all reformulated queries with Reciprocal Rank Fusion for broader recall without sacrificing precision. Runs locally with zero API calls.

4-Layer Search Deduplication

Post-retrieval dedup pipeline: best-chunk-per-source (keeps highest-scoring chunk from each file), cosine similarity dedup (>0.85 threshold), type diversity capping (max 3 results per block type), and per-source chunk limiting. Eliminates redundant results that waste LLM context.

LLM-Guided Smart Chunking

Content-aware chunking that splits at semantic boundaries (headers, paragraph breaks, list items, code blocks) instead of fixed character counts. Produces variable-size chunks with overlap for continuity. Supports markdown, code, and prose with format-specific splitting rules.

Compiled Truth Pages

Per-entity knowledge compilation: current-best-understanding on top, timestamped evidence trail below. Contradiction detection across evidence entries with automatic flagging. Entities accumulate knowledge from all sessions — each new evidence entry is checked against existing facts.

Dream Cycle (Autonomous Memory Enrichment)

Scheduled background enrichment: scans recent memory for missing cross-references, broken citations, orphan entities, and consolidation opportunities. Generates repair proposals for stale links, detects implicit entities not yet formalized, and compacts redundant entries. Runs during idle periods with configurable depth.

Feature Completeness Matrix

Cells were checked against each project's public source or, where the engine is closed (Supermemory's engine, Graphlit), its official docs, in October 2026. Several retrieval legs exist in other projects only behind an optional backend; see the Full Feature Matrix below.

Columns: MM MIND-Mem · M0 Mem0 · SM Supermemory · CM claude-mem · Le Letta · Zep Zep · LM LangMem · Co Cognee · GL Graphlit · CW ClawMem · MU MemU · En Engram · BM Basic Memory · OV OpenViking
Cells: ✓ present · ◐ partial or a different mechanism · opt present but off by default · — looked for and not found · n/v not verified (closed engine or undocumented) · N/A not applicable · ↓n see note n under the table. Small notes under each table carry the qualifiers.

Recall

Capability	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
BM25 lexical	✓	✓	◐	✓	◐	✓	—	✓	◐	✓	—	✓	✓	opt
Vector semantic	opt	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	—	✓	✓
Hybrid fusion1	opt	◐	◐	◐	◐	✓	—	◐	◐	✓	—	—	◐	opt
Cross-encoder	opt	opt	opt	—	◐	✓	—	—	✓	✓	—

1 MIND-Mem: BM25+vector+RRF2 MIND-Mem: 9 types3 MIND-Mem: RM34 MIND-Mem: co-retrieval PageRank5 MIND-Mem: 4 layers

Persistence

Capability	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Truth pages1	✓	—	◐	◐	—	◐	◐	◐	◐	◐	◐	—	—	◐
Background enrichment2	✓	◐	✓	◐	✓	◐	◐	✓	◐	opt	✓	—	—	✓
Backup/restore3	✓	◐	—	◐	◐	—	—	—	—	—	—	◐	◐	✓

1 compiled, per entity2 MIND-Mem: dream cycle3 with zip-slip protection

Integrity

Capability	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Contradictions	✓	◐	✓	—	◐	✓	◐	◐	—	◐	—	◐	—	◐
Drift analysis	✓	—	—	—	—	—	—	—	—	—	—	◐	◐	◐

Governance

Capability	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Propose/apply1	✓	—	◐	—	—	—	—	◐	◐	—	—	—	—	—
Shared memory2	✓	◐	✓	✓	✓	✓	◐	✓	✓	✓	◐	✓	◐	✓

1 governance pipeline2 several agents can read and write one store, via MCP or API. The Full Feature Matrix row "Multi-agent" is stricter: per-agent identity and isolation (◐ = shared store without per-agent isolation)

Operations

Capability	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Zero core deps	✓	—	n/v	—	—	—	—	—	—	—	—	✓	—	—
Local-only1	✓	◐	◐	◐	◐	◐	◐	✓	—	✓	◐	✓	✓	◐
Native C scorer2	✓	—	—	—	—	—	—	—	—	◐	◐	—	◐	✓

1 no cloud required2 optional backend

Integrations are the substrate working

MIND-Mem provides integrations for 69 supported clients, including 41 MCP-aware clients (22 more get printed manual MCP steps). They can share a governed memory workspace. Reproducing a recall result requires the same request, corpus, configuration, scoring instant and execution dependencies; the client count alone does not establish cross-client output identity.

Honest positioning: the integrations below are software-level — clients use their configured MCP connection or local integration. They are not commercial-customer relationships with any vendor. Full positioning policy: docs/integrations.md.

Native integration with 69 clients (41 MCP-aware clients)

pip install mind-mem
mm install-all

mm install-all auto-detects every supported client on your machine and writes the appropriate config file for each. MIND-Mem speaks the Model Context Protocol — any MCP-compatible client connects with one command.

Client	Vendor	`mm install` id	Install mode
Claude Code	Anthropic	`claude-code`	auto MCP
Codex CLI	OpenAI	`codex`	auto MCP
Grok Build CLI	xAI	`grok-build`	auto MCP
Vibe (Mistral CLI)	Mistral AI	`vibe`	auto MCP
OpenCode (1.x / 2.x)	OpenCode (open source)	`opencode`	auto MCP
Gemini CLI	Google	`gemini`	auto MCP
Cursor	Anysphere	`cursor`	auto MCP
Windsurf	Cognition (formerly Codeium)	`windsurf`	auto MCP
aider	Aider-AI (open source)	`aider`	none
OpenClaw	OpenClaw Foundation (open source)	`openclaw`	auto MCP
NanoClaw	NanoClaw / Qwibit (open source)	`nanoclaw`	none
NemoClaw	NVIDIA	`nemoclaw`	none
Continue	Continue.dev	`continue`	auto MCP
Cline	Cline	`cline`	auto MCP
Roo Code	Roo Code	`roo`	auto MCP
Zed	Zed Industries	`zed`	auto MCP
GitHub Copilot (workspace instructions)	GitHub / Microsoft	`copilot`	none
GitHub Copilot CLI	GitHub / Microsoft	`copilot-cli`	auto MCP

auto MCP: the mind-mem server entry is merged into the client's own config file. manual MCP: the client has MCP but no per-user file to merge into (UI, per-deployment or HTTP-only); mm install-all --agent <id> prints the exact steps and snippet. none: no native MCP; an instruction or hook file routes memory access through the mm CLI. Each entry was checked against the client's current documentation; the source per client is in docs/client-integrations.md.

Compatible with major LLM providers

MIND-Mem's recall pipeline is provider-agnostic: any MCP-capable client or OpenAI-compatible endpoint can use the same server interface. The provider adapters (Anthropic; OpenAI-compatible, which Mistral and other OpenAI-style APIs route through; Ollama; vLLM; llama.cpp) are covered by mocked contract tests, which make no live call. The only model-in-the-loop benchmark run so far is LoCoMo, with mistral-large-latest as answerer and judge. We do not claim live testing against specific versions of other vendors' models. Replay also requires the same query, admitted corpus, configuration, scoring instant, execution providers and dependencies; different client models can generate different queries.

Production usage at STARGA

MIND-Mem is the daily-driver memory layer across STARGA's active projects, including mind, mindlang.dev, mind-inference, and arch-mind. First-party, verifiable in our own commit history.

What we do not claim

❌ "OpenAI / Microsoft / Anthropic / Google is a customer" — false. These are software-level MCP integrations, not commercial relationships.
❌ "Used by N production teams outside STARGA" — we have no telemetry. PyPI download counts measure installs, not active use.

If a future integration becomes a real commercial relationship (signed contract, paid pilot, named reference), it will appear in the press release first — not in the README.

Benchmark Results

MIND-Mem's recall engine evaluated on standard long-term memory benchmarks using multiple configurations — from pure BM25 to full hybrid retrieval with neural reranking.

Needle In A Haystack (NIAH)

250/250 — 100% retrieval across all haystack sizes, burial depths, and needle types.

Provenance. The full-matrix repro package is committed at benchmarks/repro/niah/ (raw per-case rows, recomputed metrics, and a manifest pinning the commit, config, seeds and hardware — produced on a clean tree, repo_tracked_files_dirty_at_run: false). make repro-verify recomputes the 250/250 headline from those raw rows rather than trusting the manifest's summary. This is first-party evidence: nobody outside STARGA has re-run it yet and reported the same metrics.determinism.decision_fingerprint — see EVIDENCE.md row 1 for exactly what "verified" does and does not mean here.

A single fact is planted at a controlled depth within a haystack of semantically diverse filler blocks. The system must retrieve the needle in its top-5 results using only a natural-language query.

Haystack Size	Depths Tested	Needles	Passed	Rate
10 blocks	0/25/50/75/100%	10	50/50	100%
50 blocks	0/25/50/75/100%	10	50/50	100%
100 blocks	0/25/50/75/100%	10	50/50	100%
200 blocks	0/25/50/75/100%	10	50/50	100%
500 blocks	0/25/50/75/100%	10	50/50	100%

Config: Hybrid BM25 + all-MiniLM-L6-v2 + RRF (k=60) + sqlite-vec. Full details: benchmarks/NIAH.md

LoCoMo LLM-as-Judge

Same pipeline as Mem0 and Letta evaluations: retrieve context, generate answer with LLM, score against gold reference with judge LLM. Directly comparable methodology.

Canonical flagship number: the full 10-conversation (1986-question) BM25 run directly below (Overall Acc>=50 73.8%, Mean 70.5) — see docs/benchmarks.md for scope, evidence, and reproduction. All other LoCoMo tables on this page are smaller historical subsamples, kept for their per-category detail — do not treat any of them as the headline number.

v1.0.7 — Hybrid + top_k=18 (external LLM answerer + judge, conv-0 subsample, 199 of 1986 questions — 10% of the full set; no raw per-question artifact is checked into this repo for this run):

Category	N	Acc (>=50)	Mean Score
Overall	199	92.5%	76.7
Adversarial	47	97.9%	89.8
Multi-hop	37	91.9%	74.3
Open-domain	70	92.9%	72.7
Temporal	13	92.3%	76.2
Single-hop	32	84.4%	68.9

Pipeline: BM25 + Qwen3-Embedding-8B (4096d) vector search → RRF fusion (k=60) → top-18 evidence blocks → observation compression → answer → judge. A/B validated: +2.8 mean vs top_k=10 baseline.

v1.1.1 — BM25 + top_k=18 (canonical — full dataset) (external LLM answerer + judge, 10 conversations, 1986 questions):

Category	N	Acc (>=50)	Mean Score
Overall	1986	73.8%	70.5
Adversarial	446	92.4%	87.2
Single-hop	282	80.9%	68.7
Open-domain	841	71.2%	70.3
Temporal	96	66.7%	65.9
Multi-hop	321	50.5%	51.1

Pipeline: BM25 + RM3 query expansion → top-18 evidence blocks → observation compression → answer → judge. Full 10-conversation benchmark with the same external LLM as both answerer and judge.

v1.0.0 — BM25-only baseline (external LLM answerer + judge, 10 conversations):

Category	N	Acc (>=50)	Mean Score
Overall	1986	67.3%	61.4
Open-domain	841	86.6%	78.3
Temporal	96	78.1%	65.7
Single-hop	282	68.8%	59.1
Multi-hop	321	55.5%	48.4
Adversarial	446	36.3%	39.5

Key improvements since v1.0.0: Adversarial accuracy tripled from 36.3% to 92.4% via abstention classifier + hybrid retrieval. Overall Acc≥50 improved from 67.3% to 73.8% (+6.5pp).

Competitive Landscape (LoCoMo)

Full 10-conversation (1986-question) LoCoMo, Acc>=50 — apples-to-apples scope and metric. Canonical MIND-Mem table + evidence: docs/benchmarks.md. On this metric MIND-Mem is not the top score — Memobase and Letta report slightly higher, both on cloud infrastructure with embedding + vector-DB dependencies. MIND-Mem's differentiator is not "wins every cell"; it's being the only local-only, zero-core-dependency, governed system in the table — governance (contradiction detection, drift analysis, proposal/review/apply audit trail, byte-identical replay) is a property no other row has, and it is not measured by this benchmark at all.

System	LoCoMo Acc>=50 (full 10-conv, 1986Q)	Infrastructure	Dependencies
Memobase¹	75.8%	Cloud + GPU	embeddings + vector DB
Letta¹	74.0%	Cloud	embeddings + vector DB
MIND-Mem (BM25)	73.8%	Local-only	Zero core
Full-context¹	72.9%	N/A	LLM context window
Mem0 (own LoCoMo paper)²	66.9%	Cloud (managed)	graph DB + embeddings

¹ Third-party self-reported numbers (Letta's August 2025 analysis — see "Why Plain Files Outperform Fancy Retrieval" below). Not re-run by MIND-Mem, and not measured under a shared contract: different hardware, different judge configuration, and each system's own harness. Rows in this table are therefore indicative of scope, not a head-to-head result, and none of them — including ours — has been reproduced by the others. A genuine comparison requires every system run under one adapter contract on one box with a pinned judge and >=2 reps; that run does not exist yet, and until it does no ordering in this table should be read as a ranking.

² 66.88 is Mem0's own published LoCoMo-paper number. Mem0's separate 2026 managed platform self-reports 91.6 on LoCoMo — a different setup/judge (hosted product, not the open-paper config), not apples-to-apples with this table. Surfaced rather than omitted, per policy: never publish a comparison a skeptic could catch as cherry-picked.

³ OpenViking (0.3.22) self-reports 80.3–82.9% LoCoMo accuracy for three agent integrations. It is not a row here because the scope and metric differ: its scripts drop the 446 adversarial (category 5) questions and score the other 1,540, use a binary LLM judge told to accept any answer that "touches on the same topic" as the gold answer, and measure the whole agent (harness, memory and hosted Doubao models), not the memory layer alone. Not re-run by MIND-Mem.

LongMemEval-S

The previous headline (R@5 = 85.3) is retracted, not held — it had no committed artifact, was not reproducible after two attempts, and its own per-category rows summed to 376 under a stated N=470. It is replaced by the measurement below, which ships with per-question NDJSON so anyone can recompute it. See benchmarks/STATUS.md and benchmarks/REPORT.md.

Full eligible set (470 of 500; 30 abstention questions excluded), two reps identical per question, artifacts under docs/benchmarks/2026-09-03-longmemeval-s-full-*. Configuration: BM25F/SQLite with the vector leg OFF — one leg of the product, not the shipped hybrid. The hybrid number does not exist yet and nothing here may be read as one.

adapter	recall_any@5	recall_all@5 (official)	MRR
`mind_mem` (BM25F/SQLite, vector off)	0.9404	0.8170	0.8776
`bm25_baseline` (zero-dependency, in-memory)	0.9702	0.8298	0.9081

Paired over the same 470 question ids: on the official strict protocol (recall_all@5) the two are statistically indistinguishable (McNemar exact, p=0.4799); the zero-dependency baseline is better on the lenient protocol (recall_any@5, p=0.0043) and on MRR (p=0.0013). An independent audit refuted every artefact explanation — the recall caps are genuinely off in the pinned config, there is no ingest truncation, and index fragment ids never reach recall — so the deficit is ordering quality, not candidate recall. That is the work in flight; we publish the number that exists rather than the one we want.

Performance (Latency & Throughput)

Measured on a single developer workstation (commodity x86-64, warm cache, single process) against a 65-block workspace (typical personal workspace) with the SQLite FTS5 backend. Absolute latencies are hardware-dependent — the portable claim is the O(log N) scaling noted below, not the millisecond figures. These figures come from a single-workstation run; no committed artifact backs them yet and make repro-verify does not cover them:

Operation	Metric	Value
Query (FTS5 + rerank)	p50 latency	2.1 ms
Query (FTS5 + rerank)	p95 latency	4.9 ms
Query (FTS5 + rerank)	mean latency	2.6 ms
Incremental reindex	elapsed	32 ms (13 blocks indexed)
Full index build	elapsed	48 ms (65 blocks)
MCP tool overhead	stdio round-trip	< 15 ms
Memory footprint	RSS (idle MCP server)	~28 MB

Query latency scales as O(log N) with SQLite FTS5 (vs O(corpus) for scan backend). The co-retrieval graph adds < 1ms per query. Knee cutoff and fact aggregation add negligible overhead (< 0.5ms).

Feedback-Quality -> Downstream-Success (synthetic, deterministic)

Downstream-success prediction (synthetic, deterministic): starved 0.00 -> sufficient 1.00 at matched budget. 48-episode regression gate over the v4.7.0 per-hit feedback-quality credit + v4.8.0 recall-sufficiency score; see benchmarks/REPORT.md and benchmarks/feedback_success_bench.py.

Run Benchmarks Yourself

# Retrieval-only (R@K metrics)
python3 benchmarks/locomo_harness.py
python3 benchmarks/longmemeval_harness.py

# LLM-as-judge (accuracy metrics, requires API key)
python3 benchmarks/locomo_judge.py --dry-run
python3 benchmarks/locomo_judge.py --answerer-model <your-answerer-model> --output results.json

# Hybrid retrieval with any model pair (BM25 + vector + cross-encoder)
python3 benchmarks/locomo_judge.py --hybrid --compress --answerer-model <your-answerer-model> --judge-model <your-judge-model> --output results.json

# Selective conversations
python3 benchmarks/locomo_harness.py --conv-ids 4,7,8

Install in 3 commands

pip install mind-mem
mm install-all --force      # auto-wires every detected AI CLI
mm install-model            # downloads mind-mem-4b GGUF + imports to Ollama

Full options + Postgres setup + troubleshooting: docs/install-guide.md

Quick Start

One-line install (recommended)

pipx install "mind-mem[mcp]"
mind-mem-mcp --help          # smoke-test

pipx keeps MIND-Mem in its own venv, exposes the mind-mem-mcp console script on PATH, and avoids polluting your system Python. If you don't have pipx, pip install --user "mind-mem[mcp]" works too.

Then wire it into every AI coding client on your machine:

git clone https://github.com/star-ga/mind-mem.git
cd mind-mem
./install.sh --all --no-install   # Already installed via pipx, just wire clients

Or do both in one shot (the installer will auto-pick pipx if available, else fall back to pip):

git clone https://github.com/star-ga/mind-mem.git
cd mind-mem
./install.sh --all

./install.sh has dedicated flags for eight clients (Claude Code, Claude Desktop, Codex CLI, Gemini CLI, Cursor, Windsurf, Zed and OpenClaw); every other registry client is wired with ./install.sh --client <id>, and --all covers every detected one. Each client launches the same MCP server, so all agents share one workspace.

For the full set of 69 clients (41 of them get an automatic MCP entry), use mm install-all after installing the package; it auto-detects what is on your machine and writes these files (Linux paths shown; macOS and Windows locations are resolved per platform):

Client	Config Location	Format
Claude Code (`claude-code`)	`~/.claude/settings.json` + MCP `~/.claude.json`	JSON (hooks) + JSON
Codex CLI (`codex`)	`<workspace>/AGENTS.md` + MCP `~/.codex/config.toml`	Markdown block + TOML
Grok Build CLI (`grok-build`)	`<workspace>/AGENTS.md` + MCP `~/.grok/config.toml`	Markdown block + TOML
Vibe (Mistral CLI) (`vibe`)	`<workspace>/AGENTS.md` + MCP `~/.vibe/config.toml`	Markdown block + TOML
OpenCode (1.x / 2.x) (`opencode`)	`~/.config/opencode/AGENTS.md` + MCP `~/.config/opencode/opencode.json`	Markdown block + JSON
Gemini CLI (`gemini`)	`<workspace>/.gemini/settings.json` + MCP `~/.gemini/settings.json`	JSON
Cursor (`cursor`)	`<workspace>/.cursorrules` + MCP `~/.cursor/mcp.json`	Markdown block + JSON
Windsurf (`windsurf`)	`<workspace>/.windsurfrules` + MCP `~/.codeium/windsurf/mcp_config.json`	Markdown block + JSON
aider (`aider`)	`<workspace>/.aider.conf.yml`	YAML
OpenClaw (`openclaw`)	`~/.openclaw/openclaw.json` + MCP `~/.openclaw/openclaw.json`	JSON (hooks) + JSON
NanoClaw (`nanoclaw`)	`~/.nanoclaw/nanoclaw.json`	JSON (hooks)
NemoClaw ()

Cline and Roo Code: the installer writes desktop VS Code's settings tree (~/.config/Code/User/ on Linux) and, when present, the VS Code Server (remote / WSL) copy under ~/.vscode-server/data/User/.

Selective install:

./install.sh --claude-code --codex --gemini         # Only specific clients
./install.sh --all --workspace ~/my-project/memory  # Custom workspace path

Uninstall:

./uninstall.sh          # Remove from all clients (keeps workspace data)
./uninstall.sh --purge  # Remove everything including workspace data

Manual Setup

For manual or per-project setup:

1. Clone into your project

cd /path/to/your/project
git clone https://github.com/star-ga/mind-mem.git .mind-mem

2. Initialize workspace

PYTHONPATH=.mind-mem/src python3 -m mind_mem.init_workspace .
# or, after `pip install -e .mind-mem`:  mind-mem-init .

Creates the directory tree, the template files and the mind-mem.json config. Never overwrites existing files.

3. Validate

bash .mind-mem/src/mind_mem/validate.sh .
# or cross-platform:
PYTHONPATH=.mind-mem/src python3 -m mind_mem.validate_py .

Expected: 0 issues (17 checks on a fresh workspace; warnings for empty sections are normal).

4. First scan

PYTHONPATH=.mind-mem/src python3 -m mind_mem.intel_scan .

Expected: 0 critical | 0 warnings on a fresh workspace.

5. Verify recall + capture

PYTHONPATH=.mind-mem/src python3 -m mind_mem.recall --query "test" --workspace .
# → No results found. (empty workspace — correct)

PYTHONPATH=.mind-mem/src python3 -m mind_mem.capture .
# → capture: no daily log for YYYY-MM-DD, nothing to scan (correct)

6. Add hooks (optional)

Option A: Claude Code hooks (recommended)

Merge into your .claude/hooks.json:

{
  "hooks": [
    {
      "event": "SessionStart",
      "command": "bash .mind-mem/hooks/session-start.sh"
    },
    {
      "event": "Stop",
      "command": "bash .mind-mem/hooks/session-end.sh"
    }
  ]
}

Option B: OpenClaw hooks (for OpenClaw 2026.2+)

cp -r .mind-mem/hooks/openclaw/mind-mem ~/.openclaw/hooks/mind-mem
openclaw hooks enable mind-mem

7. Smoke Test (optional)

bash .mind-mem/src/mind_mem/smoke_test.sh

Creates a temp workspace, runs init → validate → scan → recall → capture → pytest, then cleans up.

Health Summary

After setup, this is what a healthy workspace looks like:

$ python3 -m mind_mem.intel_scan .

mind-mem Intelligence Scan Report v2.0
Mode: detect_only

=== 1. CONTRADICTION DETECTION ===
  OK: No contradictions found among 25 signatures.

=== 2. DRIFT ANALYSIS ===
  OK: All active decisions referenced or exempt.
  INFO: Metrics: active_decisions=17, active_tasks=7, blocked=0,
        dead_decisions=0, incidents=3, decision_coverage=100%

=== 3. DECISION IMPACT GRAPH ===
  OK: Built impact graph: 11 decision(s) with edges.

=== 4. STATE SNAPSHOT ===
  OK: Snapshot saved.

=== 5. WEEKLY BRIEFING ===
  OK: Briefing generated.

TOTAL: 0 critical | 0 warnings | 16 info

Commands

Command	What it does
`/scan`	Run integrity scan — contradictions, drift, dead decisions, impact graph, snapshot, briefing
`/apply`	Review and apply proposals from scan results (dry-run first, then apply)
`/recall <query>`	Search across all memory files with ranked results (add `--graph` for cross-reference boosting)

The three skills above live in skills/.

Agent skill: CLI user manual

Agents that prefer the shell over MCP can install a mind-mem skill that works as a user manual for the mm CLI. Its SKILL.md is a table of contents — what mind-mem is, which command to run for which job, and how governed writes work — and it points to reference files the agent opens only when it needs them:

Reference	Covers
`install.md`	Install, workspaces, wiring clients, upgrading, removing
`cli.md`	Every `mm` subcommand with its flags and an example (generated from the parser)
`configuration.md`	`mind-mem.json` keys, `mm config set`, environment variables
`troubleshooting.md`	`mm doctor`, `mind-mem-verify`, common errors and their fixes
`mcp-vs-cli.md`	When to use which, and the MCP-tool-to-command map
`faq.md`	Basic questions about the product

mm skill install                             # -> ~/.claude/skills/mind-mem
mm skill install --target ~/.codex/skills    # any agent that reads SKILL.md folders

The skill ships inside the package. tests/test_skill_manual.py fails the build if a documented command, flag, environment variable or config key stops existing, and python3 scripts/gen_skill_cli_reference.py regenerates the CLI reference after the parser changes.

Architecture

your-workspace/
├── mcp_server.py            # MCP server (FastMCP, 107 tools, 8 resources)
├── mind-mem.json             # Config
├── MEMORY.md                # Protocol rules
│
├── mind/                    # 26 .mind files: 18 INI config + 8 MIND sources
│   ├── README.md            # Source/config inventory and migration status
│   ├── bm25.mind            # MIND-language source prototype
│   ├── rrf.mind             # MIND-language source prototype
│   ├── ranking.mind         # MIND-language source prototype
│   └── recall.mind          # INI pipeline configuration example
│
├── lib/                     # Optional native C scoring backend
│   └── libmindmem.so        # Locally built from lib/kernels.c; not bundled
│
├── decisions/
│   └── DECISIONS.md         # Formal decisions [D-YYYYMMDD-###]
├── tasks/
│   └── TASKS.md             # Tasks [T-YYYYMMDD-###]
├── entities/
│   ├── projects.md          # [PRJ-###]
│   ├── people.md            # [PER-###]
│   ├── tools.md             # [TOOL-###]
│   └── incidents.md         # [INC-###]
│
├── memory/
│   ├── YYYY-MM-DD.md        # Daily logs (append-only)
│   ├── intel-state.json     # Scanner state + metrics
│   └── maint-state.json     # Maintenance state
│
├── summaries/
│   ├── weekly/              # Weekly summaries
│   └── daily/               # Daily summaries
│
├── intelligence/
│   ├── CONTRADICTIONS.md    # Detected contradictions
│   ├── DRIFT.md             # Drift detections
│   ├── SIGNALS.md           # Auto-captured signals
│   ├── IMPACT.md            # Decision impact graph
│   ├── BRIEFINGS.md         # Weekly briefings
│   ├── AUDIT.md             # Applied proposal audit trail
│   ├── SCAN_LOG.md          # Scan history
│   ├── proposed/            # Staged proposals + resolution proposals
│   │   ├── DECISIONS_PROPOSED.md
│   │   ├── TASKS_PROPOSED.md
│   │   ├── EDITS_PROPOSED.md
│   │   └── RESOLUTIONS_PROPOSED.md
│   ├── applied/             # Snapshot archives (rollback)
│   └── state/snapshots/     # State snapshots
│
├── shared/                  # Multi-agent shared namespace
│   ├── decisions/
│   ├── tasks/
│   ├── entities/
│   └── intelligence/
│       └── LEDGER.md        # Cross-agent fact ledger
│
├── agents/                  # Per-agent private namespaces
│   └── <agent-id>/
│       ├── decisions/
│       ├── tasks/
│       └── memory/
│
├── mind-mem-acl.json        # Multi-agent access control
├── .mind-mem-wal/           # Write-ahead log (crash recovery)
│
└── src/mind_mem/
    ├── mind_ffi.py          # MIND FFI bridge (ctypes)
    ├── hybrid_recall.py     # Hybrid BM25+Vector+RRF orchestrator
    ├── block_metadata.py    # A-MEM metadata evolution
    ├── cross_encoder_reranker.py  # Optional cross-encoder
    ├── intent_router.py     # 9-type intent classification (adaptive)
    ├── recall.py            # BM25F + RM3 + graph scoring engine
    ├── recall_vector.py     # Vector/embedding backends
    ├── sqlite_index.py      # FTS5 + vector + metadata index
    ├── connection_manager.py # SQLite connection pool (WAL read/write separation)
    ├── block_store.py       # BlockStore protocol + MarkdownBlockStore
    ├── corpus_registry.py   # Central corpus path registry
    ├── abstention_classifier.py  # Adversarial abstention
    ├── evidence_packer.py   # Evidence assembly and ranking
    ├── intel_scan.py        # Integrity scanner
    ├── apply_engine.py      # Proposal apply engine (delta-based snapshots)
    ├── block_parser.py      # Markdown block parser (typed)
    ├── capture.py           # Auto-capture (27 patterns)
    ├── compaction.py        # Compaction/GC/archival
    ├── mind_filelock.py     # Cross-platform advisory file locking
    ├── observability.py     # Structured JSON logging + metrics
    ├── namespaces.py        # Multi-agent namespace & ACL
    ├── conflict_resolver.py # Automated conflict resolution
    ├── backup_restore.py    # WAL + backup/restore + JSONL export
    ├── transcript_capture.py  # Transcript JSONL signal extraction
    ├── validate.sh          # Structural validator (shell)
    └── validate_py.py       # Structural validator (Python, cross-platform)

How It Compares

Quick Comparison

Feature	MIND-Mem	Mem0	Letta	Zep/Graphiti	Engram	Basic Memory	OpenViking
Local-only	Yes	Parta	Self-hostb	Self-hostc	Yesd	Yese	Part (needs a configured VLM)
Zero infrastructure	Yes	Partf	No	No	Yesg	Yes	No (server)
Hybrid retrieval	BM25F + vector + RRF	Semantic + BM25 + entity, additiveh	Vectori	Graph + BM25 + vector, RRF / cross-encoder	FTS5 only	FTS5 + vector, score fusion	Vector, optional rerank; BM25 / sparse only with hosted VikingDB
Governance (propose/review/apply)	Yes	No	No	No	No	No	No
Contradiction detection	Yes	Platform onlyj	LLM prompt only	Yesk	Agent-judged	No	LLM, at merge
Test functions	13,258 test functions	-	-	-	-	-	-
LoCoMo benchmark (full 10-conv, Acc>=50)¹	73.8%	66.9%²	74.0%	-	-	-	-³
MCP tools	107 distinctl	Hostedm	Client only	13	23	27	24
Core dependencies	0	Many	Many	Many	0n	Many	Many

a Mem0, Local-only: OSS can run locally; defaults to a cloud LLMb Letta, Local-only: heavy runtimec Zep/Graphiti, Local-only: graph DB + LLMd Engram, Local-only: cloud optionale Basic Memory, Local-only: cloud optionalf Mem0, Zero infrastructure: library mode; needs LLM + embedderg Engram, Zero infrastructure: single Go binaryh Mem0, Hybrid retrieval: no RRFi Letta, Hybrid retrieval: BM25 + RRF only with Turbopufferj Mem0, Contradiction detection: Dreamk Zep/Graphiti, Contradiction detection: LLM-basedl MIND-Mem, MCP tools: mcp.tool registrations; recall dispatcher shadows base recallm Mem0, MCP tools: Platformn Engram, Core dependencies: single binary

¹ Canonical MIND-Mem LoCoMo number — see docs/benchmarks.md for scope/evidence. On this apples-to-apples metric MIND-Mem is not the top score of every system evaluated (see the Competitive Landscape table above); its differentiator is being the only local-only, zero-dependency, governed option.

² Mem0's own published LoCoMo-paper number. Mem0's separate 2026 managed platform self-reports 91.6 on a different setup/judge — not apples-to-apples with this row.

³ OpenViking self-reports 80.3–82.9% on a narrower scope (1,540 questions, no adversarial category) with a more lenient judge; see note ³ under the Competitive Landscape table.

At a Glance

Tool	Strength	Trade-off
Mem0	Managed platform plus self-hostable OSS; semantic + BM25 + entity retrieval; user/agent/run scoping	Graph memory, Dream and hosted MCP are platform-only; OSS writes go straight in with no review
Supermemory	Knowledge graph with supersession, optional reranking, auto-ingestion from Drive/Notion	Engine is closed-source; cloud-first (local binary lacks connectors and MCP); only inferred memories are reviewed
claude-mem	Purpose-built for Claude Code, Chroma vectors + SQLite FTS5, MCP server	Needs Bun, uv, Chroma and a worker service; LLM observer; no contradiction detection or write governance
Letta	Self-editing memory blocks, sleep-time agents, git-tracked memory (letta-code)	Full agent runtime (heavy), not just memory; hybrid search needs Turbopuffer
Zep	Temporal knowledge graph (Graphiti, Apache-2.0), bi-temporal model, BM25 + vector + RRF, MCP server	Needs a graph database and an LLM; Zep itself is the managed service
LangMem	Native LangChain/LangGraph integration, background extraction	Tied to LangChain ecosystem; retrieval delegated to the LangGraph store
Cognee	Graph + vector memory, local-first defaults, auto-improve loop, MCP server	LLM-driven graph build; heavy dependency tree; no lexical+vector fusion or write governance
Graphlit	Multimodal ingestion, semantic search, managed platform	Cloud-only, managed service
ClawMem	Full ML pipeline (cross-encoder + QMD + beam search), 33 MCP tools

Full Feature Matrix

Compared against every major memory solution for AI agents, checked against each project's public source or official docs in October 2026. Column codes and cell symbols are the same as in the Feature Completeness Matrix.

Recall

Feature	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Vector	opt	✓	✓	Chroma	✓	✓	✓	✓	✓	✓	✓	—	↓1	✓
Lexical	BM25F	BM25	FTS	FTS5	◐	BM25	—	◐	Keyword	BM25	—	FTS5	FTS5	opt
Graph	2-hop	◐	✓	—	—	✓	—	✓	✓	↓2	—	—	✓	◐
Hybrid + RRF	opt	◐3	◐	◐	◐	✓	—	◐

1 Basic Memory, Vector: FastEmbed2 ClawMem, Graph: Beam + MPFP3 Mem0, Hybrid + RRF: no RRF4 Basic Memory, Hybrid + RRF: score fusion5 MIND-Mem, Cross-encoder: MiniLM 80MB6 Graphlit, Cross-encoder: Reranker7 ClawMem, Cross-encoder: qwen3 0.6B8 MIND-Mem, Query expansion: RM3 (zero-dep)9 Supermemory, Query expansion: LLM rewrite10 ClawMem, Query expansion: QMD 1.7B

Persistence

Feature	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Structured	Markdown	JSON	Grph	SQL	Blk	Grph	KV	Grph	Grph	SQL	↓1	SQL	↓2	↓3
Entities	✓	✓	✓	—	◐	✓	◐	✓	✓	✓	—	—	✓	✓
Temporal	✓	◐	✓	◐	◐	✓	◐	✓	✓	✓	◐	◐	✓	◐
Supersede	✓	◐	✓	—	◐	✓	◐	◐

1 MemU, Structured: SQL + Markdown2 Basic Memory, Structured: Markdown3 OpenViking, Structured: Markdown + vector index

Integrity

Feature	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Contradictions	✓	◐	✓	—	◐	✓	◐	◐	—	◐	—	↓1	—	◐
Drift detection	✓	—	—	—	—	—	—	—	—	—	—	↓2	↓3	◐
Validation	Structural	—	—	—	—	n/v	◐	✓	—	◐	—	◐	Schema	✓
Impact graph	✓	—	—	—	—	—	—	—

1 Engram, Contradictions: Agent-judged2 Engram, Drift detection: Staleness3 Basic Memory, Drift detection: Schema drift4 Engram, Conflict res.: Agent-judged5 Basic Memory, WAL/crash: Index only

Governance

Feature	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Auto-capture	Propose	Auto	Auto	Auto	Self	Ext	Auto	Auto	Ing	Auto	Auto	↓1	↓2	Auto
Proposal queue	✓	—	◐	—	—	—	—	◐	—	—	—	—	—	—
Rollback	✓	—	◐	—	◐	◐	—	—	—	◐	—	—	Cloud	◐
Mode governance	3 modes	—	—	—	—	—	—	—

1 Engram, Auto-capture: Agent + passive2 Basic Memory, Auto-capture: Plugin hooks

Operations

Feature	MM	M0	SM	CM	Le	Zep	LM	Co	GL	CW	MU	En	BM	OV
Local-only	✓	◐	◐	◐	◐	◐	◐	✓	—	✓	◐	✓	✓	◐
Zero core deps	✓	—	n/v	—	—	—	—	—	—	—	—	✓	—	—
No daemon	✓	✓	—	—	—	◐	✓	✓	N/A	◐	✓	◐	✓	—
GPU required	No	No	No	No	No	No	No	No	No

1 ClawMem, GPU required: optional2 18 config + 8 source

The Gap MIND-Mem Fills

Most tools above focus on **storage + retrieva

添加此服务器

用我们的密钥与日志托管一份副本。

Server facts

Tools

Questions

How do I install Mind Mem?

Does Mind Mem need an API key?

What transport does Mind Mem use?

When was Mind Mem last checked?

Documentation

30-Second Demo

Substrate Properties

Table of Contents

Deep-dive docs

Why MIND-Mem

Novel Contributions

Features

Hybrid BM25+Vector Search with RRF Fusion

RM3 Dynamic Query Expansion

9-Type Intent Router

A-MEM Metadata Evolution

Deterministic Reranking

Optional Cross-Encoder

MIND Kernel Sources and Configuration

MIC/MAP — MIND IR graph serialization

BM25F Hybrid Recall

Graph-Based Recall

Vector Recall (optional)

Persistent Memory

Immune System

Safe Governance

Adversarial Abstention Classifier

Auto-Capture with Structured Extraction

Tool-Output Offload (v4.2.0)

Concurrency Safety

Compaction & GC

Observability

Multi-Agent Namespaces & ACL

Automated Conflict Resolution

Write-Ahead Log (WAL) + Backup/Restore

Transcript JSONL Capture

MCP Server (107 tools, 8 resources)

Structural Validation + 13,258 Test Functions

Audit Trail

Calibration Feedback Loop

LLM-Guided Multi-Query Expansion

4-Layer Search Deduplication

LLM-Guided Smart Chunking

Compiled Truth Pages

Dream Cycle (Autonomous Memory Enrichment)

Feature Completeness Matrix

Integrations are the substrate working

Native integration with 69 clients (41 MCP-aware clients)

Compatible with major LLM providers

Production usage at STARGA

What we do not claim

Benchmark Results

Needle In A Haystack (NIAH)

LoCoMo LLM-as-Judge

Competitive Landscape (LoCoMo)

LongMemEval-S

Performance (Latency & Throughput)

Feedback-Quality -> Downstream-Success (synthetic, deterministic)

Run Benchmarks Yourself

Install in 3 commands

Quick Start

One-line install (recommended)

Manual Setup

Health Summary

Commands

Agent skill: CLI user manual

Architecture

How It Compares

Quick Comparison

At a Glance

Full Feature Matrix

The Gap MIND-Mem Fills