Memory Vault is a self-hosted, MIT-licensed AI memory layer that bundles PostgreSQL + pgvector hybrid search, MCP-native tools, a knowledge graph, and local LLM chat around the promise that your data never leaves your machine. It is database-backed memory infrastructure rather than a filesystem note tool, aimed at individual developers who are comfortable running Postgres and who want to use memory through MCP, REST, or the dashboard as equal interfaces. Caveats to weigh: v1.0 is single-instance, NER is English-only, the HTTP/SSE transport is off by default and ships without encryption, and team features remain a planned PRO tier; the project is maintained by a single author, so response times are not guaranteed.
Strongest · Documentation 14/20 Weakest · Reliability 9/20
Static review · not runListed 2026-09-10
Read the FMRS scoring method →Runtime：Python 3.11+ · Docker
DB_HOST
Hostname of the Postgres+pgvector instance; use 127.0.0.1 or host.docker.internal with Docker.
DB_PORT
Postgres port, defaults to 5432.
DB_NAME
Postgres database name, defaults to memory_vault.
DB_USER
Postgres user with read/write access to the memory vault database.
DB_PASSWORD
Password for DB_USER; you set it yourself.
Option 1 (Docker, recommended): clone the repository, cd into it, and run docker compose up -d. Migrations run automatically on first start; verify with docker compose exec app memory-vault status. The dashboard is at http://localhost:8000.
Option 2 (no Docker): requires Python 3.11+, PostgreSQL 16 with the pgvector extension, and uv (or pip + venv). Run uv sync, then uv run python -m spacy download en_core_web_sm, then cp .env.example .env and fill in your PostgreSQL credentials, then uv run memory-vault migrate and uv run memory-vault status.
Configure your MCP client: complete the no-Docker setup above first so the memory_vault package is installed, then add the server block shown in install_config to your project's .mcp.json in Claude Code (or ~/.claude/.mcp.json), filling in DB_HOST, DB_PORT, DB_NAME, DB_USER, and DB_PASSWORD. For global availability, also add memory-vault to enabledMcpjsonServers in ~/.claude/settings.json. Verify with claude mcp list — it should show connected. For Claude Desktop, add the same block via Settings → Developer → Edit Config and restart.
Docker users: the MCP server runs on the host (not inside Docker) and connects over the exposed port, so set DB_HOST to 127.0.0.1 and make sure port 5432 is exposed in docker-compose.yml. For remote access over HTTP/SSE, set MCP_HTTP_ENABLED=true; the transport mounts at /api/mcp and clients connect to http://<host>:8000/api/mcp/sse with a bearer token created via memory-vault token create. Declare allowed hostnames with MCP_HTTP_ALLOWED_HOSTS (the list replaces the default, which covers localhost and 127.0.0.1 only).
{
"mcpServers": {
"memory-vault": {
"command": "/path/to/memory-vault/.venv/bin/python",
"args": ["-m", "memory_vault.mcp"],
"env": {
"DB_HOST": "localhost",
"DB_PORT": "5432",
"DB_NAME": "memory_vault",
"DB_USER": "memory_vault",
"DB_PASSWORD": "memory_vault"
}
}
}
}
Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.
{
"servers": {
"memory-vault": {
"command": "/path/to/memory-vault/.venv/bin/python",
"args": [
"-m",
"memory_vault.mcp"
],
"env": {
"DB_HOST": "localhost",
"DB_PORT": "5432",
"DB_NAME": "memory_vault",
"DB_USER": "memory_vault",
"DB_PASSWORD": "memory_vault"
}
}
}
}
Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).
claude mcp add memory-vault -e DB_HOST=localhost -e DB_PORT=5432 -e DB_NAME=memory_vault -e DB_USER=memory_vault -e DB_PASSWORD=memory_vault -- /path/to/memory-vault/.venv/bin/python -m memory_vault.mcp
Run it in a terminal; replace any <…> placeholders with your own values first.
Run `claude mcp list` in Claude Code and confirm memory-vault shows connected, or ask "Use memory_status to check the memory system" to confirm the tools are available.
Once connected, you can ask your AI assistant things like:
No matching tools
Listed from the project's documentation, not tested by this site.
Memory Vault is a local-first AI memory layer built on self-hosted PostgreSQL 16 + pgvector. Vector embeddings, full-text indexes, and relational data all live in one database, so there is no separate vector store to keep in sync; hybrid search combines vector similarity with PostgreSQL full-text search and merges the ranked lists using Reciprocal Rank Fusion (RRF).
It exposes six MCP tools to Claude (recall, remember, forget, purge_forgotten, move_memory, memory_status) so memories can be read and written during any session. The same memory layer is also reachable through a FastAPI REST API and a React dashboard with six pages (Chat, Search, Browse, Graph, Ingest, Stats); MCP, REST, the CLI, and your own apps are treated as equal first-class clients. The knowledge graph extracts entities with spaCy's en_core_web_sm model and derives related_to edges from co-occurrence, all on CPU with no external LLM or API calls.
The project is MIT licensed and maintained by MihaiBuilds as a single-maintainer project. Embeddings default to all-MiniLM-L6-v2 (384-d, CPU). Local LLM chat supports LM Studio in v1.0 and always shows the exact memory chunks each answer was grounded in. MCP defaults to stdio transport; HTTP/SSE transport must be explicitly enabled with MCP_HTTP_ENABLED=true and always requires a bearer token.
Connect ClickHouse to your AI assistants
Unofficial MCP server providing advanced access to the ChEMBL chemical database
Google's official database MCP toolbox — define AI-accessible database tools via config
Bytebase's official, minimalist two-tool database MCP server
Source revision d0d6b86b5f37 Data synced 2026-10-19 Read the FMRS scoring method