About Mindpm
mindpm is a local, SQLite-backed MCP server that keeps project context available across LLM sessions. It tracks tasks, decisions, notes, and agent attempts, and supports handing specified work to coding agents with human acceptance.
Key features
- 01Persistent project context in SQLite
- 02Task specs, priorities, and blockers
- 03Decision and architecture notes
- 04Session handoffs and change briefs
- 05Leased task claims for parallel agents
- 06Human acceptance and optional verification
Use cases
- 01Resuming work in a new LLM session
- 02Recording project decisions and next steps
- 03Assigning specified tasks to coding agents
- 04Coordinating parallel agent work
MCP support
mindpm exposes project memory through MCP tools that LLMs use to read and update the local SQLite database. It also provides task handoffs for coding agents and a local Kanban board.
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
npx -y mindpmMINDPM_DB_PATHPath to the SQLite database fileMINDPM_PORTPort for the built-in Kanban board UIMINDPM_HOSTInterface the Kanban UI binds to. Loopback by default; set 0.0.0.0 only to opt in (e.g. under WSL2 NAT)Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.
Tools
24Saved tool list · updated 3w ago
| Parameter | Type | Required | Description |
|---|---|---|---|
| name | string | Yes | Project name (unique) |
| description | string | No | What this project is about |
| tech_stack | array | No | Technologies used, e.g. ["FastAPI", "React", "PostgreSQL"] |
| repo_path | string | No | Path to the project repository |
Details
From the project READMEmindpm
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?"
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 mindpm
That'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
- Advanced: unattended agents and verification
- Security model
- MCP tools
- Development
- Changelog
License
MIT
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.