RAG Frameworks · zilliztech

memsearch

Memsearch is a persistent memory layer for AI agents that automatically captures conversations and makes them searchable across multiple platforms (Claude Code, OpenClaw, OpenCode, Codex CLI). It stores memories as Markdown files indexed by Milvus, supporting hybrid search with vector embeddings and BM25 full-text search.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/zilliztech/memsearch

2.2k

GitHub stars

193

Forks

Python

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	zilliztech/memsearch
Owner	zilliztech
Primary language	Python
License	MIT — OSI-approved
Stars	2.2k
Forks	193
Open issues	222
Latest release	v0.4.12 (2026-06-30)
Last updated	2026-06-30
Source	https://github.com/zilliztech/memsearch

What memsearch is

Python-based agent memory system using Markdown as source-of-truth and Milvus as a shadow vector index. Provides 3-layer retrieval (search → expand → transcript), hybrid search via dense vectors + BM25 + RRF reranking, SHA-256 content deduplication, and real-time file watching. Defaults to local ONNX embeddings (bge-m3) with optional OpenAI or Ollama providers.

Quickstart

Get the memsearch source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/zilliztech/memsearch.git2cd memsearch3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Multi-agent memory continuity

Seamlessly share conversation context across Claude Code, OpenClaw, OpenCode, and Codex CLI—memories captured in one agent become searchable in all others without manual sync.

Long-context RAG for coding agents

Maintain searchable project history, decision logs, and task transcripts across sessions; hybrid search (semantic + keyword) helps agents retrieve relevant prior discussions and avoid repeating work.

Local, cost-effective embedding pipeline

Use included ONNX bge-m3 model (~558 MB, CPU-based) for offline embeddings with zero API cost, or opt into OpenAI/Ollama for higher-quality representations.

Implementation considerations

Default ONNX embedding (~558 MB) downloads on first run from HuggingFace Hub; ensure network access and disk space. API key required only if switching to OpenAI provider.
Markdown files are the source-of-truth; Milvus index is a rebuilable cache. Ensure version control or backup strategy for `.memsearch/memory/` directory to avoid data loss.
Each agent platform (Claude Code, OpenClaw, OpenCode, Codex) has its own plugin; installation steps vary. Review platform-specific docs and ensure hook permissions are correctly configured (e.g., OpenClaw requires `allowConversationAccess` and `allowPromptInjection`).
Memory files are stored locally in workspace directories (e.g., `.memsearch/memory/`); sensitive information in conversations will be persisted. Implement access controls at the filesystem level if needed.
Background maintenance tasks (durable `PROJECT.md` and `USER.md` updates) and skill distillation are optional features; behavior and overhead depend on configuration.

When to avoid it — and what to weigh

Standalone semantic search engine — Memsearch is purpose-built for AI agents; if you need a general-purpose vector database or search platform, use Milvus/Weaviate/Pinecone directly.
Multi-user, shared team memory — Designed for per-agent or per-user memory isolation; no built-in multi-tenant access controls or role-based memory sharing. Each agent workspace maintains its own `.memsearch/` directory.
Strict regulatory compliance (healthcare, finance) — Project is actively developed but relatively young (created Feb 2026); security audit status, data residency controls, and regulatory certifications are unknown—requires review before PHI/PCI use.
Real-time sub-second retrieval at scale — Default Milvus Lite runs on single machine; while hybrid search is implemented, large-scale concurrent retrieval performance is unknown. Zilliz Cloud deployment may help but requires external dependency.

License & commercial use

Licensed under MIT (permissive OSI license). Allows commercial use, modification, and distribution with attribution. No restrictions on proprietary derivatives or closed-source products using the library.

MIT license explicitly permits commercial use. No commercial licensing, enterprise support tier, or restrictive clauses detected in the provided data. However, deployment on Zilliz Cloud (recommended backend) is a managed service with separate commercial terms; review Zilliz's pricing and SLA before production use.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Good
Assessment confidence	High

Security considerations

Conversations are stored as Markdown files in `.memsearch/memory/` with no built-in encryption-at-rest or access controls; filesystem permissions are the primary safeguard. Network traffic to embedding providers (OpenAI) or Zilliz Cloud should be assumed unencrypted unless TLS is verified. SHA-256 deduplication is used internally but does not provide confidentiality. No mention of audit logging, key rotation, or compliance frameworks. Project's security posture has not been independently assessed; requires vendor security review before handling sensitive data.

Alternatives to consider

Langchain Memory (ConversationBufferMemory, etc.)

Lower-level Python abstractions for agent memory; less specialized for cross-platform agents, but simpler integration if building custom agents. No unified Markdown storage or multi-agent sync.

Zilliz Cloud + custom indexing

Use Milvus/Zilliz directly without the memsearch wrapper for maximum flexibility and control. Requires more integration effort but avoids vendor lock-in to memsearch plugin ecosystem.

OpenClaw's native memory system

If only using OpenClaw, its native memory and plugin system may suffice. Memsearch adds cross-platform unification and automation but adds complexity if single-agent context is sufficient.

Software development agency

Build on memsearch with DEV.co software developers

Install memsearch for your platform (Claude Code, OpenClaw, OpenCode, Codex CLI) or use the Python API to integrate with custom agents. Start with free ONNX embeddings—no API keys required.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

memvid memanto claude-mem

Related on DEV.co

Explore the category and the services that help you build with it.

RAG Frameworks AI application development Custom software development Talk to DEV.co

memsearch FAQ

Does memsearch require internet access or API keys?

No for basic use: default ONNX bge-m3 embedding runs locally on CPU and downloads the model (~558 MB) from HuggingFace Hub once. Zilliz Cloud deployment requires network access, but Milvus Lite (default) is fully offline after model download. API keys only needed if you explicitly switch to OpenAI embeddings.

Can I use memsearch with my own AI agent (not Claude Code, OpenClaw, etc.)?

Yes: memsearch provides a full CLI and Python API for custom integration. The plugin ecosystem covers four platforms, but the underlying library is agent-agnostic. Requires custom hook/integration code.

Where is my conversation history stored?

As Markdown files in `.memsearch/memory/` (daily files by default). This directory is local to your agent's workspace. Milvus maintains a searchable index of the same content; both can be backed up or version-controlled independently.

What happens if I delete the `.memsearch/` directory?

Memories are lost, but Markdown files can be recovered from version control if they were committed. The Milvus index is rebuilable from the Markdown source; memsearch can re-index if needed. No automatic backup is mentioned.

Software developers & web developers for hire

From first prototype to production, DEV.co delivers software development services around tools like memsearch. Our software development agency staffs experienced software developers and web developers for custom software development, web development, integrations, and ongoing support across rag frameworks and beyond.

Ready to add persistent memory to your AI agents?

Install memsearch for your platform (Claude Code, OpenClaw, OpenCode, Codex CLI) or use the Python API to integrate with custom agents. Start with free ONNX embeddings—no API keys required.

Talk to DEV.co Schedule a Consultation