Local Memory MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Local Memory MCP store my birthday is in July"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Local Memory MCP
Persistent, local semantic memory for tools that speak the Model Context Protocol. A connected client can save notes, context, and preferences during one session and recall them later by meaning rather than exact wording. Everything is kept in a single SQLite file on your machine, and embeddings are computed locally on the CPU.
Overview
The server runs over stdio and exposes three tools: one to store text, one to search it semantically, and one to clear a namespace. Stored text is embedded with a small sentence-transformer model and indexed for vector search with sqlite-vec. After a one-time model download, no network connection is needed.
An optional desktop application is included for inspecting and managing what has been stored.
Related MCP server: mesh-memory
Features
Three tools over MCP:
store_memory,search_memory,wipe_project_memories.Local embeddings with
all-MiniLM-L6-v2(384 dimensions).Vector search backed by sqlite-vec in a single SQLite database.
Per-project namespaces through a
project_tagfield.An importance score for each memory that decays with age and rises each time the memory is recalled.
A blacklist that stops chosen terms, such as
.envorpassword, from being stored or written to the log.An optional desktop dashboard with an activity feed, a memory table, and privacy controls.
How it works
flowchart LR
C["MCP client"] -- "stdio" --> S["server.py (FastMCP)"]
S --> E["memory_engine.py"]
E -- "embeddings" --> M["all-MiniLM-L6-v2 (local CPU)"]
E -- "read / write (WAL)" --> DB[("memory.db: SQLite + sqlite-vec")]
UI["Desktop dashboard"] -- "read / delete / blacklist" --> DBThe server and the dashboard share one SQLite file in WAL mode. The dashboard can read and manage memory while the server is writing to it, and neither side blocks the other.
Requirements
Python 3.11 or newer
For the desktop app: Rust, Node.js, and a C/C++ toolchain. On Windows that means the Visual Studio C++ Build Tools. See the Tauri prerequisites for other platforms.
Running the server
git clone https://github.com/AQuietRiver/local-memory-mcp.git
cd local-memory-mcp
uv sync
uv run python server.pyThe first run downloads the embedding model (about 90 MB) and caches it. Later runs do not touch the network.
Connecting a client
Add a server entry to your MCP client's configuration file, using an absolute path:
{
"mcpServers": {
"local-memory": {
"command": "uv",
"args": ["run", "--directory", "/absolute/path/to/local-memory-mcp", "python", "server.py"]
}
}
}Restart the client and the three tools become available.
Tools
Tool | Signature | Purpose |
|
| Embed and save a piece of text. Rejected if it matches a blacklisted term. |
|
| Rank stored text by semantic similarity to the query. |
|
| Delete every memory in a namespace. |
Each tool has a docstring that the client reads to decide when to call it.
Desktop dashboard
A companion application for watching and managing the memory bank. It sits in the system tray and opens to three panels.
Panel | Function |
Activity Feed | A chronological log of tool calls, showing the tool, the project, the text passed, and the result. |
Memory Vault | A searchable table of stored memories with their tag, timestamp, and importance score, plus a per-row delete. |
Privacy Center | A control to erase all memory at once, and a manager for blacklisted terms. |
Deleting from the dashboard removes the embedding from disk as well as the row, not just the metadata.
Building
cd tauri-ui
npm install
npm run dev # development window with hot reload
npm run build # standalone installer and executableThe Windows vector extension (vec0.dll) is included under tauri-ui/src-tauri so the app can load sqlite-vec and remove embeddings. For macOS or Linux, place the matching vec0.dylib or vec0.so from the sqlite-vec releases in the same directory and update the resources entry in tauri.conf.json.
Scoring and blacklist
The importance score is 100 * 0.5^(age_days / 30) plus a small capped bonus for each recall, clamped to the range 0 to 100. Recency is the main factor; recalling a memory slows its decay. The Python engine and the dashboard compute the score the same way.
The blacklist is checked before any text is embedded. Comparison is case-insensitive and substring-based. A match is rejected, nothing is stored, and the activity log keeps a redacted record instead of the original text.
Data location
All data lives in a single file at ~/.config/local_memory_mcp/memory.db. There is no separate index or cache to manage.
Project layout
local-memory-mcp/
├── memory_engine.py # database and embedding engine
├── server.py # FastMCP server exposing the tools
├── pyproject.toml # packaging and dependencies
├── test_smoke.py # engine and tool-layer tests
├── test_features.py # blacklist, scoring, activity, and wipe tests
└── tauri-ui/ # optional desktop dashboard
├── src/ # frontend (HTML, CSS, JavaScript)
└── src-tauri/ # Rust backend (tray and read/write database layer)Testing
uv run python test_smoke.py
uv run python test_features.py
cd tauri-ui/src-tauri
cargo testLicense
MIT. See LICENSE.
Available Tools
3 toolssearch_memoryA
Search local vector memory for context semantically similar to query.
Call this at the start of a task to surface relevant context from past sessions before you begin reasoning or writing code. The search is embedding-based (not keyword-based), so natural-language questions work better than exact terms.
Example queries:
"how does authentication work in this project?"
"user's preferred code style and formatting rules"
"database schema decisions"
Inputs: query (required), limit, project_tag. Returns: result
store_memoryA
Store a piece of text as a semantic memory in the local vector database.
Call this tool whenever the user explicitly asks you to remember something, or whenever you observe context that should survive the current session:
Architectural decisions or design rationale
User preferences and working-style notes
Frequently-referenced file paths or API endpoints
Summaries of long conversations or research findings
One focused idea per memory retrieves better than a large wall of text.
Inputs: content (required), metadata, project_tag. Returns: result
wipe_project_memoriesA
Permanently delete all memories stored under project_tag.
This action is irreversible — vectors and metadata are removed from disk immediately. Only call this when the user has explicitly asked to clear or reset memory for a project. When in doubt, confirm with the user before calling.
Inputs: project_tag (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
Each tool has a distinct, non-overlapping purpose: search retrieves, store adds, wipe deletes. No ambiguity between them.
All tool names follow a consistent verb_noun pattern in snake_case (search_memory, store_memory, wipe_project_memories).
3 tools cover the core operations for a local memory server (search, store, delete). The count is well-scoped and earns its place.
The set covers essential memory operations, but lacks an update or list tool. However, delete+re-store can update, and search serves as discovery. Minor gap.
Maintenance
Related MCP Connectors
Persistent memory layer for AI tools. Save and recall notes across Claude and other MCP clients.
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
Persistent personal memory for AI assistants — save, search, and recall across every MCP client.
Self-hosted AI workspace: semantic RAG document search, long-term memory, and AI chat via MCP.
Related MCP Servers
- AlicenseAqualityCmaintenanceA local, fully-offline MCP memory server that enables persistent storage and retrieval of information using SQLite with both keyword and semantic vector search capabilities.108 npm13MIT
- AlicenseNot gradedqualityDmaintenanceSelf-hosted semantic memory for AI agents. Save worklogs, decisions, and notes via MCP, then recall them across sessions by meaning rather than keyword. Backed by Postgres + pgvector with local embeddings (multilingual-e5-base).1MIT
- AlicenseNot gradedqualityCmaintenanceA semantic memory store for AI agents, enabling persistent memory across sessions via MCP tools with semantic search, scoped access, and local embeddings.MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that provides semantic memory with search, related-content traversal, and write-back capabilities, all powered by local embeddings of your notes, documents, and chat histories.3MIT