Mempalace

Overview

MemPalace is a local-first, MIT-licensed long-term memory layer for AI coding agents and chat workflows. It stores conversation history and project text verbatim (no LLM summarization on the core path), indexes it for semantic search, and exposes a CLI plus an MCP server so tools such as Claude Code, Cursor, Codex CLI, and Gemini CLI can recall past decisions without re-explaining them every session.

The project launched in early April 2026 under co-creators Milla Jovovich and engineer Ben Sigman, went viral on GitHub (tens of thousands of stars within days; ~57k+ stars and ~7k+ forks by mid-July 2026), and is published on PyPI as mempalace (current line: v3.6.0, 17 Jul 2026). Primary job: give agents durable, searchable memory that stays on your machine by default—ChromaDB (or other backends) on disk, SQLite knowledge graph, zero API key required for ingest/search.

Install (recommended isolated CLI): uv tool install mempalace then mempalace init ~/projects/myapp, mempalace mine …, mempalace search "…", mempalace wake-up. Docker images support stdio MCP without a local Python toolchain.

Key features

• Verbatim storage — Chunks of original text land in drawers; the product philosophy is “store everything, never throw away words via LLM extractors.” Retrieval is semantic nearest-neighbor plus optional metadata filters, not a cloud memory SaaS.
• Palace hierarchy — Spatial metaphor: wings (people/projects), rooms (topics/sessions), halls (memory types such as facts/events/preferences), closets (compressed index pointers), drawers (verbatim content). Same room name across wings forms tunnels for cross-domain navigation.
• Pluggable backends — Default chroma (embedded). Also sqlite_exact, milvus, qdrant, pgvector via extras/env (MEMPALACE_BACKEND, URI/DSN vars). Contract lives in mempalace/backends/base.py.
• Local embeddings, no core API key — Onboarding offers models such as embeddinggemma-300m (multilingual, ~300 MB disk) or lighter English MiniLM-class models. Classification, chunking, and room heuristics are regex/keyword-driven so the memory layer can run offline.
• MCP server (dozens of tools) — Palace read/write, knowledge-graph ops, navigation, drawer management, agent diaries. Clients wire stdio (or Docker) MCP; status responses include a “know before speaking” protocol nudge for agents.
• Temporal knowledge graph — SQLite entity/triple store with valid_from / valid_to so facts can be invalidated and queried “as of” a date. Simpler than Graphiti/Neo4j stacks; local and free.
• Layered wake-up — Progressive context load (identity + high-importance drawers first, then scoped room recall, then full search). Marketing and reviews emphasize a very small startup token budget (~hundreds of tokens for L0+L1) so most of the model window stays free.
• Mining pipeline — mempalace mine for project trees and conversation exports (Claude Code JSONL under ~/.claude/projects/, Claude.ai/ChatGPT/Slack-style exports in supported modes). sweep adds per-message drawers idempotently.
• IDE/agent hooks — Auto-save hooks for Claude Code, Codex CLI, and Cursor (session-start recall, pre-compaction snapshots). Critical note from maintainers: Claude Code transcripts can expire (~30 days) if hooks are not wired—see retention checklist on the official docs.
• Specialist agents / diaries — Per-agent wings and diary entries so multi-agent setups do not dump everything into one bloated system prompt; list/discover via MCP tools.
• AAAK index dialect — Dense symbolic pointers for scanning (not a replacement for the verbatim drawer). Early marketing called it “30× lossless”; independent analysis and later project docs treat it as a compressed index layer with measurable retrieval trade-offs when used as the only surface.
• Reproducible benchmarks in-repo — Scripts and result files under benchmarks/; README publishes LongMemEval R@5 raw 96.6%, hybrid held-out 98.4%, optional LLM rerank ≥99%, plus LoCoMo / ConvoMem / MemBench numbers with methodology caveats.

Pricing

MemPalace is free open source (MIT). There is no vendor seat subscription, freemium cloud tier, or meter for the software itself. You pay only for:

Cost item	Typical amount	Notes
MemPalace software	$0	pip / uv / Docker; unlimited local use
Hardware / disk	Your machine	Vector DB + embedding model (~30–300+ MB models; palace grows with history)
Optional LLM rerank	API or local model cost	Only if you enable hybrid + LLM rerank paths; core raw path needs no key
Hosted alternatives (context)	Mem0-class ~$19–249/mo; Zep/Letta tiers vary	SaaS memory products charge when you want managed multi-tenant memory

Pricing model for VersusTools: open_source, starting_price = 0. There is no paid MemPalace Cloud product on the official channels as of v3.6.0. Optional third-party compute only appears if you point rerankers or agents at Claude/OpenAI/Ollama Cloud.

Limits & gotchas

• Headline benchmarks ≠ end-to-end agent IQ — LongMemEval R@5 raw 96.6% is retrieval recall on verbatim sessions with semantic search. Independent reviews (e.g. lhl’s ANALYSIS-mempalace, GitHub issues #27/#29/#39/#214) argue early marketing over-attributed that score to palace structure when raw mode is largely Chroma-class embedding retrieval. LoCoMo without aggressive top-k/rerank is much lower (README: 60.3% session R@10; hybrid v5 88.9%). Compare retrieval metrics to QA accuracy carefully.
• Early claims vs later honesty — Launch-era “100%” messaging and “lossless AAAK” language drew intense scrutiny. Current README de-emphasizes a flat “100%” claim (flags teaching-to-the-test on last fractions of a percent) and publishes held-out hybrid 98.4%. Prefer mid-2026 docs over April hype posts.
• Concurrency / production maturity — Community reports (discussion #904 and related issues) describe SQLite lock pain, Chroma instability under multi-writer MCP, and multi-project friction without a proper server backend. Treat single-user desktop as the sweet spot; multi-agent fleets need Qdrant/pgvector/Milvus and operational discipline.
• Impostor websites — Official caution: only GitHub, PyPI, mempalaceofficial.com. Do not download installers from random MemPalace landing clones.
• Star-count skepticism — Issues such as #705 discuss bot-farm / inflated-star concerns. Evaluate by issues velocity, releases, and your own repro—not star badges alone.
• Claude Code retention — Without auto-save hooks, session JSONL can disappear on a ~30-day horizon. Wire hooks + backfill with mine --mode convos.
• Cursor / language allowlists — r/cursor reports incomplete default allowlists (e.g. PHP projects) so “mine everything” may miss files until config is extended.
• Packaging footguns — Prefer uv tool install / pipx / venv; system Python PEP 668 blocks global pip. Some users hit “hooks not in wheel” or python3 -m mempalace path issues early on—check current package contents for your version.
• Security surface — Local privacy is strong (data stays on disk). Analyses still note limited write gating / sanitization on MCP add paths: any agent with MCP write can insert drawers (prompt-injection hygiene is your responsibility). Report vulns privately via GitHub Security advisories (3.x supported).
• No magic forgetting — Verbatim-first means growth and noise; you must design retention, invalidation (KG), and scoped search. Not a managed multi-tenant compliance product with SOC2 packets.
• Not a replacement for product memory SaaS — Mem0/Zep/Hindsight-style services offer hosted APIs, entity resolution pipelines, and scale benchmarks (e.g. BEAM-class long-horizon suites) that MemPalace does not claim to replace out of the box.

Community sentiment

Sentiment is polarized between viral excitement and benchmark hygiene.

Praise (LocalLLaMA, Claude Code threads, HN, blogs): free local memory; one-command mine of Claude/ChatGPT history; MCP integration; method-of-loci mental model; zero API cost on the write path; genuine usefulness as “Claude history search + temporal KG” even if the palace metaphor is partly UX sugar. HN commenters and issue #39 authors often say: useful product, not always the product the README sold on day one. Creators publicly acknowledged critiques and iterated (tagline softened; benchmarks docs expanded; v3.x features and backends landed quickly).

Criticism: overhyped launch metrics; AAAK “lossless” mislabeling; features described before fully implemented; star inflation questions; production multi-writer pain; Cursor allowlist gaps; “is this a celebrity PR stunt?” authenticity threads that mostly resolved toward “real OSS, still early.” Competitive blogs (Vectorize/Hindsight) emphasize that high R@k with dump-everything retrieval does not prove quality at multi-million-token histories.

By mid-2026 the project looks less like a 7-commit weekend demo and more like an active OSS product (1,500+ commits, frequent 3.x releases, Discord, dozens of MCP tools)—but community consensus remains: great for local agent memory experiments; validate retrieval on your transcripts before trusting marketing tables.

Who should use it

• Claude Code / Cursor / Codex power users who lose architecture decisions every new chat and want local, free continuity with hooks + MCP.
• Privacy-sensitive builders who refuse SaaS memory vendors and accept self-hosting Chroma/SQLite (or Qdrant/pgvector).
• Researchers and OSS tinkerers who want reproducible retrieval benches and a transparent Python codebase (MIT).
• Small multi-agent experiments that can give each specialist a wing/diary without bloating CLAUDE.md—still single-machine scale.
• Less ideal: enterprises needing managed SLAs, multi-tenant isolation, and vendor SOC2; teams wanting automatic semantic “fact extraction” quality without tuning; PHP/unusual stacks until allowlists/adapters are fixed; anyone installing from unofficial websites.

Alternatives

• LangChain / LlamaIndex — Build your own RAG memory with explicit control; more glue code, broader ecosystem.
• Claude Code / Claude Projects — Vendor-native project memory and instructions; less local control, simpler setup.
• Cursor — IDE-native rules/memories; MemPalace can complement via hooks but is not required.
• OpenAI Codex — Agent CLI with its own session model; MemPalace has Codex hooks if you want external palace memory.
• Ollama — Local models; pair with MemPalace when you want open weights and durable memory offline.
• OpenClaw — Agent stack with its own memory debates; community often compares reliability of built-in memory vs external layers.
• Mem0 / Zep / Letta / Hindsight / Supermemory — Managed or heavier agent-memory products with different pricing and extraction philosophies (summarize vs graph vs hybrid). Choose when you need hosted APIs or production multi-tenant memory rather than a local palace.

Verdict

MemPalace is a free, local, verbatim-first AI memory toolkit—strong for developers who live in Claude Code/Cursor and want searchable history without a SaaS bill. The palace metaphor and MCP surface are distinctive; the honest mid-2026 README numbers (96.6% LongMemEval R@5 raw, 98.4% hybrid held-out) are better framed as “excellent offline retrieval with reproducible scripts” than “solved long-term agent cognition forever.”

Use it if local privacy and zero software cost dominate. Wire hooks early, install only from official channels, scope search by wing/room, and plan a real backend if multiple writers share a palace. Prefer hosted memory platforms when you need multi-tenant production guarantees, polished entity resolution, and vendor-backed scale benchmarks. Treat April 2026 hype posts as history; evaluate current v3.6 docs, issues, and a mine of your chat logs before committing a team workflow.