24kchengYe/MemoMind

Give your AI agent a brain that remembers. Local memory system for Claude Code — 100% private, GPU-accelerated, zero cloud dependency.

🧠 MemoMind – Local, GPU‑accelerated memory for AI coding agents

What it is – MemoMind is a self‑hosted system that gives an LLM‑based coding assistant a persistent, structured “brain”. It stores everything the assistant learns (preferences, decisions, conversation facts, daily life events) in a PostgreSQL database enriched with pgvector embeddings and a knowledge‑graph layer. The agent can then retain new facts, recall the most relevant ones with a 4‑way hybrid search (semantic, BM25, graph, temporal), and reflect across all memories to synthesize insights.

Why it matters – Most current LLM tools treat each chat as a fresh slate. MemoMind keeps the context alive across sessions, across different providers (ChatGPT, Gemini, Claude), and even across unrelated data sources (your DayLife planner). All data stays 100 % local, runs on your own GPU for fast embedding, and never leaves the machine, addressing privacy and cost concerns.

Core Features (as described in the README)

  • Local storage – PostgreSQL + pgvector, no cloud dependency.
  • GPU‑accelerated embeddings – uses the bge‑m3 model (1024‑dim) on an NVIDIA GPU; ~50 ms per item.
  • 4‑way hybrid retrieval – combines semantic similarity, BM25 keyword search, graph‑based entity linking, and temporal filters (keyword ~20 ms, semantic ~400 ms).
  • Automatic fact extraction – a lightweight LLM extracts structured facts from every imported conversation.
  • Reflect operation – a stronger LLM can reason over the whole knowledge base, not just retrieve.
  • Multilingual support – embeddings cover 100+ languages.
  • Companion import tools – one‑click import of ChatGPT, Gemini, and DayLife activity logs; each memory links back to its source conversation.
  • Web dashboard – visual browsing of the knowledge graph, timeline view, filters, and JSON export.
  • Zero‑manual effort – the agent decides what to retain and when to recall; users only need to run the service.
  • Cross‑provider compatibility – works with OpenAI, Anthropic, Gemini, Groq, Ollama, LM Studio, or any OpenAI‑compatible API.
  • Backup & export – one‑click JSON dump and optional weekly push to a private GitHub repo.

Typical Use Cases

Use case How MemoMind helps
Coding assistant Remembers your preferred language, style, tech‑stack decisions, and past debugging attempts, so the next session starts with the right context.
Project management Stores decisions, deadlines, and blockers as structured memories; the agent can surface risks by reflecting on past events.
Debugging Retrieves “what we tried before” without you re‑typing the whole history.
Team onboarding New members’ agents inherit the accumulated knowledge graph instantly.
Personal life‑assistant DayLife events become searchable facts, letting the AI answer “When did I last run a marathon?” or “What habit am I most consistent with?”

Architecture Overview (textual summary)

  1. Database layer – PostgreSQL 17 with the vector extension (pgvector). Stores raw memories, embeddings, and graph relationships.
  2. Embedding & reranking – bge‑m3 runs on the local NVIDIA GPU (CUDA 12.4). Generates 1024‑dim vectors for each memory.
  3. LLM layer – Two models are used:
    • A fast, cheap model for extracting facts from new conversations.
    • A stronger model (configurable) for the reflect operation.
  4. MCP (Model Context Protocol) interface – Exposes three RPC‑style calls (retain, recall, reflect) that coding agents (e.g., Claude Code) can invoke via stdio.
  5. Dashboard – A lightweight Python‑based web UI (dashboard.py) that visualises the knowledge graph, timeline, and provides search/filter tools.
  6. Import pipelines – Small Python scripts (import_daylife.py, exporters for ChatGPT/Gemini) that ingest external data, run the extraction LLM, and write to the DB.

Quick‑Start Summary (Windows & Linux/WSL2)

  • Prerequisites: NVIDIA GPU (optional but recommended), Python 3.11+, PostgreSQL 17, an OpenAI‑compatible API key.
  • Installation:
    1. git clone https://github.com/24kchengYe/MemoMind.git
    2. Create a virtual environment and install the provided requirements (or run install.sh on Linux).
    3. Install PostgreSQL and the pgvector extension, then create a database and enable the vector extension.
    4. Edit serve.py to add your LLM API key, base URL, and model name.
    5. Run python serve.py (API at http://localhost:19999) and pythonw dashboard.py (UI at http://localhost:9999).
  • MCP registration – Use the claude mcp add … command shown in the README to bind the service to Claude Code (or any MCP‑compatible agent).
  • Auto‑start – Windows users can place start‑memomind.vbs in the Startup folder; Linux users can enable the memomind.service systemd unit.

How it differs from similar projects

Feature MemoMind Mem0 Graphiti/Zep Letta
Local only Yes (100 % on‑device) Cloud‑first (local tier paid) Cloud/BYOC Optional self‑host
GPU‑accelerated embeddings Yes (CUDA) No No No
Hybrid 4‑way retrieval Semantic + BM25 + graph + temporal Semantic + vector only Semantic + graph Agent‑driven
Knowledge‑graph built‑in pgvector‑based KG Pro feature ($) Neo4j core No
Temporal reasoning Native No Bi‑temporal No
Cost <$0.30 /mo (local compute) Free‑to‑$249/mo Free‑to‑$475/mo Free‑to‑$200/mo

MemoMind is positioned for developers who already use MCP‑based coding agents (e.g., Claude Code) and want a deep, locally‑hosted memory store with fast GPU‑backed retrieval.

License & Community

  • License: MIT (see LICENSE).
  • Verification badge: “MseeP Verified” – indicates the project passed an external AI‑tooling audit.
  • Platform support: Windows, Linux, WSL2.
  • Documentation: README includes detailed install steps, architecture diagrams, and a demo dashboard.

Bottom line

MemoMind is a genuine, production‑grade open‑source system that tackles the amnesia problem of LLM‑based coding assistants. By persisting facts in a vector‑enabled PostgreSQL knowledge graph and providing fast, GPU‑accelerated retrieval, it lets an AI agent continue a conversation—or a coding project—exactly where it left off, all while keeping the data private and inexpensive to run.

Related

  • Project
    openmemind/memind

    An open-source, self-evolving memory and context engine for AI agents that turns raw interactions into structured memory graphs and insight trees for long-term recall.

  • Project
    oleksiijko/pmb

    PMB is an open‑source Python library that gives LLM‑based coding assistants a local, SQLite‑backed memory. It automatically indexes code, PDFs, git history, and user‑recorded facts, then injects the most relevant pieces back into the agent via the Model‑Context‑Protocol. The system works offline, offers a hybrid BM25‑+‑vector search (≈35 ms warm latency), provides a visual dashboard, and includes hooks that both recall memory before the model thinks and auto‑write observed actions. Install with `pip install pmb-ai`, run `pmb setup` to wire an agent, and the agent will remember decisions, lessons, and project context across restarts without any API keys or cloud calls.

  • Project
    mnemon-dev/mnemon

    A persistent, cross-session memory system for AI agents that uses the host LLM as a supervisor to manage a four-graph knowledge store.

  • Dispatch
    ScreenMind: Local AI Screen Memory Powered by Gemma 4

    ScreenMind is an open-source, privacy-first alternative to Microsoft Recall that uses Gemma 4 E2B to locally capture, analyze, and search screen history on GPUs with as little as 4GB VRAM.

  • Project
    memgraph/memgraph

    Memgraph is an in‑memory graph database (C/C++) that combines sub‑millisecond graph traversals with built‑in vector, text, and geospatial indexes. It ships a 40+ algorithm library (MAGE), an “Atomic GraphRAG” query model, and an AI Toolkit for LLM‑aware workflows, while offering enterprise features like Raft HA, multi‑tenancy, and fine‑grained security.