Complex plan

MCP Complex Plans Server

Un servidor de Model Context Protocol (MCP) diseñado para mejorar los flujos de trabajo de IA con capacidades avanzadas de planificación y pensamiento secuencial. Este servidor permite a los agentes de IA crear planes estructurados, gestionar tareas de manera eficiente e integrarse sin problemas con entornos de desarrollo.

Nota

Esta herramienta se ha desarrollado principalmente para funcionar con Mistral Vibe CLI, pero debería funcionar con cualquier modelo compatible con MCP. Aunque no se ha probado exhaustivamente con otros modelos, ¡las contribuciones y las pruebas son bienvenidas!

Consejo

¡Elige modelos europeos cuando puedas, Europa es simplemente mejor! 🇪🇺

Características

• Creación y gestión de planes: Crea, actualiza, lista y elimina planes estructurados para tareas complejas
• Pensamiento secuencial: Herramienta integrada para resolución de problemas y análisis dinámico
• Configuración: Comportamiento personalizable mediante archivos de configuración, argumentos de CLI y variables de entorno
• Integración con Git: Gestión automática de .gitignore
• Integración con editores: Abre archivos en tu editor preferido para revisión

Todas las herramientas operan de forma segura dentro del directorio de planes configurado (por defecto .complex_plans) y se pueden usar tanto en modo chat como en modo plan.

Instalación

Configuración de Mistral Vibe CLI

Para usar este servidor con Mistral Vibe CLI, añade la siguiente configuración a tu ~/.vibe/config.toml:

Importante

¡Elimina la línea mcp_servers = [] de la parte superior del archivo para que esto funcione!

[[mcp_servers]]
name = "complex_plans"
transport = "stdio"
command = "npx"
args = ["-y", "@tuchsoft/mcp-complex-plans"]

[tools.complex_plans_createPlan]
permission = "always"
[tools.complex_plans_updatePlan]
permission = "always"
[tools.complex_plans_openInEditor]
permission = "always"
[tools.complex_plans_sequentialThinking]
permission = "always"
[tools.complex_plans_listPlans]
permission = "always"
[tools.complex_plans_readPlan]
permission = "always"
[tools.complex_plans_deletePlan]
permission = "ask"

Uso en modo plan/chat

Para usar las herramientas en modo plan/chat, crea o edita el archivo de configuración ~/.vibe/agents/plan.toml (y/o chat.toml):

enabled_tools = [
    "complex_plans_createPlan",
    "complex_plans_updatePlan",
    "complex_plans_openInEditor",
    "complex_plans_sequentialThinking",
    "complex_plans_readPlan",
    "complex_plans_listPlans"
]

Fragmento recomendado de System Prompt

Para obtener mejores resultados, edita tu system prompt para incluir un fragmento como el siguiente que indique al modelo cuándo usar esta herramienta:

**FOR COMPLEX, MULTI-FILE EDITS, ALWAYS GENERATE A MARKDOWN PLAN FIRST:** if the user request a complex task that require editing multiple files, traverse the project or make a lot of changes, **YOU MUST** create a markdown plan and ask the user to confirm it before proceeding, use the `complex_plans_createPlan` tool (and consequitive `complex_plans_readPlan`, `complex_plans_updatePlan`, `complex_plans_listPlans`, `complex_plans_openInEditor`, (optional) `complex_plans_deletePlan` tools).
**ALWAYS** ask the user to review and accept the plan after calling `complex_plans_openInEditor` and **BEFORE** doing anything else, do not proceed with the implementation until the user has accepted the plan.
Follow the instrucion provided by the tool itself.
Also if the user request a plan creation **ALWAYS** use the `complex_plans_createPlan` tool.

Opcionalmente, añade también este otro bloque para asegurar que la cadena de pensamiento se use siempre que sea posible:

**ALWAYS USE AN INTERNAL CHAIN OF THOUGHT**: Before answering to the user, writing code, editing a file, or performing whatever action, **always** use an internal chain of thought to verify your findings trough the use of the `complex_plans_sequentialThinking` tool.
Use as many tokens as you believe are necessary for your internal reasoning.
Output limit and verbosity constraints do not apply to your internal reasoning.
Always use the `complex_plans_sequentialThinking` tool for any task that is not a direct question-answer, as a rule of thumb if you are reading a file, you must also use the `complex_plans_sequentialThinking` tool.

Configuración de Claude Code

Para usar este servidor con Claude Code, añade lo siguiente a tu ~/.claude/claude.json (global) o .claude/settings.json (a nivel de proyecto):

Configuración global (~/.claude/claude.json):

{
  "mcpServers": {
    "complex_plans": {
      "command": "npx",
      "args": ["-y", "@tuchsoft/mcp-complex-plans", "--disabled-tools=sequentialThinking"]
    }
  }
}

O mediante la CLI de Claude Code:

claude mcp add complex_plans npx -- -y @tuchsoft/mcp-complex-plans --disabled-tools=sequentialThinking

Nota sobre sequentialThinking: Claude tiene razonamiento extendido nativo integrado. Se recomienda encarecidamente deshabilitar la herramienta sequentialThinking (como se muestra arriba) para evitar redundancias y conflictos con el propio razonamiento de Claude. Cuando está deshabilitada, la herramienta se elimina por completo del contexto de Claude — no quedan instrucciones visibles sobre ella.

Fragmento recomendado de CLAUDE.md

Añade esto al CLAUDE.md de tu proyecto para indicar a Claude cuándo usar las herramientas de planificación:

## Complex Plans

**FOR COMPLEX, MULTI-FILE EDITS, ALWAYS GENERATE A MARKDOWN PLAN FIRST:** If the user requests a complex task that requires editing multiple files, traversing the project, or making many changes, **YOU MUST** create a markdown plan and ask the user to confirm it before proceeding. Use the `complex_plans_createPlan` tool (and subsequent `complex_plans_readPlan`, `complex_plans_updatePlan`, `complex_plans_listPlans`, `complex_plans_openInEditor`, and optionally `complex_plans_deletePlan` tools).

**ALWAYS** ask the user to review and accept the plan after calling `complex_plans_openInEditor` and **BEFORE** doing anything else. Do not proceed with the implementation until the user has accepted the plan.

Follow the instructions provided by each tool. When asked to create a plan, always use `complex_plans_createPlan`.

**IMPORTANT**: Ignore the built-in `EnterPlanMode` and `ExitPlanMode` tools — use `complex_plans_createPlan` instead for all planning workflows.

Nota sobre instrucciones inyectadas: El servidor envía automáticamente un conjunto de instrucciones al modelo durante la inicialización (por ejemplo, usar el conjunto de herramientas complex_plans y, cuando auto_delete_plans está deshabilitado, tratar los planes existentes como datos históricos). Los fragmentos anteriores siguen siendo útiles como respaldo o para dar énfasis adicional.

Uso

1. El modelo debe decidir por sí mismo cuándo usar la herramienta cuando la tarea es compleja, larga o requiere editar muchos archivos.
2. Para forzar al modelo a crear un plan, simplemente incluye algo como Create a plan before implementing
3. Para editar un plan:
   • Puedes hacerlo manualmente editando el archivo del plan. La sección Additional user provided details es donde puedes proporcionar información adicional que el modelo haya omitido. Recuerda eliminar de la sección Risks/Doubts cualquier elemento para el que proporciones una respuesta clara.
   • Puedes pedirle al modelo que lo haga indicando Edit the plan to... (o Edit my XYZ plan to... si no estás en la misma conversación)

Configuración

El servidor admite múltiples métodos de configuración con el siguiente orden de prioridad (de mayor a menor):

1. Archivo de configuración a nivel de proyecto ([your_project]/<plans_dir>/config.json) - Prioridad más alta
2. Argumentos de CLI - Anulan las variables de entorno
3. Variables de entorno - Anulan los valores por defecto
4. Valores por defecto - Prioridad más baja

Opciones de configuración

Opción	Tipo	Por defecto	Argumento CLI	Variable de entorno	Descripción
default_editor	string	"zed"	--default-editor=	MCP_COMPLEX_PLANS_DEFAULT_EDITOR	Editor por defecto para abrir archivos
auto_delete_plans	boolean	false	--auto-delete-plans=	MCP_COMPLEX_PLANS_AUTO_DELETE_PLANS	Eliminar automáticamente los planes después de su implementación
add_to_gitignore	boolean	true	--add-to-gitignore=	MCP_COMPLEX_PLANS_ADD_TO_GITIGNORE	Añadir automáticamente el directorio de planes a .gitignore
plans_dir	string	".complex_plans"	--plans-dir=	MCP_COMPLEX_PLANS_PLANS_DIR	Nombre del directorio utilizado para almacenar los archivos de plan
disabled_tools	string[]	[]	--disabled-tools=	MCP_COMPLEX_PLANS_DISABLED_TOOLS	Lista de herramientas a deshabilitar (separadas por comas)

Ejemplos de configuración

Archivo de configuración (.complex_plans/config.json):

{
  "default_editor": "vscode",
  "auto_delete_plans": false,
  "add_to_gitignore": true,
  "plans_dir": ".complex_plans",
  "disabled_tools": ["listPlans"]
}

Argumentos de CLI:

node dist/index.js --default-editor=vscode --auto-delete-plans=false --plans-dir=.complex_plans --disabled-tools=listPlans,deletePlan

Variables de entorno:

export MCP_COMPLEX_PLANS_DEFAULT_EDITOR="vscode"
export MCP_COMPLEX_PLANS_AUTO_DELETE_PLANS="false"
export MCP_COMPLEX_PLANS_PLANS_DIR=".complex_plans"
export MCP_COMPLEX_PLANS_DISABLED_TOOLS="listPlans,deletePlan"

Herramientas

Herramientas disponibles

• createPlan: Crea planes estructurados para tareas complejas
• updatePlan: Modifica planes existentes usando bloques SEARCH/REPLACE
• deletePlan: Elimina planes completados u obsoletos
• listPlans: Lista todos los planes disponibles en el proyecto actual
• openInEditor: Abre archivos en tu editor configurado para revisión
• sequentialThinking: Herramienta de resolución de problemas y análisis dinámico

Pensamiento secuencial

La implementación del pensamiento secuencial se basa en sequentialthinking; para documentación detallada de la herramienta y patrones de uso, consulta ese repositorio.

Desarrollo

npm install
npm run build
npm link #To then test using npx as normal

Licencia

MIT