The most advanced MCP memory server. Period.

_{Hybrid search (BM25 + jina-embeddings-v5 RRF + cross-encoder rerank) · 100+ languages · Temporal Knowledge Graph · Query-aware ranking · Corpus origin detection · Agent/persona disambiguation · Topic tunnels · AAAK compression (5-10x token savings) · GraphRAG · Chunked RAG · Auto-Compaction · Auto-Classification · Memory Capsules · HTTP API · Single binary · Zero API calls}

MemoryPilot demo — instant recall in 28 ms

--- ## Why AI coding assistants forget everything between sessions. MemoryPilot gives them persistent, searchable memory with project awareness, semantic understanding, and automatic knowledge organization. Built-in AAAK compression and memory capsules reduce token consumption by 5-10x when loading context. Every memory is auto-classified with the right importance, kind, and TTL on insert. The database compacts itself automatically — zero maintenance.

Install MemoryPilot

One-liner install for Cursor, Claude Desktop, VS Code, Windsurf, Claude Code, Codex and ChatGPT. Single Rust binary, zero runtime dependencies.

Install the latest release →

How it works

The 9 pillars — hybrid search, temporal knowledge graph, GraphRAG, AAAK compression, auto-classification, self-healing — explained end to end.

Read the architecture →

## Benchmarks ### LongMemEval-S (ICLR 2025) — Academic Standard

MemoryPilot vs Mem0, Zep, MemPalace, mcp-memory-service on LongMemEval-S

Evaluated on 470 questions from the [LongMemEval](https://arxiv.org/abs/2410.10813) benchmark (ICLR 2025), the standard academic dataset for long-term memory retrieval. Turn-level granularity, ~50 sessions per haystack. #### vs the entire market (LongMemEval-S, public numbers) | System | R@5 / Accuracy | Latency | Privacy | Stack | Source | |--------|---------------:|---------|---------|-------|--------| | **MemoryPilot v4.2 (adaptive)** | **99.1%** | ~900 ms | 100% local | Rust · 35 MB binary · zero API | This repo, `--benchmark-longmemeval` @470 | | **MemoryPilot v4.2 (default fast)** | **98.7%** | **~28 ms** | 100% local | Rust · 35 MB binary · zero API | This repo, `--benchmark-longmemeval` @470 | | MemPalace v3.3.3 (hybrid) | 98.4% | not published | 100% local | Python + ChromaDB · ~500 MB | MemPalace v3.3.3 release notes | | agentmemory v0.9 (11k+ stars) | 95.2% | not published | 100% local | Node + iii-engine + SQLite | [github.com/rohitg00/agentmemory](https://github.com/rohitg00/agentmemory) — `benchmark/LONGMEMEVAL.md` | | Mem0 (cloud, OpenAI backend) | 94.4% | ~6 787 tokens/query | Cloud (OpenAI) | SaaS + OpenAI embeddings | [mem0.ai blog](https://mem0.ai/blog/benchmarked-openai-memory-vs-langmem-vs-memgpt-vs-mem0-for-long-term-memory-here-s-how-they-stacked-up) | | mcp-memory-service v10.34.0 | 80.4% | not published | 100% local | Python + SQLite-Vec + MiniLM | [v10.34.0 release notes](https://github.com/doobidoo/mcp-memory-service/releases/tag/v10.34.0) | | Zep / Graphiti | 63.8% | "90% lower vs baseline" | Cloud or self-host | Python + Neo4j + LLM extraction | [arXiv 2501.13956](https://arxiv.org/abs/2501.13956) | | Letta / MemGPT | not measured on LongMemEval | — | Self-host | Python framework | [Letta tracking issue #3115](https://github.com/letta-ai/letta/issues/3115) | > MemoryPilot is the **only system in this comparison that is both 100% local *and* tops the leaderboard**. The default fast mode (~28 ms) already beats every published competitor — including agentmemory (95.2%), the current darling of the AI-agent-memory category with 11k+ GitHub stars. The adaptive cross-encoder mode adds +0.4 pp R@5 for the cost of one ONNX rerank pass per query, and a +6.7 pp MRR lead vs agentmemory (94.9% vs 88.2%). #### Detailed view — MemoryPilot vs MemPalace (closest local competitor) | Metric | MemoryPilot v4.2 (default fast) | MemoryPilot v4.2 (adaptive rerank) | MemPalace v3.3.3 | Delta vs MemPalace | |--------|---------------------------------|------------------------------------|------------------|--------------------| | **R@5** | **98.7%** | **99.1%** | 96.6% raw / 98.4% hybrid | +2.5% vs raw / +0.7% vs hybrid | | **R@10** | **99.6%** | **99.4%** | ~97%¹ | +2.6% vs raw | | **NDCG@10** | **95.1%** | **96.0%** | Not published | MemoryPilot publishes | | **MRR** | **93.6%** | **94.9%** | Not published | MemoryPilot publishes | | **Avg search latency** | ~28 ms | ~900 ms | N/A | Default mode is 30× faster | > ¹ Validated with the full 470-question evaluation set (after dropping the 30 abstention questions) in two modes: default fast local hybrid retrieval (BM25 + cosine RRF, ~28 ms/query, suitable for live MCP traffic) and adaptive cross-encoder rerank (`MEMORYPILOT_CROSS_RERANK=adaptive`, jina-v2-multilingual, fusion weight 0.45, ~900 ms/query, suitable for benchmarks and high-stakes recall). The default mode already beats MemPalace's hybrid held-out result; the adaptive mode trades latency for a further +0.4 pp R@5 and +1.3 pp MRR. #### By Category (470 questions, adaptive rerank) | Category | R@5 | R@10 | MRR | |----------|-----|------|-----| | single-session-user (64) | **100%** | **100%** | 96.6% | | single-session-assistant (56) | **100%** | **100%** | 98.8% | | multi-session (121) | **100%** | **100%** | 95.7% | | knowledge-update (72) | **100%** | **100%** | 98.2% | | temporal-reasoning (127) | 97.6% | 98.4% | 93.3% | | single-session-preference (30) | 96.7% | 96.7% | 75.9% | ### French / Multilingual Benchmark — `--benchmark-fr` To complement the English-only LongMemEval, MemoryPilot ships its own deterministic French benchmark covering 109 memories and 109 paraphrased queries across infra, mobile, web, security, and ML domains. The queries are intentionally distant from the indexed wording so they actually exercise the semantic lane. | Mode | R@5 | R@10 | MRR | Avg latency | |------|-----|------|-----|-------------| | Default fast (BM25 + jina RRF) | 92.7% | 99.1% | 74.4% | ~100 ms | | Adaptive cross-encoder rerank (default) | **99.1%** | **99.1%** | **97.4%** | ~210 ms | v4.5 fixed a ranking bug that had capped this benchmark at R@5 ≈ 70% since v4.0: knowledge-graph neighbours were injected at a hard-coded score (0.1) above every genuine RRF hit (max 2/41 ≈ 0.049), so they occupied the cross-encoder window and pushed real matches past `limit`. Neighbours now enter below the weakest genuine candidate and only the cross-encoder can promote them. v4.5.0 also closes two write-path stability bugs surfaced by that work: the episodic rollup embedded every hourly bucket on **each** pass (before checking whether the episode already existed) and did so synchronously inside `add_memory`, then panicked on multi-byte French text; it now runs on its own thread with a cheap existence check first. And auto-compaction held a `Mutex` across `run_gc`/`compact_to_capsules`, whose merged rows re-enter `add_memory` — a deadlock hidden until the rollup stopped panicking ahead of it. Run-to-run variance is bounded to ±1 pp on R@5 / R@10 thanks to deterministic memory ids, deterministic id-based RRF tie-break, synchronous ANN warm-up, and explicit cross-encoder pre-warm before the first query. This is the metric to watch for any French / multilingual regression. ### v4.6 — beyond single-fact retrieval v4.6.0 targets the LongMemEval categories a top-k retriever alone cannot win: multi-session aggregation, temporal reasoning, knowledge updates and abstention. Everything stays local and rule-based or int8 ONNX. Measured on LongMemEval-S@100 (64 single-session + 36 multi-session, plus the 7 abstention questions of that slice) against v4.5.0, same machine, cross-encoder adaptive: | Metric | v4.5.0 | v4.6.0 | |---|---|---| | R@5 / R@10 | 99% / 100% | **100%** / 100% | | MRR / nDCG@10 | 96.3% / 97.2% | **96.5%** / **97.3%** | | Multi-session gold coverage@10 | 93.6% | **94.5%** | | Multi-session questions with *all* gold sessions in top-10 | 30/36 | **32/36** | | False abstention on answerable questions | — | 4% | | Extractive answer (`search_memory … answer=true`), contains-gold | — | 48% (72% single-session; counting questions are out of reach for span extraction) | `--benchmark-fr` is unchanged within noise (R@1 96.3%, R@5 99.1%, MRR 97.6%). - **MMR diversity** (`src/diversity.rs`) — the finalists plus the RRF ranks just below them are re-ordered by maximal marginal relevance over their stored vectors (λ = 0.4, redundancy floor 0.55). The top hit never moves, so MRR is untouched; a second, distinct source can displace a restatement of the first. `MEMORYPILOT_MMR=0` disables it. - **Temporal grounding** (`src/temporal.rs`) — explicit dates in a memory (`2026-09-01`, `12 septembre 2026`, `September 12`, `hier`…) become `date` entities at ingest; a temporal phrase in the query (`last week`, `il y a deux semaines`, `en mars`, `last Tuesday`) becomes a day window that boosts dated candidates inside it (×1.25) and mildly demotes dated candidates far outside (×0.85). Undated memories are neutral, so a mis-parsed window costs at most the boost. `MEMORYPILOT_TEMPORAL=0` disables it. - **Contextual embeddings** — transcript chunks and other context-poor kinds are embedded with a `[date · project]` prefix while the stored content and its hash are left untouched. - **Superseding** — the daily consolidation pass links a memory to a newer, near-identical restatement with a changed value (cosine ≥ 0.86, lexical overlap 0.55–0.95, ≥ 1 h apart) and the old one is demoted (−0.35) at search time. Both stay retrievable; `consolidate_memories(apply=true)` reports the links made. - **Calibrated confidence** — every search returns `confidence: { top_cosine, peak, cross_score, margin, level, abstain }`. On LongMemEval the abstention haystacks are built from the *same user's* other sessions and no cheap signal separates them from answerable questions (top-1 cosine p50 0.46 vs 0.54, cross-encoder logits overlap fully), so the hard `abstain` is deliberately conservative (cosine < 0.35, 4% false abstention) and `level` carries the graded signal. `MEMORYPILOT_ABSTAIN_COSINE` moves the floor. - **Extractive reader** (`src/reader.rs`, opt-in) — `search_memory` with `answer: true` runs `deepset/roberta-base-squad2` (int8 ONNX, 125 MB, English, loaded on demand through the idle pool) over the top-5 passages and returns the literal span or nothing. ~480 ms per question on CPU. It is a benchmarking instrument and a shortcut for literal lookups, not a language model: it abstained on 5/7 LongMemEval abstention questions where the retriever could not. `--benchmark-longmemeval --reader` reports SQuAD-style EM / F1 / contains. ### Search Quality — Real-World (500 memories, 30 scenarios) | Metric | MemoryPilot v4.2 | MemPalace v3.1 (raw) | Quantum Memory Graph | |--------|------------------|----------------------|---------------------| | **R@5** | **100%** | 96.6% | 93.4% | | **R@10** | **100%** | N/A | 93.4% | | **NDCG@10** | **95.6%** | 88.9% | 90.8% | | **Cluster Coherence** | **96.7%** | N/A | N/A | | **Multilingual** | **100+ languages** (validated FR R@5 99.1%) | English only | English only | | **AAAK Compression** | **5-10x** (no recall loss) | 30x (recall drops to 84.2%) | N/A | | **Avg Search Latency** | **~28 ms** default / ~410 ms adaptive | N/A | ~80 ms | | **Binary Size** | **35 MB** | ~500 MB (Python+ChromaDB) | 1.5 GB | | **Dependencies** | 0 (single binary, ONNX bundled) | Python + ChromaDB + SQLite | Python + ONNX | --- **vs the best memory servers on the market:** | Feature | MemoryPilot v4.2 | MemPalace v3.3.3 | agentmemory v0.9 | Mem0 | Zep / Graphiti | |---------|-----------------|----------------|------------------|------|----------------| | LongMemEval R@5 | **99.1%** | 98.4% | 95.2% | 94.4% | 63.8% | | LongMemEval MRR | **94.9%** | not published | 88.2% | not published | not published | | Search | Hybrid BM25 + jina-embeddings-v5-nano RRF (768-dim, int8) + adaptive mmarco cross-encoder | ChromaDB cosine (all-MiniLM-L6-v2) | BM25 + vector + graph (RRF) | Vector search (cloud API) | Temporal KG traversal + vector | | Embeddings | jina-embeddings-v5-text-nano-retrieval (100+ languages, 8k context, local ONNX) | all-MiniLM-L6-v2 (English only) | all-MiniLM-L6-v2 (English only) | OpenAI API calls (external) | OpenAI / cloud LLM extraction | | Multilingual | **100+ languages native (FR, EN, ES, DE, JA, ZH...)** | English only | English only | Depends on API | Depends on LLM backend | | Knowledge Graph | Temporal triples with validity + confidence | Temporal triples (SQLite) | Knowledge graph (no validity window) | Basic graph (no temporal) | Temporal KG (Graphiti, core feature) | | GraphRAG | Auto entity extraction + graph traversal + combinatorial reranker | No | Partial (graph search lane) | No | Yes (LLM-based extraction) | | Cross-encoder rerank | jina-v2-multilingual (adaptive, ~250 ms) | No | No | No | No | | Query-aware ranking | Preference/temporal/role/update/technical intent boosts | Hybrid v4 keyword + temporal boosts | RRF fusion only | Depends on API | Graph-distance scoring | | Corpus origin detection | AI transcript/codebase/notes/platform detection | v3.3.4 prep | No | No | No | | Agent/persona disambiguation | Agents are separate from real people | v3.3.4 prep | Hooks-based session scoping | No | Partial (entity nodes) | | Topic tunnels | Cross-project topic links via KG | v3.3.4 prep | No | No | No | | Code-aware chunking | Tree-sitter Rust/Python/TS/TSX/JS + Svelte script extraction | Tree-sitter code chunking | No | No | No | | Chunked RAG | Transcript auto-chunking + auto-distillation (8 types) | Conversation chunking by exchange | Session replay + JSONL import | No | LLM-based summarisation | | Compression | AAAK + Memory Capsules (5-10x token savings) | AAAK dialect (experimental, regresses recall to 84.2%) | 4-tier consolidation + decay | No | No | | Auto-Classification | Zero-shot kind/importance/TTL on insert | No | Pattern-based via hooks | No | LLM-classified entities | | Auto-Compaction | GC triggers automatically at 500+ memories | No | Lifecycle decay + auto-forget | No | Manual | | Memory Capsules | Compress old memories into dense summaries | No | Tier-based consolidation | No | No | | Memory Pinning | Pin critical memories — always in recall, GC-proof | No | No | No | No | | Graph Traversal | Find related memories via KG (depth 1-3) | No | Yes (graph lane) | No | Native (Cypher / Neo4j) | | Bulk Operations | Delete by kind/project/tag/age with safety guards | No | Governance delete API | No | Manual | | Health Dashboard | Memory distribution, stale count, orphans, DB size | No | Real-time web viewer (port 3113) | No | No | | Dedup Detection | Jaccard similarity scan for near-duplicates | No | Not documented | No | LLM-based reconciliation | | Person detection | Auto-detects team members from text | No | No | No | LLM-extracted entities | | Self-Healing | Background auto-linting loop | No | No | No | No | | Garbage collection | Heuristic merge + scoring + orphan cleanup | No | Lifecycle + decay | Basic TTL | No automatic GC | | Project brain | Yes, with team members (<1500 tokens) | No | Session summary on demand | No | No | | File watcher | Context boost from recent edits | No | Filesystem connector (`@agentmemory/fs-watcher`) | No | No | | Deduplication | Content hash (exact) + Jaccard 85% (fuzzy) | Basic hash | Confidence scoring | Embedding similarity | LLM-based merge | | HTTP API | Multi-threaded REST server (optional) | No | REST + MCP + leases + signals | Cloud hosted | REST + GraphQL | | Memory types | 13 types, importance 1-5 | Wings/Rooms hierarchy | Tier-based (working / short / long / archival) | 1 type | Episodic / semantic | | MCP tools | 41 tools | 29 tools | **51 tools** | N/A | Limited MCP server | | Hooks / event capture | File watcher + auto-linter (Rust-only) | No | **12 named hooks** (SessionStart, UserPromptSubmit, PreToolUse...) | No | No | | Privacy | 100% local, zero API calls | 100% local | 100% local (SQLite) | Cloud dependent | Cloud or self-host (LLM required) | | Language | Rust (single binary, zero deps) | Python (pip install) | TypeScript / Node (npm install) | SaaS | Python + Neo4j | | Startup | 1-2 ms (`open_at`) / synchronous warm via `open_at_warm` | ~5 ms | Node boot + iii-engine init | N/A (cloud) | Heavy (Neo4j boot) | | Binary | 35 MB single binary | Python + ChromaDB (~500 MB installed) | Node runtime + iii-engine deps | SaaS | Python + Neo4j (~1.5 GB) | | Storage | SQLite WAL + FTS5 + 16-conn read pool | ChromaDB | SQLite + iii-engine | Cloud DB | Neo4j + Postgres | | Concurrency | EmbedPool (4) + RerankPool (1, tunable) + 16 read conns + debounced cleanup | Single-threaded | Node event loop | Single-threaded | Neo4j-bound | | External LLM dependency | **None** | None | None (local embeddings) | OpenAI required | LLM required for ingestion | | GitHub stars (May 2026) | nascent | nascent | **11 083** | 53k | — | ## The 9 Pillars ### 1. Hybrid Search (BM25 + jina RRF) Every memory gets a 768-dimension transformer embedding on insert via ONNX Runtime (`jina-embeddings-v5-text-nano-retrieval`, int8, local inference — 100+ languages including French, English, Spanish, German, Japanese, Chinese — no API calls, no external services; the model is fetched from its Hugging Face repository on first run, licence CC-BY-NC-4.0). Queries and documents use the model's asymmetric `Query:` / `Document:` prefixes. The int8 weights are memory-mapped, so the embedder costs ~250 MB resident, most of it reclaimable file-backed pages. Search runs both BM25 full-text and cosine similarity in parallel, then merges results with Reciprocal Rank Fusion. Results are boosted by importance weighting, knowledge graph link density, file watcher context, and penalized for expired knowledge triples. Ephemeral working memory is available in the same MCP through `remember_working`, `recall_working`, and `clear_working`. It keeps fast session scratchpad context in RAM, capped to 256 items, without polluting SQLite or durable recall. **Performance optimizations:** - Lazy embedding: `add_memory` returns instantly, embeddings computed in background thread - Two-tier query embedding cache (LRU 256 + write-through SQLite): repeated queries skip ONNX inference - Read connection pool (16 connections): concurrent vector searches don't block writes, sized for HTTP server workloads - EmbedPool (4 sessions, env-tunable): parallel embeddings without serialization on a single ONNX mutex - RerankPool (1 session, env-tunable to 2): parallel cross-encoder rerank under multi-client load - Content hashing (FNV-1a): backfill skips unchanged memories - Synchronous warm-up entrypoint `open_at_warm`: hydrates the ANN index in RAM before returning, eliminating cold-start tail (p95 search latency 3939 ms → 229 ms in the 4-client concurrency bench) ### 2. Temporal Knowledge Graph A full knowledge graph with temporal validity. Facts have `valid_from` / `valid_to` dates and `confidence` scores. When facts become outdated, they are invalidated rather than deleted — giving the AI a timeline of how knowledge evolved. Entities (technologies, files, components, people) are automatically extracted from memory content and linked bidirectionally. Search results from memories with all-expired triples are penalized. **5 dedicated KG tools:** `kg_add`, `kg_invalidate`, `kg_query`, `kg_timeline`, `kg_stats` ### 3. GraphRAG Every memory is automatically analyzed for entities: technologies, file paths, components, projects, and **people**. Entities are stored in a dedicated table. Memories sharing entities are auto-linked with inferred relationship types (`resolves`, `implements`, `depends_on`, `deprecates`...). When searching, MemoryPilot traverses the knowledge graph from the top matches to pull in related context — e.g., finding the architecture decision that led to a specific bug fix. A **combinatorial reranker** then selects the best *cluster* of connected memories rather than independent top-K results, producing cohesive context (94% cluster coherence). Tuned RRF fusion (k=40), exact term coverage boost, smart FTS tokenization, query-time KG expansion, temporal recency, and importance tiebreakers push NDCG@10 to 94% with perfect R@5/R@10. ### 4. Chunked RAG (Transcripts) Save full conversation transcripts without polluting the LLM context window. The `add_transcript` tool automatically chunks large texts into ~2000 character blocks and links them together. Chunks are excluded from `recall` but fully searchable. For source code, MemoryPilot uses local tree-sitter parsing by default for Rust, Python, TypeScript, TSX, and JavaScript, with Svelte support via `