Skip to main content
Glama

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 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/

License

MIT

Available Tools

24 tools
add_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).

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

    B3.4/5.0

    Scored across 24 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count3/5

    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.

    Completeness3/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A 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.
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A 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
    • A
      license
      A
      quality
      C
      maintenance
      MCP 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.
      17
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      A 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.
      11
      MIT