SQLite Project Memory MCP
Supports rendering and exporting project memory into human-readable Markdown files, allowing structured data like roadmaps and tasks to be viewed as generated documents.
Utilizes a SQLite database as the authoritative relational store for project memory, providing tools to manage entities, relationships, and content through structured SQL-backed operations.
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., "@SQLite Project Memory MCP show me the project overview and recent activity"
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.
SQLite Project Memory MCP
SQLite-backed MCP server for storing project memory as a graph-friendly relational core.
Why this project
Keeps authoritative state in SQLite (single source of truth).
Provides graph semantics (
entities,relationships,content,tags).Supports structured reads (
query_view) and explicit generated markdown views.Designed for AI-agent-safe workflows.
Related MCP server: @contextable/mcp
Core model
entitiesattributesrelationshipscontenttagsevents,snapshots,snapshot_entities(audit/history)
Supported sync-document targets
Core documents:
architecture,decisions,plan,notes,roadmapExtended docks:
kpi,okr,strategy,risk,issue,epic,story,feature,milestone,release,dependency,objective,initiative,metric,capability,assumption,problem_statement,retrospective,action_item
Install
Clone the repo into a sqlite-mcp subfolder of your project, then run the installer once.
The script detects its location, places all runtime files inside Project Memory/, and writes .vscode/mcp.json.
No Python installation required. The installer downloads uv and uses it to fetch
a pinned CPython 3.12.9 interpreter automatically. The interpreter is cached in
Project Memory/.uv/python/ and the virtual environment is created in Project Memory/.venv.
If the uv download fails (e.g. behind a firewall) the installer falls back to any
Python 3.11+ already on the machine.
Important: open VS Code on your project root (the parent folder), not on the sqlite-mcp subfolder.
The MCP config is written to the project root at .vscode/mcp.json.
Windows (PowerShell)
# from your project root
git clone https://github.com/WebRTCGame/SQLITE-MCP.git sqlite-mcp
.\sqlite-mcp\install.ps1Optional flag:
-LogFile install.log— save a full transcript for debugging-AppendInstructions— append snippet to the suggested instructions file (idempotent)
Linux / macOS
# from your project root
git clone https://github.com/WebRTCGame/SQLITE-MCP.git sqlite-mcp
chmod +x ./sqlite-mcp/install.sh
./sqlite-mcp/install.shOptional flag:
--log-file install.log— save a full transcript for debugging--append-instructions— append snippet to the suggested instructions file (idempotent)
To update: after a successful nested install, the scripts live under Project Memory/ because the sqlite-mcp checkout is moved there. Re-run the installer from your project root with Project Memory\install.ps1 (Windows) or Project Memory/install.sh (Linux/macOS). For in-place/developer installs, re-run the same command.
pip only (developer / advanced)
Used when you want to manage the environment yourself (requires Python 3.11+):
python -m venv .venv
source .venv/bin/activate # or .venv\Scripts\Activate.ps1 on Windows
pip install -e .Or with uv directly (no system Python needed — uv downloads Python automatically):
uv venv --python 3.12.9 .venv
uv pip install -e .Full example:
./sqlite-mcp/install.shStart server
& ".\Project Memory\.venv\Scripts\python.exe" -m sqlite_mcp_serverPaths
Project Memory/.venv— virtual environment (pinned Python 3.12.9)Project Memory/.uv/bin/uv[.exe]— uv runtime manager (downloaded by installer)Project Memory/.uv/python/— pinned CPython interpreter (fetched by uv on first run)Project Memory/pm_data/project_memory.dbProject Memory/pm_exports.vscode/mcp.json.vscode/settings.jsonmay also be created automatically by Copilot/VS Code withchat.mcp.serverSamplingentries forsqlite-project-memory; this is expected.
To override the pinned Python version:
$env:SQLITE_MCP_PYTHON_VERSION = "3.13.0"; .\sqlite-mcp\install.ps1SQLITE_MCP_PYTHON_VERSION=3.13.0 ./sqlite-mcp/install.shCLI tools
sqlite-project-memory-admin bootstrap-self --repo-root .
sqlite-project-memory-admin project-state
sqlite-project-memory-admin health
sqlite-project-memory-admin sync-document architecture --input-path architecture.md
sqlite-project-memory-admin sync-document decisions --input-path decisions.md
sqlite-project-memory-admin sync-document roadmap --input-path roadmap.md
sqlite-project-memory-admin export-views --user-requested --request-reason "User asked for a roadmap export" --require-existing-dir exports todo roadmap architecture
sqlite-project-memory-admin export-views --user-requested --request-reason "User asked for refreshed generated docs" --force todo roadmap architecture
sqlite-project-memory-admin export-json --output-path exports/project_memory.snapshot.json
sqlite-project-memory-admin import-json --input-path exports/project_memory.snapshot.jsonConfiguration
Environment variables:
SQLITE_MCP_PROJECT_ROOTSQLITE_MCP_DB_PATHSQLITE_MCP_EXPORT_DIRSQLITE_MCP_TRANSPORT(stdioorstreamable-http)SQLITE_MCP_LOG_LEVEL(INFOdefault)SQLITE_MCP_LOG_FORMAT(jsonortext)
Post-install hook
Create
.scripts/post_install.ps1(PowerShell) or.scripts/post_install.sh.The install script executes the hook if present.
Quick start (Windows)
Clone the repo into your project.
Run the installer:
git clone https://github.com/WebRTCGame/SQLITE-MCP.git sqlite-mcp .\sqlite-mcp\install.ps1After install, ensure VS Code is opened at the parent project root (for example
C:\CODE\TestProject), notC:\CODE\TestProject\sqlite-mcp.Activate runtime venv:
& ".\Project Memory\.venv\Scripts\Activate.ps1"Run self-check:
sqlite-project-memory-admin --db-path "Project Memory/pm_data/project_memory.db" project-state sqlite-project-memory-admin --db-path "Project Memory/pm_data/project_memory.db" healthStart the server:
python -m sqlite_mcp_server
Quick start (Linux/macOS)
Clone the repo into your project.
Run the installer:
git clone https://github.com/WebRTCGame/SQLITE-MCP.git sqlite-mcp chmod +x ./sqlite-mcp/install.sh ./sqlite-mcp/install.shAfter install, ensure VS Code is opened at the parent project root, not the
sqlite-mcpsubfolder.Activate runtime venv:
source "Project Memory/.venv/bin/activate"Run self-check:
sqlite-project-memory-admin --db-path "Project Memory/pm_data/project_memory.db" project-state sqlite-project-memory-admin --db-path "Project Memory/pm_data/project_memory.db" healthStart the server:
python -m sqlite_mcp_server
Notes
render_markdown_views/export_markdown_viewsrequireuser_requested=trueandrequest_reason.sync-documentis anchored (no unstructured free-text record in roadmap state).project_stateandhealthare primary diagnostics.
AI-first design
Write entities/content through MCP tools.
Generate docs only on explicit user request.
Add AI instructions to your project
After running the installer, paste the snippet below into your AI instructions file
(copilot-instructions.md, AGENTS.md, CLAUDE.md, or equivalent).
The installer also prints this snippet to the terminal as a reminder.
## SQLite Project Memory
This project uses the **`sqlite-project-memory` MCP server** as the single source of truth for all project state.
### Mandatory rules
- **NEVER** create, modify, or delete `.md` files for notes, tasks, decisions, roadmaps, or architecture.
- **ALWAYS** use `sqlite-project-memory` MCP tools to store and retrieve project knowledge.
- `README.md` is the **only** markdown file you may edit directly.
- Files in `Project Memory/pm_exports/` are read-only derived artifacts — never edit them directly.
### Tool usage guide
| Intent | Tool to use |
|--------|-------------|
| Add a task / todo | `create_entity` (entity_type: `task`) |
| Record a decision | `create_entity` (entity_type: `decision`) |
| Document a component | `create_entity` (entity_type: `component`) + `write_content` |
| Add a note to an item | `write_content` or `append_content` |
| Query project state | `query_view`, `list_entities`, `get_entity` |
| Search knowledge | `search_content` |
| Link two items | `add_relationship` or `connect_entities` |
| Export to markdown | `export_markdown_views` with `user_requested: true` — only when explicitly asked |
### First action each session
Before making changes, call `get_project_context` to confirm the database path and project root, then call `get_recent_activity` or `query_view` to orient yourself.Usage gates checklist
For best reliability, confirm all of the following:
.vscode/mcp.jsoncontains thesqlite-project-memoryserver.VS Code MCP approval/trust prompt was accepted for this workspace.
Chat is in Agent mode (not regular chat/edit mode).
Project Memoryagent is available in the agents dropdown./sqlite-project-memoryskill is available in slash commands.Your project instructions file includes the SQLite Project Memory snippet.
Start each session with
get_project_contextthenget_recent_activityorquery_view.
The installer prints a Usage Gates Report with PASS or ACTION REQUIRED for the gates it can validate automatically.
If tools still do not appear, first fully reload or restart VS Code and start a new Agent chat session.
If the server is not already running after restart, run MCP: Start Server from the Command Palette, select sqlite-project-memory, and restart the chat session.
Available Tools
41 toolsadd_relationshipC
Create a typed graph edge between two entities.
Inputs: relationship_id (required), from_entity (required), to_entity (required), relationship_type (required). Returns: object
append_contentD
Add a piece of content to an entity.
Inputs: entity_id (required), content_type (required), body (required), content_id. Returns: object
apply_performance_tuningC
Tune SQLite settings for throughput during heavy project-memory workloads.
Inputs: journal_mode, synchronous, temp_store, cache_size, +2 more. Returns: object
archive_entityA
Archive an entity without deleting its history or related project memory.
Inputs: entity_id (required), reason, archived_status. Returns: object
bootstrap_project_memoryC
Initialize a project root entity and standard memory-area anchor entities.
Inputs: project_id (required), project_name (required), description, tags. Returns: object
connect_entitiesC
Create a relationship if missing, otherwise return the existing edge.
Inputs: from_entity (required), to_entity (required), relationship_type (required), relationship_id. Returns: object
create_entityC
Create a new authoritative project entity.
Inputs: entity_id (required), entity_type (required), name, description, +3 more. Returns: object
create_snapshotC
Create a named snapshot of current project state.
Inputs: snapshot_id (required), name (required), description, entity_ids. Returns: object
delete_entityA
Delete an entity with guardrails; non-forced deletion requires prior archiving and no critical dependents.
Inputs: entity_id (required), force. Returns: object
delete_relationshipB
Delete a relationship by id and record the removal in project history.
Inputs: relationship_id (required). Returns: object
export_markdown_viewsB
Write generated markdown views only after an explicit user request for a human-readable artifact.
Inputs: view_names, output_dir, overwrite, require_existing_dir, +2 more. Returns: object
find_similar_entitiesB
Find likely duplicate or related entities before creating a new one.
Inputs: name (required), entity_type, limit. Returns: result
get_architecture_summaryB
Return a compact architecture-oriented node and relationship summary.
Inputs: node_limit, relationship_limit, compact. Returns: object
get_database_healthB
Report likely duplicates, low-quality records, and retention pressure in project memory.
Inputs: limit. Returns: object
get_decision_logB
Return decisions and recent supporting note excerpts without requiring ad hoc SQL.
Inputs: limit, offset, compact. Returns: object
get_dependency_viewC
Return dependency-oriented graph data with stable compact fields.
Inputs: root_entity_id, max_depth, relationship_types, limit, +1 more. Returns: object
get_entityC
Fetch an entity and optionally include related metadata, content, and events.
Inputs: entity_id (required), include_related. Returns: object
get_entity_graphC
Traverse outward relationship dependencies from an entity.
Inputs: entity_id (required), max_depth, relationship_type, edge_limit, +2 more. Returns: object
get_or_create_entityB
Reuse an exact entity when it already exists or create one with a generated stable id.
Inputs: entity_type (required), name (required), entity_id, description, +3 more. Returns: object
get_project_contextA
Return the current project root, DB path, and export directory.
Inputs: no named parameters. Returns: object
get_recent_activityC
Return recent entities, content, and events to help an AI resume context quickly.
Inputs: limit, offset, compact. Returns: object
get_recent_reasoningC
Return recent reasoning excerpts for quick AI context recovery.
Inputs: limit, offset, compact. Returns: object
get_snapshotB
Fetch a named snapshot and its captured entities.
Inputs: snapshot_id (required). Returns: object
list_entitiesC
List entities with optional type, status, attribute, tag, and text filters.
Inputs: entity_type, status, attribute_key, attribute_value, +4 more. Returns: result
list_relationshipsC
List graph edges, optionally constrained to an entity and direction.
Inputs: entity_id, relationship_type, direction, limit. Returns: result
list_viewsB
List available view names for query_view discovery.
Inputs: no named parameters. Returns: result
merge_entitiesB
Merge a duplicate source entity into a target entity with deterministic conflict handling.
Inputs: source_entity_id (required), target_entity_id (required), attribute_conflict. Returns: object
prune_content_retentionC
Prune older reasoning/log content while keeping the most recent records per entity and type.
Inputs: content_types, keep_latest, entity_id, dry_run. Returns: object
query_viewB
Query a named SQL view for generic reporting and model projections.
Inputs: view_name (required), params. Returns: object
refresh_task_summaryB
Rebuild a task summary materialized table for faster open task queries.
Inputs: no named parameters. Returns: object
render_markdown_viewsA
Render markdown document views only after an explicit user request for a human-readable artifact.
Inputs: view_names, user_requested, request_reason. Returns: object
resolve_entity_by_nameC
Resolve a human-readable name to an existing entity when possible.
Inputs: name (required), entity_type, limit. Returns: object
run_read_queryC
Run a constrained read-only SQL query for diagnostics, analytics, and ad hoc retrieval.
Inputs: sql (required), parameters, limit. Returns: object
search_contentC
Search narrative content using FTS5 when available.
Inputs: query (required), limit. Returns: result
server_infoB
Return server metadata and schema settings.
Inputs: no named parameters. Returns: object
set_project_rootB
Switch project context (root + db + export path) and reconnect database.
Inputs: project_root (required). Returns: object
set_tagsC
Set or merge tag labels for an entity.
Inputs: entity_id (required), tags (required), replace. Returns: object
update_entityC
Update an existing entity's top-level state.
Inputs: entity_id (required), name, description, status. Returns: object
upsert_attributesB
Create or update flexible metadata for an entity.
Inputs: entity_id (required), attributes (required), replace. Returns: object
upsert_entityC
Create an entity if missing or merge updates into an existing entity.
Inputs: entity_id (required), entity_type (required), name, description, +5 more. Returns: object
write_contentC
Write narrative content in one unified API with append|replace semantics.
Inputs: entity_id (required), mode (required), content (required), content_type (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 41 tools
The tools cover distinct operations like entity management, graph relationships, content handling, and queries, but there is notable overlap in some areas. For example, create_entity, get_or_create_entity, and upsert_entity have overlapping purposes for entity creation, and append_content vs. write_content could cause confusion in content addition. Descriptions help clarify, but agents might misselect between these similar tools.
Most tools follow a consistent verb_noun or verb_adjective_noun pattern (e.g., create_entity, list_entities, get_entity_graph), with clear and descriptive names. There are minor deviations like server_info (noun_verb) and apply_performance_tuning (verb_noun_noun), but overall the naming is predictable and readable across the set.
With 41 tools, the count is excessive for a project memory server, leading to potential cognitive overload and inefficiency. While the domain is broad, many tools could be consolidated or streamlined (e.g., multiple entity creation tools, overlapping content tools), making it feel heavy and less well-scoped than ideal for agent use.
The tool set provides comprehensive coverage for project memory management, including full CRUD operations for entities and relationships, content handling, graph traversal, queries, snapshots, health checks, and context management. There are no obvious gaps; agents can perform all core workflows from initialization to archiving and reporting without dead ends.
Maintenance
Related MCP Connectors
Shared project memory for people and AI agents: documents, ERD, diagrams, boards, design mockups.
Project memory, documentation and controlled secret access for AI coding agents.
The system of record for AI agents — open-source (MIT) database where agents and people share data.
Project memory for coding agents: requirements, decisions, code graph and delivery telemetry.
Related MCP Servers
- AlicenseAqualityDmaintenanceA knowledge graph memory server using SQLite to provide persistent, isolated contexts for organizing information into searchable categories like work and personal projects. It features unique ID-based operations and a token-efficient serialization format designed to optimize interactions with LLMs.11MIT
- AlicenseNot gradedqualityDmaintenanceA persistent AI memory server that enables storage and retrieval of context and project artifacts across conversations. It features full-text search, version history, and automatic content chunking using local SQLite or hosted cloud storage.13 npmApache 2.0
- AlicenseNot gradedqualityDmaintenanceA persistent memory server for AI agents that stores structured notes in a local SQLite database with full-text search and graph-based relationships. It features 32 specialized tools for managing long-term context, including version history, automated TTL expiration, and complex filtering.12 npmMIT
- AlicenseNot gradedqualityDmaintenanceA database-backed MCP server that acts as a project memory bank, enabling AI assistants to store, retrieve, and search structured context like decisions, tasks, and architecture using SQLite and vector embeddings.Apache 2.0