# MemPalace: verbatim drawers, a Rust CLI, and a 300 MB first search

> MemPalace stores conversation history verbatim and retrieves it with semantic search, with no summarization step and a pluggable backend that defaults to ChromaDB. It ships as a Python package and a Rust workspace on one version number, and the first search that needs embeddings pulls 80 MB or 300 MB into a volume before it answers anything.

**MemPalace/mempalace** — The best-benchmarked open-source AI memory system. And it's free.

- Repository: https://github.com/MemPalace/mempalace
- Website: http://mempalaceofficial.com/
- Stars: 59,278 · Forks: 7,565
- Language: Python
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/mempalace-mempalace

## The index is wings, rooms and drawers rather than a flat corpus

MemPalace stores conversation history as verbatim text and retrieves it with semantic search. What it does not do is summarize, extract or paraphrase, and the README is explicit about that, which is the whole design argument in one sentence. The index is structured instead: people and projects become wings, topics become rooms, and the original content lives in drawers, so a search can be scoped to a wing or a room rather than run against everything ever said to the assistant. The retrieval layer is pluggable, with the interface defined in mempalace/backends/base.py and ChromaDB as the current default, and alternative backends are meant to drop in without touching the rest. The stated guarantee is that nothing leaves your machine unless you opt in. Two consequences follow. Scoping only works if the mining step filed things correctly, and the quality number rides on the default backend rather than on the interface.

## A Rust workspace and a Python package carry the same version string

The primary language says Python, and the tree says more than that. Cargo.toml declares a workspace with three members, crates/mempalace-core, crates/mempalace-py and crates/mempalace-cli, and it pins the workspace version at 3.10.0, which is the same number pyproject.toml declares for the Python distribution. The release profile is aggressive: opt-level 3, lto enabled, codegen-units set to 1, panic set to abort and strip enabled. That combination produces a small, fast binary that aborts instead of unwinding, so an embedding failure terminates the process rather than being caught higher up the stack. The practical consequence is that you now maintain two toolchains for one tool, and the CLI you run is the Rust one. There is also a Dockerfile and a Dockerfile.gpu, a docker-compose.yml, a docker-entrypoint.sh and a deploy directory, so the same artefact has a container form and a team server form.

## uv, pipx or pip, and setup records which one you used

The recommended install puts the CLI in an isolated environment, for two stated reasons: it avoids PEP 668 errors on Debian, Ubuntu and Homebrew Pythons, and it keeps the dependencies, named as chromadb, numpy and grpcio among them, from colliding with anything else in your global site-packages.

```bash
uv tool install mempalace
mempalace init ~/projects/myapp
```

pipx is offered as the equivalent alternative with pipx install mempalace, and plain pip is advised only inside a virtual environment you activated on purpose, where the sequence is python -m venv .venv, source .venv/bin/activate, then pip install mempalace. There is an agent-guided path too, npx skills add MemPalace/mempalace, which installs one of three skills: mempalace for guided installation and operations, mempalace-recall for search-before-answer recall, and mempalace-task for logstream delegation. Installing a skill does not install the CLI or the MCP server. What setup records afterwards is which of uv tool, pipx or pip produced the runtime, so a later upgrade plan never proposes the wrong command.

## The first search that needs embeddings downloads 80 MB or 300 MB

The first command requiring embeddings fetches a model into the data directory, and the README gives both numbers: roughly 80 MB for the default minilm and roughly 300 MB for embeddinggemma. It is a one-off as long as the volume persists, but it does mean the first call is slow and needs network, which is worth knowing before assuming a hung container. The dependency manifest explains why the heavy model is not optional. A comment in pyproject.toml records that onboarding now offers embeddinggemma-300m as an ONNX model for new installs, so huggingface_hub and tokenizers are required core dependencies rather than optional extras, and that users who pick minilm during onboarding still get them installed and unused, a small wheel-size cost traded for one fewer pip command in the multilingual path. So an air-gapped machine is out, and a first run that looks hung is usually this download.

## Linux bind mounts fail at uid 1000 with a bare PermissionError

The container runs as uid 1000, bind mounts keep their host ownership, and a mounted directory therefore has to be readable by that uid. An ordinary 0755 checkout is fine and a 0700 directory is not, and the failure surfaces as PermissionError: [Errno 13] rather than as anything about Docker. Docker Desktop maps uids on macOS and Windows, so this only bites on Linux. The README is explicit that the workaround does not work either: do not reach for the user flag, because /data is owned by uid 1000 inside the image and another uid cannot write the palace at all. The compose file carries a second container trap of the same kind. A bare environment block with nothing but comments parses as null, and Compose then rejects the whole file with services.mcp.environment must be a mapping. Keys such as MEMPALACE_EMBEDDING_MODEL and MEMPALACE_PALACE_PATH exist, they just have to be uncommented together with a value.

## No native Termux path, and Claude Code sessions expire in 30 days

Two situations in the README are outright refusals, and both matter for planning. The first is Android. Native Termux installation is not supported because compiled dependencies such as ChromaDB and ONNX Runtime publish Linux wheels and not Android wheels; Android ARM64 users are pointed at an isolated Debian PRoot container instead, with a Termux guide and an argv-preserving launcher. The second is Claude Code, where a note at the top of the README says sessions expire in 30 days without auto-save hooks wired, with a discussion thread and a retention setup checklist linked. The MCP integration is otherwise a stdio server over JSON-RPC, and the README insists the container be run with the -i flag because stdin has to stay open, and that paths become container paths from that point on, so you mine /transcripts rather than a home directory path. It also warns that ~ and $HOME are not expanded by every MCP client, so a real absolute path is required.

## Three official sources, and everything else is called an impostor

The README opens with a caution block that is unusual to see in a project of this size. It names the only official sources as this GitHub repository, the PyPI package, and the documentation at mempalaceofficial.com, and states that any other domain, including .tech, .net and other .com variants, is an impostor that may distribute malware, with the timeline in docs/HISTORY.md. Given that the installation instructions involve running an agent and a container, that is a supply chain warning worth taking at face value. The same restraint shows up in the update story: guided setup can offer weekly stable-release checks, but they are disabled by default, contact only PyPI when enabled, and never install updates automatically, with availability cached in scoped status fields so the agent can explain a release and ask before showing an upgrade plan. For anyone auditing this, the plugin directories at the root, .claude-plugin, .codex-plugin, .cursor-plugin, .antigravity-plugin and .dsh-plugin, are the surface to look at.

## Conclusion

Adopt MemPalace if you want an agent's history kept verbatim on your own disk and searchable by meaning, and if you can accept that the retrieval quality claim, 96.6 percent R at 5 on LongMemEval with zero API calls, is the project's own number rather than one you have measured. Skip it on Android without a Debian PRoot container, since ChromaDB and ONNX Runtime ship Linux wheels and not Android wheels. Verify four things before you build anything on it. Which install method you used, because setup records whether the runtime came from uv tool, pipx or pip and an upgrade plan is generated from that record. Which embedding model you chose, since embeddinggemma is the default for new installs and minilm is the 80 MB option. That your mounted directory is readable by uid 1000 on Linux. And that you are on the GitHub repository or the PyPI package, since the project states plainly that any other domain is an impostor.

## FAQ

### What is MemPalace?

It is a local-first AI memory system that stores conversation history verbatim and retrieves it with semantic search, without summarizing or paraphrasing. Content is filed into wings, rooms and drawers, and the retrieval backend is pluggable through mempalace/backends/base.py with ChromaDB as the default.

### How do I install MemPalace?

The recommended route is uv tool install mempalace, then mempalace init with a project path. pipx install mempalace works the same way, and plain pip is suggested only inside a virtual environment you activated yourself.

### How do I use MemPalace with Claude Code?

Run it as an MCP stdio server over JSON-RPC, with the -i flag so stdin stays open, and mount your project transcripts directory read-only at a container path such as /transcripts, using a real absolute path since ~ and $HOME are not always expanded. The README also warns that Claude Code sessions expire in 30 days unless auto-save hooks are wired.

### Does MemPalace actually work?

The project reports 96.6 percent R at 5 raw on LongMemEval with zero API calls, and that is its own figure rather than an independent measurement. A benchmarks directory sits at the repository root, and the default retrieval backend is ChromaDB, which is where that number was produced.

### Is MemPalace safe to install?

Storage is local and verbatim, and the project states that nothing leaves your machine unless you opt in. It also warns that only the GitHub repository, the PyPI package and mempalaceofficial.com are official, and that any other domain may distribute malware.

### Did Milla Jovovich create an AI memory tool?

The project metadata lists a single author named milla-jovovich in pyproject.toml, and the repository says nothing further about that name. The README names the GitHub repository, the PyPI package and mempalaceofficial.com as the only official sources.

## Sources

- [Official documentation](http://mempalaceofficial.com/)
- [Official README](https://github.com/MemPalace/mempalace#readme)
- [Project repository](https://github.com/MemPalace/mempalace)
- [Release notes](https://github.com/MemPalace/mempalace/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mempalace-mempalace