Gives AI clients a local SQLite knowledge graph with FTS5 hybrid search, session and task tracking, and cross-machine bridge sync.
Also known as RMANOV/sqlite-memory-mcp
- Stars
- 18
- Tools
- 7
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- MIT
What is SQLite Memory MCP?
SQLite Memory gives AI clients a local SQLite knowledge graph with FTS5 hybrid search, session and task tracking, and cross-machine bridge sync. It exposes 7 tools, such as sqlite_memory, sqlite_session, sqlite_tasks.
Summary generated from the project's README
About SQLite Memory MCP server
Coding agents that need a reliable, shared memory source can use this system to maintain a local knowledge graph. It provides a single SQLite file that acts as a central brain for multiple concurrent sessions, preventing the data corruption or file locking issues common with JSONL-based memory servers. By using WAL mode, the system supports over ten simultaneous Claude Code sessions without conflicts.
Developers can manage complex workflows through specialized tools for session tracking, task management, and entity linking. The server uses hybrid retrieval, combining FTS5 keyword search with optional semantic search via sqlite-vec to ensure high recall. Unlike systems that silently rewrite data, this implementation uses an approval-aware promotion gate where candidate claims must be confirmed by a human or meet specific policy requirements to become canonical facts.
This setup is designed for local-first use without the need for Docker, cloud APIs, or complex configurations. It includes bridge tools to sync shared entities across different machines using a private git repository, making it ideal for developers working across multiple workstations.
What you can do with it
- 1Syncing memory across machinesA developer can synchronize shared entities between different computers using bridge tools.
- 2Managing coding tasksAn AI agent can perform structured CRUD operations on tasks including setting priorities and due dates.
- 3Governing knowledge updatesUsers can prevent silent memory rewrites by requiring human confirmation for new facts.
- 4Running concurrent agent sessionsMultiple coding sessions can read and write to the same memory file simultaneously.
Written from the project's README. Every use case is checked against a quote from it.
SQLite Memory MCP tools 7
Detected from the READMEsqlite_memorysqlite_sessionsqlite_taskssqlite_bridgesqlite_collabsqlite_entitysqlite_intel
| sqlite_memory | — | |
| sqlite_session | — | |
| sqlite_tasks | — | |
| sqlite_bridge | — | |
| sqlite_collab | — | |
| sqlite_entity | — | |
| sqlite_intel | — |
Configuration
BRIDGE_REPOSQLITE_MEMORY_DB
| Name | Description | |
|---|---|---|
| BRIDGE_REPO | — | |
| SQLITE_MEMORY_DB | — |
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packageNot checked
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledPass
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesNot checked
README
View on GitHubSQLite Memory MCP Server
Governed cross-agent memory for coding agents
Claude and Codex can share one provenance-rich knowledge graph with approval-aware promotion workflows.
- Hybrid retrieval — BM25/FTS5 keyword search fused with optional semantic (sqlite-vec) results via Reciprocal Rank Fusion, so recall does not depend on exact keywords.
- Provenance + reviewable promotion — memory mutations carry provenance, and candidate claims move to canonical facts through an approval-aware promotion gate (
human_confirmed, plus policy-gated multi-evidence) instead of silent rewrites. - Cross-agent MCP memory with bridge sync — one local SQLite knowledge graph any MCP client can read and write, with bridge tools that sync shared entities across machines.
It is a production-quality, local-first MCP memory stack: a single SQLite file under WAL concurrency (10+ sessions), FTS5 BM25 search, session tracking, task management, bridge sync, collaboration workflows, and a native system-tray task manager. The core 9 knowledge-graph tools are drop-in compatible with @modelcontextprotocol/server-memory; companion FastMCP micro-servers add more tools for sessions, tasks, bridge sync, collaboration, entity linking, and intelligence/multi-agent workflows. A PyQt6 desktop app and standalone automation scripts ship alongside. See the Tool Reference for the exact per-server tool counts.
Technical deep-dives
- Medium: The Amnesiac That Learned to Remember
- Dev.to: The Amnesiac That Learned to Remember — Building a Brain for Claude Code
- Dev.to: How a SQLite WAL Fix Grew into a 54-Tool MCP Memory Stack
Why SQLite?
Existing MCP memory servers use JSONL files, cloud APIs, or heavyweight databases. Each has trade-offs that hurt real-world Claude Code usage:
- JSONL files (official MCP memory) -- file locks break with 2+ concurrent sessions. Data corruption is a matter of time.
- Cloud APIs (Mem0, Supabase) -- latency, API keys, privacy concerns, vendor lock-in.
- Heavy databases (Neo4j, ChromaDB, Qdrant) -- Docker, config files, resource overhead for what is essentially a key-value store with search.
SQLite hits the sweet spot:
- Single file --
memory.dbis the entire database. Back it up withcp. - Zero config -- No server process, no Docker, no API keys.
- ACID transactions -- Writes never corrupt, even on power loss.
- WAL mode -- Multiple concurrent readers and writers. 10+ Claude Code sessions, no conflicts.
- FTS5 -- Full-text search with BM25 ranking built into the standard library.
- stdlib --
sqlite3ships with Python. No additional binary dependencies.
Features
- WAL mode -- 10+ concurrent Claude Code sessions with no file locking conflicts
- Hybrid search (BM25 + semantic) -- FTS5 keyword search fused with optional sqlite-vec cosine similarity via Reciprocal Rank Fusion, then re-ranked with 6 contextual signals (recency, project affinity, graph proximity, observation richness, canonical facts, active session)
- Session tracking -- Save and recall session snapshots for context continuity across restarts
- Task management -- Structured task CRUD with typed queries, priorities, sections, due dates, and recurring tasks
- Kanban board -- Optional HTML report generator for visual task overview via GitHub Pages
- Cross-project sharing -- Optional
projectfield scopes entities; omit it to share across all projects - Cross-machine sync -- Bridge tools push/pull shared entities between machines via a private git repo
- Provenance + approval-aware promotion -- Mutations carry provenance; candidate claims promote to canonical facts through a review gate (
human_confirmed/ policy-gated multi-evidence). See Advanced & operator topics - Drop-in compatible core -- All 9 tools from
@modelcontextprotocol/server-memorywork identically insqlite_memory, with many more tools available from companion servers (see Tool Reference for exact per-server counts) - Zero required dependencies beyond stdlib -- Only
fastmcpis required for MCP protocol;sqlite3is Python stdlib. Optionalorjson,sqlite-vec, andsentence-transformersadd speed and semantic search - Automatic FTS sync -- Full-text index stays in sync with every write operation
- JSONL migration -- Optionally import existing
memory.jsonknowledge graphs on first run
FAQ: how is this different from sqlite.ai / sqlite-vector?
sqlite.ai is adjacent, not identical. It is a broader SQLite platform around cloud sync, extensions, AI inference, vector search, agent memory, and MCP tooling. Its related projects include sqlite-memory, a Markdown-based agent memory system, and sqlite-vector, a vector-search extension for embedded SQLite workloads.
sqlite-memory-mcp is focused on local-first MCP memory governance for coding agents, not on vector search as the center of the product:
- WAL-backed task, session, entity, and note memory in one local SQLite file
- FTS5-first retrieval, with vector search as an optional backend
- cross-machine bridge sync for private multi-machine workflows
- event/provenance tracking for memory mutations
- reviewable consolidation instead of silent memory rewriting
- debate/protocol workflows for conductor, executor, and devil's advocate agents
- an explicit OSS/premium runtime boundary with signed entitlement, manifest, and policy checks
sqlite-vec is therefore not the product center; it is one possible local
retrieval backend. If sqlite-vector proves better for this workload, it can
become a candidate backend. The harder problem this project targets is memory
governance: how agents remember, revise, sync, debate, and promote durable
context without turning the memory store into an unreviewable pile of
contradictions.
Advanced & operator topics
The features above are the core. The capabilities below are deliberately kept out of the hero because they matter to operators, not first-time users. Each links to its canonical document.
Core path vs advanced path
This section is the public summary of what is on the everyday core path versus the advanced / optional path, plus the allowed / forbidden external-claim set and the D2 (code-change) triggers.
- Core path (load-bearing, start here):
sqlite_memory,sqlite_tasks,sqlite_session; provenance / knowledge-links; bridge resilience; reflect / audit discipline; addressed debate routing; entity hygiene. - Advanced / optional path (opt in as needed):
sqlite_collab/ P2P (advanced / optional shared-knowledge surface); premium / airlock (an operator / private-runtime boundary, excluded from external-facing feature claims); the vector semantic backend (an optional backend with FTS5 fallback); and the advancedsqlite_intel/ debate operations.
These labels describe posture and emphasis. Nothing here is removed, deprecated, disabled, or scheduled for removal; every server and tool below stays present and supported. The 7-microserver split is current MCP-visibility / ergonomics design, not a consolidation target — the Tool Reference and its server / tool counts are unchanged.
Intelligence v2 — claims, governance, and provenance
The sqlite_intel server turns raw memory into reviewable knowledge. It extracts candidate claims, queues clarifications, records human answers, and promotes claims to canonical facts through an approval-aware gate (promote_candidate: human_confirmed always allowed; multi_evidence is policy-gated; sensitive scopes require explicit human confirmation). Every mutation can carry a provenance link, and audit_memory / replay_memory make the history inspectable. Consolidation runs through reflect_audit (Phase 0.5) — deterministic SQL with no LLM cost per run. See docs/REFLECT_AUDIT_DEMO.md.
Debate / multi-agent protocol
For workflows that coordinate multiple agents (conductor, executor, devil's advocate) across sessions, the sqlite_intel debate tools provide a single per-topic channel with role-aware watermarks, claim/reclaim, and escalation. This is an advanced coordination layer, not required for memory use. See docs/DEBATE_PROTOCOL.md and docs/ops/DEBATE_OPERATIONS.md.
Optional private-runtime boundary
This OSS repo includes a public contract for separately configured private extensions. It defines entitlement, artifact-manifest, control-policy, audit, revoke, and bootstrap surfaces, but does not include private business logic, private entitlements, signing keys, proprietary connectors, or private ranking/governance rules. Private extensions are not loaded by default; they require an explicit configured entrypoint, local owner approval, and the relevant signed entitlement / manifest / policy checks.
Operator wiring and the public contract are documented in:
docs/ops/PREMIUM_BOUNDARY.md— operator wiring and verificationdocs/ops/RELEASE_CONFIDENCE.md—v3.7.2release-quality checklistpremium_contract.py— public contract for the private repodocs/premium/entitlement.schema.json— entitlement schemadocs/premium/private_extension_contract.md— private extension contracttemplates/private_premium_repo/— public-safe bootstrap template
Pricing is intentionally not published here; serious prospects receive a scoped questionnaire, then a customized offer.
External claim boundary (frozen claim-set)
For external / diligence material, the project commits to the bounded claim-set summarized here.
Allowed: local-first governed cross-agent memory; provenance /
knowledge-links and approval-aware promotion; the deterministic reflect_audit
audit gate; addressed debate routing bounded to addressed messages, cursors,
no_action, role watermarks, and audit logs; hybrid retrieval with an FTS5
baseline and an optional vector backend (FTS5 fallback); entity hygiene / merge
with an audit trail; and bridge cross-machine resilience as conflict / recovery
discipline against no-resurrect / no-data-loss failures. Posture: application-
enforced append-only governance, local-first, civilian-dogfooded,
single-operator, test-backed.
Forbidden: defence validation / accreditation / certification; "immutable" /
WORM / tamper-evident or hash-chain claims (until shipped); shipped
STRIX ↔ sqlite_memory integration; edge / on-hardware deployment; premium /
airlock as a named external feature; an absolute no-data-loss guarantee; vector
search as the product center or a required baseline; and unbounded "production"
claims (only production-quality, single-operator, no external customers or
deployment).
Competitor Comparison
| Feature | sqlite-memory-mcp | Official MCP Memory | claude-mem0 | @pepk/sqlite | simple-memory | mcp-memory-service | memsearch | memory-mcp | MemoryGraph |
|---|---|---|---|---|---|---|---|---|---|
| Storage | SQLite | JSONL file | Mem0 Cloud | SQLite | JSON file | ChromaDB | Qdrant | SQLite | Neo4j |
| Concurrent 10+ sessions | WAL mode | file locks | cloud | no WAL | file locks | yes | yes | no | yes |
| Hybrid search (BM25 + vector) | yes (RRF fusion) | substring | no | no | no | vector only | vector only | no | Cypher only |
| Session tracking | built-in | no | no | no | no | no | no | no | no |
| Task management | built-in | no | no | no | no | no | no | no | no |
| Cross-project sharing | project field | no | no | no | no | no | no | no | no |
| Drop-in compatible | 9/9 tools | baseline | no | partial | no | no | no | partial | no |
| Setup effort | pip install | npx | API key + pip | pip | npx | Docker + pip | Docker + pip | pip | Docker + Neo4j |
| Dependencies | sqlite3 (stdlib) | Node.js | Cloud API | sqlite3 | Node.js | ChromaDB | Qdrant | sqlite3 | Neo4j |
Where this sits in the ecosystem
- Beads. sqlite-memory-mcp can sit beside Beads. Beads is an issue/work-tracking layer for agents; sqlite-memory-mcp is a governed memory layer. There is no shipped Beads adapter — the
ready_contexttool offers aready/primework surface that is the cross-project/cross-machine analog ofbd ready/bd prime, so the two can coexist in the same workflow. - Codex Memories. OpenAI's Codex has its own memory feature, and the "agent memory" category is gaining mindshare fast. sqlite-memory-mcp is not pitched as a 1:1 replacement; it targets a different point in the design space — a local-first, multi-agent, provenance-governed knowledge graph that any MCP client can share, rather than a single-agent built-in. The category risk is real, which is precisely why the governance and cross-agent surface matter.
Convergent evolution: sqlite-memory-mcp vs GBrain
GBrain — Garry Tan's structured knowledge layer for AI agents — launched 2026-04-10. It and sqlite-memory-mcp arrived independently at the same architectural conclusions: local-first storage, hybrid lexical + vector search fused via Reciprocal Rank Fusion, rule-based zero-LLM entity extraction, and a memory-consolidation cycle (GBrain calls it dream, sqlite-memory-mcp calls it reflect). When two solo founders converge on the same architecture, the design space is real.
The two projects ship different bets for different deployments. Public git history establishes that sqlite-memory-mcp's hybrid search shipped on 2026-03-18 (commit feat(search): add hybrid semantic search via sqlite-vec + RRF fusion) — twenty-three days before GBrain's first public release.
| Axis | GBrain | sqlite-memory-mcp |
|---|---|---|
| Initial public release | 2026-04-10 | 2026-03-01 (v0.1.0, 40-day lead) |
| Hybrid search (BM25 + vector + RRF) | shipped 2026-04-10 | shipped 2026-03-18 (23-day lead) |
| Storage primitive | Markdown files in git + PGLite (embedded Postgres) + pgvector | Single SQLite file (FTS5 + sqlite-vec) + bridge git repo |
| Infrastructure footprint | Postgres runtime + git remote + LLM API | Single binary, single file, optional local embeddings |
| Embeddings | OpenAI API (network call per page write) | sentence-transformers, fully local |
| Memory consolidation | "dream cycle" (uses LLM) | reflect_audit Phase 0.5 — deterministic SQL, no LLM cost |
| Per-candidate review | atomic store-level output | per-row accept / reject / defer with apply snapshots |
| Cross-machine sync | git remote of the brain repo | bridge JSON + per-field LWW-Register CRDT; conflict/recovery regressions and operational discipline address no-resurrect / no-data-loss failure modes without claiming an absolute data-loss guarantee |
| Source of truth | Markdown (human-readable) | SQLite + JSON bridge exports (machine-portable) |
| Air-gapped / regulated deployment | blocked by OpenAI embedding requirement | fully supported (no external network in hot path) |
| Companion stack | GStack (Garry's Claude Code setup) | MCP-native, works with any MCP client (Claude Code, Codex) |
Where each one wins:
- GBrain is right for teams that want a markdown-first knowledge base, are happy paying for OpenAI embeddings on every page write, and benefit from Garry Tan's distribution. The forthcoming hosted
gbrain.iotargets teams that don't want to run their own runtime. - sqlite-memory-mcp is right for solo developers, privacy-first / offline / embedded deployments, regulated environments where data cannot reach OpenAI (DoD, healthcare, finance), and anyone who needs the consolidation pipeline to run on a Raspberry Pi or inside an air-gapped network. The deterministic Phase 0.5 audit produces real candidate counts with zero LLM cost per run.
This is convergent validation, not derivative work. The architecture is decided; the markets diverge.
Installation
Two-minute install + demo
Use this path when you want to verify the install before wiring Claude Code:
git clone https://github.com/RMANOV/sqlite-memory-mcp.git
cd sqlite-memory-mcp
python -m venv .venv
source .venv/bin/activate
pip install -e ".[gui,dev]"
# Verify Python, FastMCP, SQLite schema, DB write access, and optionally
# whether Claude Code and Codex list the local sqlite MCP servers.
sqlite-memory-doctor --db /tmp/sqlite-memory-mcp-demo.db --check-gui --check-claude-mcp --check-codex-mcp
# Seed a safe demo DB with one entity, one task, one note, a reminder,
# and a recurring schedule. This does not touch your real memory.db.
sqlite-memory-demo --db /tmp/sqlite-memory-mcp-demo.db --reset
# Optional desktop demo against the demo DB.
SQLITE_MEMORY_DB=/tmp/sqlite-memory-mcp-demo.db task-tray
If sqlite-memory-doctor is clean and the tray opens the demo DB, the local
install is healthy enough to connect to Claude Code.
Claude Code quick start
# Clone
git clone https://github.com/rmanov/sqlite-memory-mcp.git
cd sqlite-memory-mcp
# Install from source
pip install -e .
# Optional extras
# pip install -e ".[gui,vector,speed]"
# Add the core drop-in server
claude mcp add --scope user sqlite_memory -- python /path/to/server.py
# Add companion servers for the full OSS tool stack
claude mcp add --scope user sqlite_tasks -- python /path/to/task_server.py
claude mcp add --scope user sqlite_session -- python /path/to/session_server.py
claude mcp add --scope user sqlite_bridge -- python /path/to/bridge_server.py
claude mcp add --scope user sqlite_collab -- python /path/to/collab_server.py
claude mcp add --scope user sqlite_entity -- python /path/to/entity_server.py
claude mcp add --scope user sqlite_intel -- python /path/to/intel_server.py
# Optional: run the full stack as one all-in-one server instead
claude mcp add --scope user sqlite_unified -- python /path/to/unified_server.py
If you install the package instead of running from a checkout, the same servers are available as console scripts:
claude mcp add --scope user sqlite_memory -- sqlite-memory-core
claude mcp add --scope user sqlite_tasks -- sqlite-memory-tasks
claude mcp add --scope user sqlite_session -- sqlite-memory-session
claude mcp add --scope user sqlite_bridge -- sqlite-memory-bridge
claude mcp add --scope user sqlite_collab -- sqlite-memory-collab
claude mcp add --scope user sqlite_entity -- sqlite-memory-entity
claude mcp add --scope user sqlite_intel -- sqlite-memory-intel
# Optional all-in-one server
claude mcp add --scope user sqlite_unified -- sqlite-memory-unified
Codex can use the same console-script servers:
codex mcp add sqlite_memory -- sqlite-memory-core
codex mcp add sqlite_tasks -- sqlite-memory-tasks
codex mcp add sqlite_session -- sqlite-memory-session
codex mcp add sqlite_bridge -- sqlite-memory-bridge
codex mcp add sqlite_collab -- sqlite-memory-collab
codex mcp add sqlite_entity -- sqlite-memory-entity
codex mcp add sqlite_intel -- sqlite-memory-intel
# Optional all-in-one server
codex mcp add sqlite_unified -- sqlite-memory-unified
Manual Configuration
Prefer claude mcp add --scope user ... above and verify with
claude mcp list; prefer codex mcp add ... and verify with
codex mcp list for Codex. Some Claude Code builds no longer surface legacy
~/.claude/settings.json mcpServers entries in claude mcp list, and Codex
uses its own ~/.codex/config.toml, so one client's manual block does not
prove the other client can load the servers.
If you need a manual fallback, add these server/file pairs to your
~/.claude/settings.json under mcpServers:
| MCP server name | Python entry file | Purpose |
|---|---|---|
sqlite_memory |
server.py |
Core 9 drop-in memory tools |
sqlite_tasks |
task_server.py |
Task CRUD, digest, archive, overdue bump |
sqlite_session |
session_server.py |
Session recall, project search, health, resume |
sqlite_bridge |
bridge_server.py |
Cross-machine bridge sync, sharing review |
sqlite_collab |
collab_server.py |
Collaborator and public-knowledge workflows |
sqlite_entity |
entity_server.py |
Task-entity linking and merge helpers |
sqlite_intel |
intel_server.py |
Context assessment and enrichment tools |
sqlite_unified |
unified_server.py |
Optional all-in-one server that mounts the full OSS tool stack |
Each server should share the same environment values:
"env": {
"SQLITE_MEMORY_DB": "/home/user/.claude/memory/memory.db",
"BRIDGE_REPO": "/home/user/.claude/memory/bridge"
}
The SQLITE_MEMORY_DB environment variable controls where the database is stored. If omitted, it defaults to ~/.claude/memory/memory.db. BRIDGE_REPO is only needed for bridge/collab flows.
Architecture
The system is intentionally split into micro-servers because Claude Code exposes only a limited number of tools per MCP server.
server.pyexposes the 9 drop-in knowledge-graph tools.task_server.py,session_server.py,bridge_server.py,collab_server.py,entity_server.py, andintel_server.pyexpose the remaining tools; see the Tool Reference for the exact per-server breakdown.- All MCP servers, the Task Tray GUI, and the automation scripts share the same
memory.db. db_utils.pyandschema.pyare the shared source of truth for connections, migrations, and common helpers.- SQLite WAL mode handles concurrency across all of these processes.
SQLite Memory MCP questions
What tools does SQLite Memory MCP provide?
It exposes 7 tools, including sqlite_memory, sqlite_session, sqlite_tasks, sqlite_bridge, sqlite_collab.
What storage does this memory server use?
It stores everything in a single local SQLite file, memory.db, running in WAL mode so multiple sessions can read and write concurrently.
How many concurrent sessions does it support?
WAL mode allows 10 or more concurrent Claude Code sessions without file locking conflicts.
Does it support semantic search or only keywords?
It fuses FTS5 BM25 keyword search with optional sqlite-vec semantic results using Reciprocal Rank Fusion, and re-ranks with contextual signals.
Is it compatible with the official MCP memory server?
Yes, the core 9 knowledge-graph tools are drop-in compatible with @modelcontextprotocol/server-memory.
Can I sync memory across machines?
Yes, bridge tools push and pull shared entities between machines through a private git repository.