Released by Zilliz, the company behind the Milvus vector database, memsearch is a memory layer for AI coding agents. It automatically records your conversations with an agent and brings back only the relevant parts in later sessions. The memories themselves are plain Markdown files — human-readable, directly editable, and version-controllable with Git. The search index lives in Milvus, but Markdown always remains the source of truth, so the index can be rebuilt at any time if it breaks. memsearch installs as a plugin for Claude Code, Codex CLI, OpenClaw, OpenCode, and DeepSeek Harness, and sharing a single Milvus backend lets memories travel across tools. It is open source under the MIT license and has gathered more than 2,500 stars on GitHub.
Key Features
- Markdown is primary, the vector index is secondary: Memories are stored as
.mdfiles. You can inspect them, rewrite them in an editor, and see them in Git diffs. The Milvus index is treated as a regenerable “shadow” of the Markdown, so losing the index never means losing the memories - Hybrid search (dense vectors + BM25 + RRF): Dense vector search for semantic similarity is combined with BM25 for keyword matching, and the two result sets are merged with RRF (Reciprocal Rank Fusion). This catches both “different wording, same meaning” and pinpoint matches on proper nouns, so fewer relevant memories slip through than with either method alone
- SHA-256 deduplication: Chunks are identified by a hash of their content, so unchanged text is never re-embedded. The first indexing pass takes time, but subsequent re-indexing is nearly instant — and embedding API costs stay down
- Automatic re-sync via file watching: A file watcher detects Markdown changes, updates the index, and removes stale chunks for content that no longer exists. There is no manual “save” or “re-index” step
- LLM-powered memory compaction: Older memories are summarized and consolidated by an LLM. This keeps a memory store that would otherwise grow without limit at a density that search can still work with
- Progressive disclosure: A search returns summaries first, then lets the agent expand to the full section, and finally drill into the original transcript. This three-layer approach avoids filling the agent’s context window unnecessarily
- Memory sharing across agents: Supports Claude Code, Codex CLI, OpenClaw, OpenCode, and DeepSeek Harness. The Markdown format is shared and collection names are derived from the project directory, so opening the same project in a different agent carries the memories over
Pricing
| Plan | Price | Highlights |
|---|---|---|
| memsearch itself | Free (MIT license) | All features. Installed via uv tool install memsearch and similar |
| Embeddings (ONNX, local) | Free | bge-m3 running locally on CPU by default. Nothing is sent to an external API |
| Embeddings (OpenAI / Google / Voyage / Jina / Mistral, etc.) | Each provider’s usage-based pricing | Options when accuracy or speed matter more |
| Milvus Lite (local) | Free | The default backend, aimed at single-user setups |
| Milvus Server (self-hosted / Docker) | Free (you cover server costs) | For sharing across multiple agents |
| Zilliz Cloud | See the official site | Managed operation for production use |
Pricing information is current as of August 2026. memsearch itself is free and open source, but embedding providers and managed backends carry their own separate costs. Check the official site for the latest details.
Pros & Cons
✅ Pros
- Because memories are Markdown, nothing is a black box. You can see exactly what is being remembered and delete what you do not want by hand
- The default setup (ONNX + Milvus Lite) needs no external API key and no cloud contract — it runs entirely locally, which makes it viable in environments where code cannot leave the building
- Combining dense vectors with BM25 handles both vague phrasing and exact proper-noun matches well
- SHA-256 deduplication makes re-indexing fast and keeps embedding costs from piling up
- Memories can be shared even when you use several agents side by side
- MIT-licensed open source, so vendor lock-in is a minor concern
⚠️ Cons
- It assumes a CLI and plugins; there is no GUI. Setup means installing via
uvorpipand choosing a backend - Milvus Lite ships no Windows binaries, so Windows users must pick Docker, WSL2, or Zilliz Cloud
- The initial indexing pass is slow (later passes are fast)
- Switching embedding providers mid-stream causes a vector dimension mismatch and requires rebuilding the index
- Plugin maturity varies by agent, with the Claude Code integration being the most polished
- Releases come frequently and features are still moving, so pinning a version is worth considering before building it into a workflow
Comparison with Similar Services
| Criteria | memsearch | Mem0 | Letta (formerly MemGPT) | Built-in agent memory |
|---|---|---|---|---|
| Provider | Zilliz | Mem0 | Letta | Each agent’s vendor |
| Memory storage | Markdown files | Proprietary store (managed / OSS) | Held as agent state | Config files / proprietary format |
| Search method | Dense vectors + BM25 + RRF | Primarily vector search | The agent manages its own memory | Mostly full-text or simple lookup |
| Main target | Long-term memory for coding agents | Memory API for apps and agents generally | Building autonomous agents with memory | Config and context within one tool |
| Cross-tool | Yes (shared Milvus) | Yes (via API) | Depends on your build | Generally not possible |
| Fully local | Possible (ONNX + Milvus Lite) | Possible in a self-hosted setup | Possible | Possible |
| License | MIT | OSS edition available | OSS edition available | Follows the tool |
Who Is It For
- People who use Claude Code or Codex CLI daily and are tired of re-explaining decisions made in the previous session
- Developers who switch between several coding agents and do not want memory fragmented per tool
- Anyone who wants to see and audit what an AI is remembering — Markdown means it can be reviewed and tracked in Git
- Developers in environments where code and conversations cannot leave the network, looking for a fully local memory layer
- Teams already running Milvus or Zilliz Cloud who want to reuse their existing vector infrastructure
Summary
memsearch is built on a consistent idea: an AI agent’s memory should be readable Markdown files, not something invisible inside a dedicated database. The vector index is strictly a subordinate artifact that exists to make search fast and can be rebuilt whenever needed. That trade-off is what lets people inspect, edit, and version-control what an agent remembers, and it keeps those memories as an asset even when you switch tools.
The flip side is a nontrivial setup: a CLI-first workflow and constraints on Windows. A realistic path is to start with the default configuration (ONNX + Milvus Lite) on a single project, confirm that recalled memories genuinely make the work easier, and only then expand to a shared backend or managed operation.