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 . 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.
Persistent AI memory for Claude Code, OpenClaw, and any MCP-compatible agent. BM25F + vector hybrid, governance-aware, local-first, zero-infrastructure.
स्टार
22
टूल
—
अपटाइम
—
named
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.
[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).
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)
CHANGELOG.md — release notes for every published version
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
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 · M0Mem0 · SMSupermemory · CMclaude-mem · LeLetta · ZepZep · LMLangMem · CoCognee · GLGraphlit · CWClawMem · MUMemU · EnEngram · BMBasic Memory · OVOpenViking 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.
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
Cody
Sourcegraph
cody
none
Qodo Gen
Qodo
qodo
none
Claude Desktop
Anthropic
claude-desktop
auto MCP
VS Code (native MCP)
Microsoft
vscode
auto MCP
Visual Studio (Windows)
Microsoft
visual-studio
auto MCP
Qwen Code
Alibaba
qwen-code
auto MCP
Kimi Code CLI
Moonshot AI
kimi-code
auto MCP
Amp
Amp
amp
auto MCP
goose
Agentic AI Foundation (created by Block)
goose
auto MCP
Crush
Charm
crush
auto MCP
Factory Droid
Factory
factory-droid
auto MCP
Kiro
AWS
kiro
auto MCP
Auggie (Augment Code)
Augment Code
auggie
auto MCP
OpenHands CLI
All Hands AI
openhands
auto MCP
MiMo Code
Xiaomi
mimo-code
auto MCP
Junie
JetBrains
junie
auto MCP
Kilo Code
Kilo Code
kilo
auto MCP
Antigravity
Google
antigravity
auto MCP
Tabnine agent
Tabnine
tabnine
auto MCP
Hermes Agent
Nous Research
hermes-agent
auto MCP
AnythingLLM Desktop
Mintplex Labs
anythingllm
auto MCP
Warp
Warp
warp
auto MCP
Open Interpreter
Open Interpreter
open-interpreter
auto MCP
Amazon Q Developer
AWS
amazon-q
auto MCP
LM Studio
Element Labs
lm-studio
auto MCP
Jan
Menlo Research
jan
auto MCP
BoltAI (macOS)
BoltAI
boltai
auto MCP
iFlow CLI
iFlow
iflow
auto MCP
Neovim (mcphub.nvim)
mcphub.nvim (open source)
neovim-mcphub
auto MCP
Trae
ByteDance
trae
manual MCP
Android Studio (Gemini)
Google
android-studio
manual MCP
JetBrains AI Assistant
JetBrains
jetbrains-ai-assistant
manual MCP
LibreChat
LibreChat
librechat
manual MCP
Eclipse (GitHub Copilot)
GitHub / Microsoft
eclipse-copilot
manual MCP
Xcode 26.3+
Apple
xcode
manual MCP
Witsy
Witsy (open source)
witsy
manual MCP
Emacs (mcp.el)
mcp.el (open source)
emacs-mcp-el
manual MCP
Open WebUI
Open WebUI (open source)
open-webui
manual MCP
Docker MCP Toolkit
Docker
docker-mcp-toolkit
manual MCP
Cherry Studio
CherryHQ
cherry-studio
manual MCP
Msty Studio
Msty
msty
manual MCP
Raycast
Raycast
raycast
manual MCP
5ire
5ire (open source)
5ire
manual MCP
Perplexity (macOS app)
Perplexity
perplexity-desktop
manual MCP
ChatGPT
OpenAI
chatgpt-desktop
manual MCP
n8n
n8n
n8n
manual MCP
Dify
LangGenius
dify
manual MCP
Flowise
FlowiseAI
flowise
manual MCP
Blackbox AI
Blackbox
blackbox
manual MCP
fast-agent
fast-agent (open source)
fast-agent
manual MCP
Void
Void (open source)
void
manual 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.
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):
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.
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).
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):
manual MCP: mm install-all --agent trae prints the steps
-
Android Studio (Gemini) (android-studio)
manual MCP: mm install-all --agent android-studio prints the steps
-
JetBrains AI Assistant (jetbrains-ai-assistant)
manual MCP: mm install-all --agent jetbrains-ai-assistant prints the steps
-
LibreChat (librechat)
manual MCP: mm install-all --agent librechat prints the steps
-
Eclipse (GitHub Copilot) (eclipse-copilot)
manual MCP: mm install-all --agent eclipse-copilot prints the steps
-
Xcode 26.3+ (xcode)
manual MCP: mm install-all --agent xcode prints the steps
-
Witsy (witsy)
manual MCP: mm install-all --agent witsy prints the steps
-
Emacs (mcp.el) (emacs-mcp-el)
manual MCP: mm install-all --agent emacs-mcp-el prints the steps
-
Open WebUI (open-webui)
manual MCP: mm install-all --agent open-webui prints the steps
-
Docker MCP Toolkit (docker-mcp-toolkit)
manual MCP: mm install-all --agent docker-mcp-toolkit prints the steps
-
Cherry Studio (cherry-studio)
manual MCP: mm install-all --agent cherry-studio prints the steps
-
Msty Studio (msty)
manual MCP: mm install-all --agent msty prints the steps
-
Raycast (raycast)
manual MCP: mm install-all --agent raycast prints the steps
-
5ire (5ire)
manual MCP: mm install-all --agent 5ire prints the steps
-
Perplexity (macOS app) (perplexity-desktop)
manual MCP: mm install-all --agent perplexity-desktop prints the steps
-
ChatGPT (chatgpt-desktop)
manual MCP: mm install-all --agent chatgpt-desktop prints the steps
-
n8n (n8n)
manual MCP: mm install-all --agent n8n prints the steps
-
Dify (dify)
manual MCP: mm install-all --agent dify prints the steps
-
Flowise (flowise)
manual MCP: mm install-all --agent flowise prints the steps
-
Blackbox AI (blackbox)
manual MCP: mm install-all --agent blackbox prints the steps
-
fast-agent (fast-agent)
manual MCP: mm install-all --agent fast-agent prints the steps
-
Void (void)
manual MCP: mm install-all --agent void prints the steps
-
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
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:
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.
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.
Context database that stores memory, documents and skills as one viking:// file tree; generated one-line abstracts and overviews let agents read summaries before full files; multi-tenant server with ACLs; 24 MCP tools
AGPL-3.0; needs a server and a configured vision-language model; BM25 and sparse retrieval only with Volcengine's hosted VikingDB; LLM-extracted memories are written directly, with no review
In-process memory database over one SQLite file: thought graph, hybrid search, bi-temporal valid-time, tamper-evident journal (MIT)
Very new project; no propose/review/apply pipeline
MIND-Mem
Integrity + governance + zero core deps + hybrid search + MIND kernels + 107 MCP tools (incl. MIC/MAP, walkthrough, persona, pipeline-hash) + cross-model consensus audits (published for v3.11 and v3.12; see audits/)
Lexical recall by default (vector/CE optional)
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.
Persistent AI memory for Claude Code, OpenClaw, and any MCP-compatible agent. BM25F + vector hybrid, governance-aware, local-first, zero-infrastructure.
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
सवाल
Mind Mem कैसे इंस्टॉल करें?
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
क्या Mind Mem के लिए API key चाहिए?
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Mind Mem कौन सा ट्रांसपोर्ट इस्तेमाल करता है?
Mind Mem stdio पर लोकल चलता है।
Mind Mem की पिछली जाँच कब हुई थी?
पिछली जाँच 2026-11-16 को हुई। Persistent AI memory for Claude Code, OpenClaw, and any MCP-compatible agent. BM25F + vector hybrid, governance-aware, local-first, zero-infrastructure.