mindpm

Gestión persistente de proyectos y tareas para asistentes de codificación de IA. Realiza un seguimiento de tareas, decisiones y notas entre sesiones con un tablero Kanban en tiempo real. Funciona con Claude Code, Cursor, Cline, Copilot y Windsurf.

GitHub

Prueba este MCPPatrocinado

Documentación

mindpm

Memoria persistente de proyectos para LLMs. Nunca vuelvas a explicar tu proyecto.

mindpm es un servidor MCP (Model Context Protocol) que les da a los LLMs un cerebro respaldado por SQLite para tus proyectos. Realiza un seguimiento de tareas, decisiones, notas de arquitectura y contexto de sesión, para que cada nueva conversación continúe exactamente donde la dejaste.

El Problema

Cada nuevo chat con un LLM comienza desde cero:

"Déjame recordarte sobre mi proyecto..."
"La última vez decidimos usar Redis para..."
"¿Dónde lo dejamos?"

La Solución

mindpm persiste el estado de tu proyecto en una base de datos SQLite local. El LLM lee y escribe en ella a través de las herramientas MCP. No se necesita historial de chat. No se necesitan funciones de memoria.

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

Lo Que Rastrea

Tareas — estado, prioridad, bloqueos, subtareas
Decisiones — qué se decidió, por qué, qué alternativas fueron rechazadas
Notas — arquitectura, errores, ideas, investigación
Contexto — pares clave-valor (stack tecnológico, convenciones, configuración)
Sesiones — qué se hizo, qué sigue

Tablero Kanban

mindpm incluye una interfaz Kanban integrada. Cuando el servidor MCP se inicia, sirve una interfaz web en http://localhost:3131.

Cada llamada a start_session devuelve un enlace directo al tablero de tu proyecto:

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

El puerto es configurable mediante la variable de entorno MINDPM_PORT.

Resumen de Sesión

get_project_status te dice qué estabas haciendo. El resumen de sesión te dice qué cambió mientras estabas ausente: commits realizados, la rama se movió, el árbol de trabajo se ensució, las tareas cambiaron de estado, aparecieron bloqueos, se registró una decisión.

Cada llamada a start_session incorpora un resumen automáticamente (pasa brief: false para omitirlo), y también puedes obtener uno sin abrir una sesión mediante get_session_brief. Es completamente determinista — no se realizan llamadas a LLMs dentro de mindpm — y nunca toca la red: todo proviene de subprocesos locales de git y de la base de datos SQLite local.

Para obtener actividad de git en el resumen, indícale a mindpm dónde está tu repositorio:

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

(o pasa repo_path directamente a create_project). Sin un repositorio configurado, el resumen aún informa el delta de tareas/bloqueos/decisiones — solo omite la sección de git.

Ejemplo de salida:

{
  "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 es same-day (<6h), overnight (6-20h), multi-day (20h-14d), or stale (>14d) — una brecha obsoleta agrega un gap.hint que le indica al agente re-verificar el contexto en lugar de confiar en next_steps a primera vista.

El delta de git está anclado en el sha exacto del commit registrado cuando terminó la sesión anterior (mediante end_session), no en una marca de tiempo — el anclaje basado en sha sobrevive a rebases y enmiendas que romperían un diff basado en reloj. Si ese sha se vuelve inalcanzable (force-push, rebase, o el repositorio fue podado), el resumen cae de forma transparente a un ancla de marca de tiempo y lo reporta en degraded_reasons. Un repositorio roto o faltante nunca falla el resumen — solo regresa con git.available: false y degraded: true, mientras que el delta de tareas/bloqueos/decisiones no se ve afectado.

Configuración

Instalación

npm install -g mindpm

O ejecuta desde el código fuente:

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

Configura tu cliente MCP

Todos los clientes usan el mismo formato JSON — solo difieren las ubicaciones de los archivos de configuración. Todos comparten el mismo ~/.mindpm/memory.db, por lo que puedes cambiar de herramienta a mitad de proyecto sin perder contexto.

Claude Code — ~/.claude/claude_desktop_config.json

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

O usa el comando de una línea:

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

Cursor — .cursor/mcp.json en la raíz de tu proyecto (o ~/.cursor/mcp.json globalmente)

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

VS Code + Copilot — .vscode/mcp.json en la raíz de tu proyecto

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

Cline — Agrégalo mediante Configuración de VS Code → Cline → Servidores MCP, o edita cline_mcp_settings.json:

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

Windsurf — Configuración → Cascade → MCP, usando la misma estructura JSON que Cline arriba.

Usando mindpm con cualquier LLM

En la primera ejecución, mindpm escribe ~/.mindpm/AGENT.md — un prompt de sistema listo para pegar que le dice a tu LLM cómo usar mindpm de forma proactiva. Pega su contenido en las instrucciones personalizadas o en el cuadro de prompt de sistema de tu cliente.

También puedes llamar a la herramienta get_agent_instructions en cualquier momento para recuperar las instrucciones.

Comienza a Usar

Eso es todo. El LLM ahora tiene acceso a las herramientas de mindpm. Solo comienza a hablar sobre tus proyectos.

Herramientas MCP

Proyectos

Herramienta	Descripción
`create_project`	Crear un nuevo proyecto
`list_projects`	Listar todos los proyectos
`get_project_status`	Vista general completa del proyecto
`set_project_repo_path`	Establecer/actualizar la ruta del repositorio git local del proyecto (habilita el delta de git del resumen de sesión)

Tareas

Herramienta	Descripción
`create_task`	Agregar una tarea
`update_task`	Actualizar estado, prioridad, etc.
`list_tasks`	Listar con filtros
`get_task`	Detalle completo de la tarea con subtareas y notas
`get_next_tasks`	Inteligente: mayor prioridad, sin bloqueos

Decisiones

Herramienta	Descripción
`log_decision`	Registrar una decisión con razonamiento
`list_decisions`	Explorar el historial de decisiones

Notas y Contexto

Herramienta	Descripción
`add_note`	Agregar una nota (arquitectura, error, idea, etc.)
`search_notes`	Búsqueda de texto completo
`set_context`	Almacenar contexto clave-valor
`get_context`	Recuperar contexto

Sesiones

Herramienta	Descripción
`start_session`	Obtener contexto completo del proyecto + próximos pasos de la última sesión + resumen de sesión
`end_session`	Registrar resumen + qué hacer la próxima vez
`get_session_brief`	Solo lectura: qué cambió desde que terminó la última sesión, sin abrir una sesión

Consulta

Herramienta	Descripción
`query`	SQL de solo lectura contra la base de datos
`get_project_summary`	Tareas por estado, bloqueos, actividad reciente
`get_blockers`	Todas las tareas bloqueadas con qué las está bloqueando
`search`	Búsqueda de texto completo en todo

Cómo Funciona

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

Comienzas una conversación y mencionas tu proyecto
El LLM llama a start_session → obtiene contexto completo
Durante la conversación, crea tareas, registra decisiones, agrega notas
Cuando terminas, llama a end_session → guarda qué sigue
Siguiente conversación: contexto instantáneo, cero re-explicación

Almacenamiento

Predeterminado: ~/.mindpm/memory.db

Anula con la variable de entorno MINDPM_DB_PATH o PROJECT_MEMORY_DB_PATH.

La base de datos y las tablas se crean automáticamente en la primera ejecución.

Desarrollo

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

Licencia

MIT