mindpm
mindpm is a SQLite-backed MCP server that gives LLMs persistent project memory and tools for tracking projects, tasks, decisions, notes, sessions, and delivery metrics.
Create, list, inspect, and update projects (name, repo path, tech stack, status).
Create, update, list, and get details on tasks, including priorities, tags, blockers, sub-tasks, and statuses.
Find next tasks, blockers, project status, and high-level project summaries.
Record and list decisions with reasoning, alternatives, and tags.
Add, search, and categorize notes for architecture, bugs, ideas, research, meetings, and reviews.
Set and get key-value project context.
Start and end work sessions, save summaries and next steps, and get session briefs (git changes, task changes, decisions, notes).
Run read-only SQL SELECT queries and full-text search across tasks, notes, and decisions.
Get DORA-inspired delivery metrics and recommended agent instructions.
Reads the local git repository of a tracked project (commit history, current branch, and working-tree state) to include repository activity in the session brief and show what changed since the last session ended.
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., "@mindpm What should I work on next?"
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.
mindpm
Project memory and a control plane for AI coding agents.
mindpm is an MCP (Model Context Protocol) server that gives LLMs a SQLite-backed brain for your projects. It tracks tasks, decisions, architecture notes, and session context — so every new conversation picks up exactly where you left off. It also hands specced tasks to coding agents, keeps parallel agents from colliding, and only counts work as done once a human has accepted it. For agents that run unattended, an optional verifier reruns the checks itself first.
The Problem
Every new LLM chat starts from zero:
"Let me remind you about my project..."
"Last time we decided to use Redis for..."
"Where did we leave off?"
Related MCP server: Context Portal MCP (ConPort)
The Solution
mindpm persists your project state in a local SQLite database. The LLM reads and writes to it via MCP tools. No chat history needed. No memory features needed.
You: "What should I work on next?"
LLM: [queries mindpm] "Last session you finished the auth refactor.
You have 3 high-priority tasks: rate limiting, API docs, and
the webhook retry bug. Rate limiting is unblocked — start there."What It Tracks
Tasks, specs and acceptance criteria, with handoff statuses, priorities and blockers
Decisions: what was decided, why, and what was rejected
Notes and context: architecture, bugs, ideas, tech stack, conventions
Sessions: what was done and what's next, plus a brief of what changed while you were away
Agent attempts: every run on a task, and what the next attempt should avoid
Quick start
claude mcp add mindpm -e MINDPM_DB_PATH=~/.mindpm/memory.db -- npx -y mindpmThat's Claude Code, and npx fetches mindpm, so there's nothing to install first. Claude Desktop, Cursor, VS Code, Cline and Windsurf use the same JSON config in a different file. Then just talk about your project. The LLM calls start_session to load its context, records tasks, decisions and notes as you go, and calls end_session to save what's next. A Kanban board runs at http://localhost:3131.
How it works
┌──────────────┐ MCP ┌─────────┐ SQLite ┌───────────┐
│ Claude Code, │ ◄──────────► │ mindpm │ ◄────────────► │ memory.db │
│ Cursor, ... │ tools │ server │ read/write │ │
└──────────────┘ └─────────┘ └───────────┘Everything stays on your machine, in one SQLite file (~/.mindpm/memory.db by default). mindpm can also hand specced tasks to coding agents with no conversation context: claims with leases keep parallel agents from colliding, and you accept submitted work on the board. For agents that run unattended, an optional verifier reruns the checks on each submitted commit first.
Security: mindpm has no user accounts and can't stop a process on your own machine. An agent with a shell can call the board's routes as you or edit the database directly. Read the security model before you let agents run unattended.
Documentation
Full documentation: https://umitkavala.github.io/mindpm/
Setup: every MCP client, agent instructions for any LLM, storage
Kanban board: lanes, accepting work, network binding and WSL
Session brief: what changed while you were away
Agent execution: lifecycle, specs, claims and briefs
License
MIT
Available Tools
24 toolsadd_noteAdd NoteA
Add a note to a project or task. Proactively use this when the user shares context about architecture, bugs, ideas, research findings, or any important information worth remembering. Always specify the project parameter when you know which project is active.
Inputs: content (required), tags, project, task_id, +1 more.
create_projectCreate ProjectA
Create a new project to track. Use this when starting a new project or when a user mentions a project that doesn't exist yet.
Inputs: name (required), repo_path, tech_stack, description.
create_taskCreate TaskA
Create a new task in a project. Proactively use this when the user mentions something that needs to be done, a bug to fix, or a feature to build.
Inputs: title (required), tags, project, priority, +2 more.
end_sessionEnd SessionA
End a work session with a summary of what was accomplished and what to do next. Call this when the user is done working.
Inputs: summary (required), project, next_steps, decisions_made, +1 more.
get_agent_instructionsGet Agent InstructionsA
Returns the recommended instructions for using mindpm effectively. Call this once if you are unsure how to use mindpm, or share it with the user to paste into other LLM clients.
Inputs: no named parameters.
get_blockersGet BlockersA
List all blocked tasks with what's blocking them.
Inputs: project.
get_contextGet ContextC
Get context by key or list all context for a project.
Inputs: key, project.
get_delivery_metricsGet Delivery MetricsA
DORA-inspired delivery metrics for a project: throughput, lead time, flow efficiency, and performance tier. Use to understand delivery health and trends.
Inputs: days, project.
get_next_tasksGet Next TasksA
Smart query: what should be worked on next? Returns highest priority non-blocked tasks for a project.
Inputs: limit, project.
get_project_statusGet Project StatusA
Get a full overview of a project: active tasks, recent decisions, blockers, and last session summary. Great for getting up to speed.
Inputs: project (required).
get_project_summaryGet Project SummaryB
High-level summary of a project: total tasks by status, recent activity, open blockers, and upcoming priorities.
Inputs: project.
get_session_briefGet Session BriefA
Read-only: what changed since the last session ended — commits, branch and working-tree state, task status changes, new blockers, decisions, and notes. Unlike start_session, this does not open a session or mark one as started.
Inputs: project.
get_taskGet TaskA
Get full detail for a specific task including sub-tasks and related notes.
Inputs: task_id (required).
list_decisionsList DecisionsB
List decisions for a project. Filter by tags to find specific decisions.
Inputs: tag, limit, project.
list_projectsList ProjectsA
List all tracked projects. Filter by status to see active, paused, completed, or archived projects.
Inputs: status.
list_tasksList TasksA
List tasks with filters. Defaults to showing non-completed tasks for the most recent active project.
Inputs: tag, limit, offset, status, +3 more.
log_decisionLog DecisionA
Record a decision with reasoning and alternatives considered. Proactively use this when the user makes a technical decision, chooses between options, or settles a debate.
Inputs: title (required), decision (required), tags, project, +3 more.
queryQuery DatabaseA
Execute a read-only SQL query against the database. Only SELECT statements are allowed. Use this for custom queries not covered by other tools.
Inputs: sql (required).
searchSearch EverythingA
Full-text search (FTS5, ranked by relevance) across tasks, notes, and decisions for a project.
Inputs: query (required), limit, project.
search_notesSearch NotesB
Full-text search across notes for a project.
Inputs: query (required), project, category.
set_contextSet ContextA
Set a key-value context pair for a project (upsert). Proactively use this when the user shares important project context like architecture decisions, config values, conventions, or constraints.
Inputs: key (required), value (required), project, category.
set_project_repo_pathSet Project Repo PathA
Set or update the local git repository path for a project. Required for the session brief to include git activity (commits, branch, working-tree state) since the last session.
Inputs: project (required), repo_path (required).
start_sessionStart SessionA
Begin a work session for a project. Returns the full project overview including last session's next_steps, active tasks, blockers, and recent decisions. Call this at the start of every conversation. For multi-project conversations, call once per project — after that, pass project explicitly on every tool call. IMPORTANT: Always show the kanban_url to the user as a clickable link so they can open the Kanban board.
Inputs: brief, project.
update_taskUpdate TaskA
Update any field of a task. Proactively use this when a task status changes, priorities shift, or new information comes in.
Inputs: task_id (required), tags, title, status, +4 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Most tools target distinct resources and actions, but there is meaningful overlap: search_notes is a subset of the broader search tool, and get_project_status, get_project_summary, and start_session all provide similar project overview information. The descriptions help, but an agent could reasonably pick the wrong one in some situations.
The vast majority of tools follow a clear verb_noun snake_case pattern, like create_project, list_tasks, get_context, and start_session. The main deviations are the bare verbs 'search' and 'query', which are still understandable but break the otherwise consistent convention.
24 tools is on the heavy side, though the domain is broad: projects, tasks, decisions, notes, context, sessions, metrics, and search all have dedicated surfaces. Several tools could be consolidated (e.g., search_notes into search, get_project_status into get_project_summary), which would make the set tighter.
Core task lifecycle coverage is solid: create, update, list, get, and next-task prioritization all exist. However, project lifecycle is incomplete (no update or archive project tool), and notes/decisions support creation/listing/searching but not updating or deleting, which leaves notable workflow gaps.
Maintenance
Related MCP Connectors
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Remote MCP server for notes, tasks, kanban boards and docs - the Slates agentic workspace
Shared memory for your AI tools: tasks, notes and context every tool can read and write over MCP.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA self-hosted MCP server that provides AI assistants with a shared, persistent SQLite-backed memory for storing and retrieving project context, decisions, and discoveries. It enables cross-session continuity and team-wide knowledge sharing to keep AI coding tools aligned and informed.3MIT
- 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
- AlicenseAqualityCmaintenanceMCP server providing structured continuity memory for AI coding agents, tracking decisions, open loops, and session state in local SQLite. Enables agents to resume work from verified state across sessions without replaying transcripts.17Apache 2.0
- AlicenseNot gradedqualityBmaintenanceA structured project memory MCP server that persists plans, builds, reviews, and decisions across AI coding sessions and tools, enabling continuous project management with a dashboard.11MIT