mindpm

Gerenciamento persistente de projetos e tarefas para assistentes de codificação de IA. Acompanhe tarefas, decisões e anotações entre sessões com um quadro Kanban em tempo real. Funciona com Claude Code, Cursor, Cline, Copilot e Windsurf.

GitHub

Documentação

mindpm

Memória persistente de projetos para LLMs. Nunca mais re-explique seu projeto.

mindpm é um servidor MCP (Model Context Protocol) que dá aos LLMs um cérebro baseado em SQLite para seus projetos. Ele rastreia tarefas, decisões, notas de arquitetura e contexto de sessão — para que cada nova conversa continue exatamente de onde parou.

O Problema

Cada novo chat de LLM começa do zero:

"Deixe-me lembrar você sobre meu projeto..."
"Da última vez decidimos usar Redis para..."
"Onde paramos?"

A Solução

mindpm persiste o estado do seu projeto em um banco de dados SQLite local. O LLM lê e escreve nele via ferramentas MCP. Sem necessidade de histórico de chat. Sem necessidade de recursos de memória.

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."

O Que Ele Rastreia

Tarefas — status, prioridade, bloqueadores, subtarefas
Decisões — o que foi decidido, porquê, quais alternativas foram rejeitadas
Notas — arquitetura, bugs, ideias, pesquisa
Contexto — pares chave-valor (stack de tecnologia, convenções, configuração)
Sessões — o que foi feito, o que vem a seguir

Quadro Kanban

mindpm inclui uma UI Kanban integrada. Quando o servidor MCP inicia, ele serve uma interface web em http://localhost:3131.

Cada chamada start_session retorna um link direto para o quadro do seu projeto:

Kanban board: http://localhost:3131?project=<project-id>

A porta é configurável via a variável de ambiente MINDPM_PORT.

Resumo de Sessão

get_project_status diz o que você estava fazendo. O resumo de sessão diz o que mudou enquanto você estava fora — commits foram feitos, o branch mudou, a árvore de trabalho ficou suja, tarefas mudaram de status, bloqueadores apareceram, uma decisão foi registrada.

Cada chamada start_session incorpora um resumo automaticamente (passe brief: false para ignorá-lo), e você também pode buscar um sem abrir uma sessão via get_session_brief. É totalmente determinístico — nenhuma chamada de LLM acontece dentro do mindpm — e nunca toca na rede: tudo vem de subprocessos git locais e do banco de dados SQLite local.

Para obter atividade git no resumo, diga ao mindpm onde seu repositório está:

set_project_repo_path(project: "my-app", repo_path: "/Users/you/code/my-app")

(ou passe repo_path diretamente para create_project). Sem um repositório configurado, o resumo ainda relata o delta de tarefas/bloqueadores/decisões — apenas pula a seção git.

Exemplo de saída:

{
  "project": "my-app",
  "degraded": false,
  "degraded_reasons": [],
  "gap": {
    "last_session_ended_at": "2026-08-08T22:14:03.000Z",
    "hours_elapsed": 11.3,
    "label": "overnight"
  },
  "handoff": {
    "last_session_summary": "Finished the auth refactor",
    "next_steps": "Wire up rate limiting, then tackle the webhook retry bug"
  },
  "git": {
    "available": true,
    "anchor": "sha",
    "branch_then": "feat/phase-3",
    "branch_now": "feat/phase-3",
    "branch_changed": false,
    "commits": [
      { "sha": "a1b2c3d", "author": "umit", "date": "2026-08-09T09:02:11+00:00", "subject": "Add rate limit middleware" }
    ],
    "commit_count": 4,
    "commits_truncated": false,
    "files_changed": [
      { "path": "src/middleware/rate-limit.ts", "added": 82, "deleted": 11 }
    ],
    "files_changed_truncated": false,
    "working_tree_dirty": true,
    "untracked_count": 2,
    "stash_count": 0
  },
  "tasks": {
    "changed": [
      { "id": "a1b2c3d4", "title": "Add rate limiting", "from_status": "in_progress", "to_status": "done", "at": "2026-08-09T09:05:00.000Z" }
    ],
    "in_progress_now": [{ "id": "e5f6a7b8", "title": "Webhook retry bug" }],
    "next_suggested": [{ "id": "c9d0e1f2", "title": "Write API docs", "priority": "high" }]
  },
  "blockers": [],
  "decisions_since": [
    { "id": "9f8e7d6c", "title": "Use token bucket for rate limiting", "at": "2026-08-09T09:00:00.000Z" }
  ],
  "notes_since_count": 3
}

gap.label é same-day (<6h), overnight (6-20h), multi-day (20h-14d), or stale (>14d) — uma lacuna obsoleta adiciona um gap.hint dizendo ao agente para re-verificar o contexto em vez de confiar em next_steps pelo valor de face.

O delta git é ancorado no commit sha exato registrado quando a sessão anterior terminou (via end_session), não em um timestamp — a ancoragem baseada em sha sobrevive a rebases e amends que quebrariam um diff baseado em relógio. Se esse sha se tornar inalcançável (force-push, rebase, ou o repositório foi podado), o resumo transparentemente cai para uma âncora de timestamp e a reporta em degraded_reasons. Um repositório quebrado ou ausente nunca falha o resumo — apenas retorna com git.available: false e degraded: true, enquanto o delta de tarefas/bloqueadores/decisões não é afetado.

Configuração

Instalação

npm install -g mindpm

Ou rode a partir do código-fonte:

git clone https://github.com/umitkavala/mindpm.git
cd mindpm
npm install
npm run build

Configure seu cliente MCP

Todos os clientes usam o mesmo formato JSON — apenas locais de arquivo de configuração diferentes. Todos compartilham o mesmo ~/.mindpm/memory.db, então você pode trocar de ferramenta no meio do projeto sem perder contexto.

Claude Code — ~/.claude/claude_desktop_config.json

{
  "mcpServers": {
    "mindpm": {
      "command": "mindpm",
      "env": {
        "MINDPM_DB_PATH": "~/.mindpm/memory.db",
        "MINDPM_PORT": "3131"
      }
    }
  }
}

Ou use o one-liner:

claude mcp add mindpm -e MINDPM_DB_PATH=~/.mindpm/memory.db -- npx -y mindpm

Cursor — .cursor/mcp.json na raiz do seu projeto (ou ~/.cursor/mcp.json globalmente)

{
  "mcpServers": {
    "mindpm": {
      "command": "npx",
      "args": ["-y", "mindpm"],
      "env": {
        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
      }
    }
  }
}

VS Code + Copilot — .vscode/mcp.json na raiz do seu projeto

{
  "servers": {
    "mindpm": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mindpm"],
      "env": {
        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
      }
    }
  }
}

Cline — Adicione via Configurações do VS Code → Cline → MCP Servers, ou edite cline_mcp_settings.json:

{
  "mcpServers": {
    "mindpm": {
      "command": "npx",
      "args": ["-y", "mindpm"],
      "env": {
        "MINDPM_DB_PATH": "~/.mindpm/memory.db"
      }
    }
  }
}

Windsurf — Configurações → Cascade → MCP, usando a mesma estrutura JSON do Cline acima.

Usando mindpm com qualquer LLM

Na primeira execução, mindpm escreve ~/.mindpm/AGENT.md — um prompt de sistema pronto para colar que diz ao seu LLM como usar mindpm proativamente. Cole seu conteúdo no campo de instruções personalizadas ou prompt de sistema do seu cliente.

Você também pode chamar a ferramenta get_agent_instructions a qualquer momento para recuperar as instruções.

Comece a Usar

É isso. O LLM agora tem acesso às ferramentas do mindpm. Apenas comece a falar sobre seus projetos.

Ferramentas MCP

Projetos

Ferramenta	Descrição
`create_project`	Criar um novo projeto
`list_projects`	Listar todos os projetos
`get_project_status`	Visão geral completa do projeto
`set_project_repo_path`	Definir/atualizar o caminho do repositório git local do projeto (habilita o delta git do resumo de sessão)

Tarefas

Ferramenta	Descrição
`create_task`	Adicionar uma tarefa
`update_task`	Atualizar status, prioridade, etc.
`list_tasks`	Listar com filtros
`get_task`	Detalhe completo da tarefa com subtarefas e notas
`get_next_tasks`	Inteligente: maior prioridade, desbloqueada

Decisões

Ferramenta	Descrição
`log_decision`	Registrar uma decisão com justificativa
`list_decisions`	Navegar pelo histórico de decisões

Notas e Contexto

Ferramenta	Descrição
`add_note`	Adicionar uma nota (arquitetura, bug, ideia, etc.)
`search_notes`	Busca em texto completo
`set_context`	Armazenar contexto chave-valor
`get_context`	Recuperar contexto

Sessões

Ferramenta	Descrição
`start_session`	Obter contexto completo do projeto + próximos passos da última sessão + resumo de sessão
`end_session`	Registrar resumo + o que fazer na próxima vez
`get_session_brief`	Somente leitura: o que mudou desde o fim da última sessão, sem abrir uma sessão

Consulta

Ferramenta	Descrição
`query`	SQL somente leitura contra o banco de dados
`get_project_summary`	Tarefas por status, bloqueadores, atividade recente
`get_blockers`	Todas as tarefas bloqueadas com o que as está bloqueando
`search`	Busca em texto completo em tudo

Como Funciona

┌─────────────┐     MCP      ┌─────────┐     SQLite     ┌──────────┐
│  Claude Code │ ◄──────────► │ mindpm  │ ◄────────────► │ memory.db│
│  / Desktop   │   tools      │ server  │   read/write   │          │
└─────────────┘               └─────────┘                └──────────┘

Você inicia uma conversa e menciona seu projeto
O LLM chama start_session → obtém contexto completo
Durante a conversa, ele cria tarefas, registra decisões, adiciona notas
Quando você termina, ele chama end_session → salva o que vem a seguir
Próxima conversa: contexto instantâneo, zero re-explicação

Armazenamento

Padrão: ~/.mindpm/memory.db

Sobrescreva com a variável de ambiente MINDPM_DB_PATH ou PROJECT_MEMORY_DB_PATH.

Banco de dados e tabelas são criados automaticamente na primeira execução.

Desenvolvimento

npm install
npm run build       # Build with tsup
npm run typecheck   # Type-check without emitting
npm run dev         # Build in watch mode

Licença

MIT