MCP Server

Active

MIT

Turbo Quant Memory MCP Server

io.github.Lexus2016/turbo-quant-memory

Local-first memory and knowledge graph for AI coding agents—persistent, searchable, no network.

What is the Turbo Quant Memory MCP server?

Turbo Quant Memory is an MCP server that gives AI coding agents a persistent, searchable knowledge store for decisions, lessons, patterns, and indexed Markdown—all stored locally on your machine. It uses hybrid BM25 + dense vector retrieval to return compact result cards rather than whole documents, reducing token waste across sessions. Your notes, code, and secrets never leave your disk.

Turbo Quant Memory solves the problem of agents re-reading files and re-deriving conclusions in every session by maintaining a local knowledge graph and memory index. It stores typed notes (decisions, lessons, patterns, handoffs), indexes your Markdown with tiered retrieval, and provides a knowledge graph linking notes to files and issues. The server runs fully offline after an initial embedding model download, measures its own token savings, and includes an encrypted secrets vault—all without telemetry or external calls.

How to install Turbo Quant Memory

Copy-paste configuration for popular MCP clients.

transport: stdio

Config generated by PluginBench — verify against the source before use.

Environment / auth

TQMEMORY_FTS_LANGUAGE
Snowball stemmer for the BM25 lane. Use Russian for Cyrillic-dominant corpora.
TQMEMORY_EMBEDDING_BACKEND
Embedder backend. Default fastembed (ONNX); sentence-transformers needs the [torch] extra.
TQMEMORY_MIGRATE_ON_STARTUP
Set to 1 to apply pending schema migrations automatically on startup.
TQMEMORY_SECRETS_PASSPHRASE
secret
Argon2id passphrase for the secrets vault on headless hosts. Omit to use the OS keyring.

~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "turbo-quant-memory": {
      "command": "uvx",
      "args": [
        "turbo-quant-memory",
        "serve"
      ],
      "env": {
        "TQMEMORY_FTS_LANGUAGE": "<YOUR_TQMEMORY_FTS_LANGUAGE>",
        "TQMEMORY_EMBEDDING_BACKEND": "<YOUR_TQMEMORY_EMBEDDING_BACKEND>",
        "TQMEMORY_MIGRATE_ON_STARTUP": "<YOUR_TQMEMORY_MIGRATE_ON_STARTUP>",
        "TQMEMORY_SECRETS_PASSPHRASE": "<YOUR_TQMEMORY_SECRETS_PASSPHRASE>"
      }
    }
  }
}

Tools & capabilities

Tools this server exposes to the agent.

remember_note — Store a typed note (decision, lesson, pattern, or handoff) with tags and knowledge-graph links.
deprecate_note — Mark a note as deprecated or obsolete.
promote_note — Elevate a note's priority or tier in the knowledge base.
index_paths — Index Markdown files and code blocks for retrieval.
semantic_search — Search the knowledge base using hybrid BM25 + dense vector retrieval with RRF fusion.
hydrate — Retrieve full content of a search result card on demand.
recent_context — Fetch recent notes and context from the current session.
list_scopes — List available memory scopes or projects.
link_entities — Create directed, timestamped relations between notes, files, and issues.
unlink_entities — Remove relations between entities in the knowledge graph.
get_related_entities — Retrieve entities linked to a given note or file.
lint_knowledge_base — Check the knowledge base for integrity and consistency issues.
health — Run a health check on the server.
self_test — Execute self-tests to verify server functionality.
server_info — Retrieve server metadata, including cumulative token savings and usage statistics.
set_secret — Store a secret in the encrypted project-scoped vault (AES-256-GCM).
get_secret — Retrieve a secret from the vault.
list_secrets — List all secrets in the vault.
delete_secret — Remove a secret from the vault.

Use cases

Store architectural decisions and lessons learned so agents recall them in future sessions without re-reading code.
Index your project's Markdown documentation and retrieve relevant sections as compact cards, reducing token overhead.
Build a knowledge graph linking decisions to files and issues, so the agent understands context and dependencies.
Securely store API keys and credentials in an encrypted vault, structurally isolated from search.
Measure token savings across sessions with built-in usage statistics and verify the memory's ROI.

Turbo Quant Memory MCP server FAQ

What is Turbo Quant Memory?

It is an MCP server that gives AI coding agents a persistent, local-first knowledge store for decisions, lessons, patterns, and indexed code. It uses hybrid retrieval (BM25 + dense vectors) to return compact cards instead of whole documents, reducing token waste and context bloat across sessions.

Is it free?

Yes. Turbo Quant Memory is MIT-licensed, free to use, modify, and redistribute. There are no paid tiers, subscriptions, or vendor lock-in.

How do I install it in Cursor or Claude?

Install via `uv tool install turbo-quant-memory`, then register with your client: `claude mcp add --scope project tqmemory -- turbo-memory-mcp serve` (Claude Code) or `codex mcp add tqmemory -- turbo-memory-mcp serve` (Codex). See CLIENT_INTEGRATIONS.md for Cursor, OpenCode, and other clients.

Does my data leave my machine?

No. All notes, code, and secrets stay on your disk. The only external download is the embedding model (~0.22 GB from Hugging Face) on first run; after that the server runs fully offline with no telemetry or phone-home.

What authentication is required?

None. The server runs locally and does not require API keys, accounts, or network access. The encrypted secrets vault uses AES-256-GCM and is structurally isolated from search.

Can it handle non-English content?

Yes. Cyrillic and other non-English terms match exactly, case- and accent-insensitive, with no configuration needed. The hybrid retrieval combines dense vectors with BM25 exact-match for robust multilingual support.

README (reference)

Source of truth, from the repository.

<p align="center">  <img src="https://raw.githubusercontent.com/Lexus2016/turbo_quant_memory/main/assets/readme-hero-en.svg" alt="Turbo Quant Memory" width="820"> </p> <h3 align="center">Local-first memory and knowledge graph for AI coding agents</h3> <p align="center"> Your agent stops re-reading files and re-deriving the same conclusions.<br> Your notes, code and secrets never leave your machine. </p> <p align="center"> <a href="https://pypi.org/project/turbo-quant-memory/"><img alt="PyPI" src="https://img.shields.io/pypi/v/turbo-quant-memory.svg"></a> <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a> <a href="https://registry.modelcontextprotocol.io/v0/servers?search=turbo-quant-memory"><img alt="MCP Registry" src="https://img.shields.io/badge/MCP%20Registry-listed-6f42c1.svg"></a> <img alt="Python 3.11+" src="https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue.svg"> <a href="https://github.com/Lexus2016/turbo_quant_memory/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/Lexus2016/turbo_quant_memory/actions/workflows/ci.yml/badge.svg"></a> <img alt="MCP tools" src="https://img.shields.io/badge/MCP-19%20tools-green.svg"> <img alt="Local-first" src="https://img.shields.io/badge/data-100%25%20local-success.svg"> </p>

The problem

A long session accumulates hard-won detail about why the code is the way it is. Then the context compacts and it is gone. Next session the agent re-reads the same files, re-derives the same conclusions, and bills you for the same tokens again.

CLAUDE.md does not scale past a few dozen lines, and it cannot answer "what did we decide about X, and why?".

Turbo Quant Memory is an MCP server that gives the agent a persistent, searchable store it writes to while it works — decisions, lessons, patterns, session handoffs — plus a compact index of your Markdown. Retrieval returns ~220-character result cards rather than whole documents; the agent loads full content only when a card is not enough.

Why this one

	Turbo Quant Memory	mem0 / OpenMemory	MCP `memory` server
Where your data lives	your disk, always	vendor cloud or self-host	your disk
Your data leaves the host	never	yes, unless self-hosted	never
Retrieval	hybrid BM25 + dense vector, RRF-fused	dense vector	exact graph lookup
What a search returns	compact cards, hydrate on demand	full memories	full nodes
Knowledge graph	yes — with lifecycle + linting	no	yes
Non-English content	Cyrillic exact-match out of the box	varies	n/a
Measures its own savings	yes — `server_info()`	no	no
Price	free, MIT	paid tiers	free

No HTTP client, no telemetry, no phone-home. Verify it yourself — this returns nothing:

grep -rnE '^[[:space:]]*(import|from)[[:space:]]+(requests|httpx|aiohttp|urllib3)\b' src/

To be precise about the one exception: on first run fastembed downloads the embedding model (~0.22 GB) from Hugging Face. After that the server runs fully offline. Your notes, code and secrets are never transmitted anywhere — there is nothing in the package that could send them.

Install

Let your agent install it

Paste this into Claude Code, Codex, Gemini CLI, Cursor or Antigravity:

Install and configure the Turbo Quant Memory MCP server for this workspace from https://github.com/Lexus2016/turbo_quant_memory — follow the README, register the tqmemory server, run turbo-memory-mcp skill install, run the health check, and index this project.

skill install copies an operating manual into every agent skill directory on the machine, so every future session already knows how to use the memory without being told.

Or install it yourself

uv tool install turbo-quant-memory

Upgrading from 0.27.x or earlier? The distribution was renamed in 0.28.0, so uv tool upgrade turbo-memory-mcp no longer resolves — run uv tool install --force turbo-quant-memory once, and uv tool upgrade turbo-quant-memory afterwards. The turbo-memory-mcp command itself is unchanged, so client configs keep working.

Then register the server with your client:

claude mcp add --scope project tqmemory -- turbo-memory-mcp serve   # Claude Code
codex  mcp add tqmemory -- turbo-memory-mcp serve                   # Codex
gemini mcp add tqmemory turbo-memory-mcp serve                      # Gemini CLI

Cursor, OpenCode, Antigravity and other clients → CLIENT_INTEGRATIONS.md. Hermes runs MCP through a systemd gateway → docs/hermes.md.

📈 It measures its own savings — see for yourself

Turbo Quant Memory doesn't just claim to save tokens — every install keeps a running tally you can read anytime with server_info() (field usage_stats.headline). The savings are yours to verify, not ours to promise.

Live snapshot from a real developer instance (v0.28.2):

What the memory did	Number
🔢 Input tokens saved (cumulative)	≈ 2,640,000 and counting
🔁 Retrievals served	2,280 searches + 280 deep hydrations
📉 Average saved per retrieval	≈ 1,200 tokens
📚 Knowledge under management	237 active notes + 763 indexed code blocks
🛡️ Integrity	0 corrupted records · 0 pending migrations

These are one machine's cumulative numbers, not a synthetic benchmark — your own counter starts at zero and grows as your agent works. Run server_info() on your install to see your real figure.

What it does

Typed notes. decision, lesson, pattern, handoff — each stored with tags, provenance and a knowledge-graph link to the file or issue it is about.
Tiered memory. durable (decisions, patterns) and reference (indexed docs) are searched by default; episodic (session handoffs) stays out of the way until you ask for it, so yesterday's noise never buries an architectural decision.
Hybrid retrieval. A dense vector lane leads; a BM25 lane rescues exact terms — function names, file paths, IDs — fused with Reciprocal Rank Fusion. Cyrillic and other non-English terms match exactly, case- and accent-insensitive, with no configuration.
Knowledge graph. Directed, timestamped relations between notes, files and issues. Search results carry the linked context inline, so the agent does not need a second lookup.
Human notes outrank agent notes. Anything you explicitly asked to remember is flagged human-explicit and ranks above the agent's own observations at equal relevance.
Encrypted secrets vault. Project-scoped, AES-256-GCM, structurally unreachable from search. → docs/secrets-vault.md
Runs on a small machine. The default embedder is ONNX via fastembed — no PyTorch, ~0.22 GB model, comfortable on 2 GB of RAM.

Full technical detail → docs/features.md

The 19 MCP tools

Group	Tools
Write	`remember_note` · `deprecate_note` · `promote_note` · `index_paths`
Read	`semantic_search` · `hydrate` · `recent_context` · `list_scopes`
Graph	`link_entities` · `unlink_entities` · `get_related_entities`
Hygiene	`lint_knowledge_base` · `health` · `self_test` · `server_info`
Vault	`set_secret` · `get_secret` · `list_secrets` · `delete_secret`

Documentation


MEMORY_STRATEGY.md	How to actually use the memory day to day
CLIENT_INTEGRATIONS.md	Per-client setup: Cursor, OpenCode, Antigravity, …
TECHNICAL_SPEC.md	Architecture and storage format
docs/features.md	Retrieval, graph, tiers, embedder, FTS language
docs/secrets-vault.md	Vault setup, threat model, FAQ
docs/hermes.md	Hermes gateway setup and troubleshooting
CHANGELOG.md	Release history

License

MIT. Copy it, modify it, fork it, ship it inside a closed-source product, sell it. Attribution is the only condition.

Languages

🇺🇸 English · 🇺🇦 Українська · 🇷🇺 Русский

Related MCP servers

FlatWay Property Estimator

French property prices, market trends & live listings for any French address. Powered by DVF data.

io.github.Libres-coder/parseflow

Stale

PDF parsing server with text extraction, metadata, search, images, and TOC via MCP

TypeScript

MIT

View repository →

Compass

Maintained

Ground your LLM in EU financial, crypto and AI regulation, verbatim and cited, via Compass.

JavaScript

MIT

View repository →

io.github.Licinexus/mcp

Active

Access Brazilian public procurement (PNCP) and Federal Revenue CNPJ data conversationally in Claude, Cursor, or any MCP-compatible client.

TypeScript

MIT

View repository →

Licium

Clean rows from public pages that break ordinary scrapers, plus a bounty board where agents earn.

LienDeadline

Active

US mechanics lien and preliminary notice deadlines for construction suppliers, with statute sources.

JavaScript

MIT

View repository →