MemoMind Memory Layer
A self-hosted, cross-session memory system for coding agents.
Per-dimension scores and reasoning
Evidence: README claims 100% local, no cloud dependency, but no code audit or data flow diagram provided. Installation steps require manual editing of serve.py to set API keys, no mention of least privilege or user confirmation. Auto-import and full-disk scanning features may involve sensitive data, but no data protection measures described. Dependencies not pinned, supply chain risk. External effects include auto-start services, backup to GitHub, but no rollback or undo mechanism. Source attribution: README mentions MseeP verification but no details. Deductions: lack of evidence for least privilege, user confirmation, data flow transparency, sensitive data handling; dependency security not addressed; external effects and rollback only partially mentioned.
Evidence: README description is consistent with code structure, but no tests or runtime verification. Dependencies like PostgreSQL, pgvector, CUDA not version-pinned or availability guaranteed. Failure messages: health check endpoint exists, but no error handling details. Deductions: self-consistency based only on README, not verified; dependency availability not guaranteed; failure messages insufficient.
Evidence: README clearly targets Claude Code users, provides multiple integration options (MCP, SDK, REST), and supports multiple LLM providers. Capability boundaries: describes retain/recall/reflect operations, but no limitations or failure scenarios. Trigger precision: MCP tool definitions not provided, but README describes automatic invocation. Environment fit: supports Windows, Linux, WSL2, but not full macOS. Deductions: capability boundaries and trigger precision lack detail; environment fit not comprehensive.
Evidence: README well-structured with quick start, architecture, use cases. Installation instructions detailed but many manual steps. Naming stability: project name and core operations consistent, but no version history. Examples and FAQ: code examples and comparison tables provided, but no FAQ. Known limitations: not explicitly listed. License: README shows MIT badge, but no LICENSE file content. Versioning: no CHANGELOG. Maintenance responsibility: no maintainers or contribution guidelines. Deductions: missing known limitations, versioning, maintenance responsibility; license only badge.
Evidence: Output usability: REST API and Python SDK provide structured output. Marginal value: compared to built-in CLAUDE.md, offers automatic extraction, knowledge graph. Cost-benefit: claims daily LLM cost < $0.01, but no detailed calculation. Deductions: cost-benefit unverified; marginal value based on claims not independent testing.
Evidence: Performance data (e.g., retrieval times) in README lack test methodology or source. Cross-source corroboration: none. Fact-inference separation: README distinguishes feature descriptions from performance claims, but no evidence. Deductions: claims lack traceability; no cross-source verification; fact-inference separation insufficient.
- Dependencies are not pinned, posing supply chain risks.
- Auto-import and full-disk scanning may involve sensitive data without clear protection measures.
- Installation is complex with many manual steps, prone to errors.
- Performance claims lack verifiable testing methodology.
What does this agent do, and when should you use it?
MemoMind is a local persistent-memory system for AI coding agents built around retain, recall, and reflect. It stores extracted facts, entities, tags, relationships, and temporal information in PostgreSQL, pgvector, and a knowledge graph, then retrieves memory through four search paths. The project exposes a stdio MCP integration for Claude Code, a HindsightClient Python SDK, REST endpoints, and a web dashboard. Its database and embedding models run locally, while fact extraction can be configured for OpenAI, Anthropic, Gemini, Groq, Ollama, LM Studio, or OpenAI-compatible services. It also imports ChatGPT and Gemini histories plus DayLife activity data, and exports memory and graph data as JSON.
Claude Code can call retain, recall, and reflect through the stdio MCP server in mcp_stdio.py. retain extracts facts from new context and writes them to a selected memory bank; recall combines semantic similarity, BM25 keyword search, knowledge-graph search, and temporal search; reflect synthesizes across stored memories. MemoMind uses bge-m3 for 1024-dimensional embeddings and can use an NVIDIA GPU for embedding and reranking, while dashboard.py provides visual browsing, filtering, search, and graph inspection. It can import ChatGPT/Gemini conversations and DayLife events, then export memories and graph data through the dashboard or backup-memomind.py.
- A Claude Code user who wants a new coding session to retrieve prior architectural decisions, naming conventions, and stack choices.
- An engineer maintaining a long-lived codebase who needs to retain past debugging attempts, outcomes, and review-feedback patterns.
- A consultant handling multiple clients or projects who needs separate memory banks for isolated contexts.
- A user with substantial ChatGPT or Gemini history who wants extracted facts in one knowledge graph with links back to original conversations.
- A DayLife user who wants personal activity events synchronized into a searchable timeline for AI analysis.
What are this agent's strengths and limitations?
- Stores structured memory in PostgreSQL, pgvector, and a knowledge graph instead of relying solely on static Markdown rule files.
- Separates writing, four-path retrieval, and cross-memory synthesis through
retain,recall, andreflect. - Offers Claude Code stdio MCP, a Python SDK, REST API, and a dashboard for integration and human review.
- Uses multilingual bge-m3 embeddings with optional local GPU acceleration and exports memories, entities, and relationships as JSON.
- Supports memory-bank isolation by user or project and imports data from ChatGPT, Gemini, and DayLife.
- Setup is not one-command: it requires Python, PostgreSQL 17, pgvector, and an LLM provider; native Windows also requires Visual Studio Build Tools.
- Storage and embeddings can stay local, but
retainperforms LLM-based fact extraction; unless using a local option such as Ollama, data handling and cost depend on the chosen API. - Each open Claude Code MCP session loads an embedding model; the documented MCP-process memory use is about 1.5GB.
- The installation instructions focus on Windows, WSL2, and Linux; macOS appears in prerequisites but has no complete native setup procedure.
- The health-check setup uses port 19999, while the Python SDK and REST examples use 8888, so adopters need to verify their deployed configuration.
How do you install or deploy this agent?
The documented Linux/WSL2 path is:
git clone https://github.com/24kchengYe/MemoMind.git
cd MemoMind
sudo bash install.shThen edit /opt/memomind-env/serve.py and set LLM_API_KEY, LLM_BASE_URL, and LLM_MODEL; for an OpenAI-compatible service, one documented example is LLM_BASE_URL = "https://openrouter.ai/api/v1". Start the service with:
sudo systemctl start memomindVerify it with:
curl http://localhost:19999/healthThe expected response is JSON containing "status":"healthy" and "database":"connected". Native Windows setup additionally requires Python 3.11+, Visual Studio Build Tools, PostgreSQL 17, and pgvector compiled from source.
How do you use this agent?
Register the service with Claude Code:
claude mcp add --scope user --transport stdio memomind -- /opt/memomind-env/bin/python3 /opt/memomind-env/mcp_stdio.pyAlternatively, install the Python client:
pip install hindsight-clientThen call:
from hindsight_client import HindsightClient
client = HindsightClient(base_url="http://localhost:8888")
client.retain("default", "User prefers FastAPI over Express for new projects")
results = client.recall("default", "What framework should I use?")
insight = client.reflect("default", "What patterns do you see in my tech choices?")Create an isolated bank with client.create_bank("user-alice", name="Alice's Memories").
How does this agent compare with similar options?
Against Claude Code's CLAUDE.md and MEMORY.md, MemoMind is positioned for changing facts, entity relationships, and on-demand recall, while static project rules can remain in project files. The repository also names Mem0, Graphiti/Zep, Letta, Cognee, Hindsight, and MemOS as alternatives, but it does not provide a migration procedure from them or MemoMind benchmark results.
FAQ
Does it require a cloud LLM?
Can I run it without an NVIDIA GPU?
Can it serve as a direct ChatGPT memory plugin?
How are memories backed up or moved?
backup-memomind.py supports automated backup. The documented export includes memories, entities, tags, temporal data, and graph nodes and edges.