The MCP Chain of Thought server is an intelligent task management system for AI-driven project planning and execution. Key capabilities include:
Task Planning & Analysis: Analyze requirements, evaluate feasibility, and define success criteria
Step-by-Step Reasoning: Systematic problem-solving with process_thought
Task Decomposition: Break down complex tasks into manageable subtasks
Dependency Management: Handle task relationships, priorities, and track progress
Task Execution & Verification: Execute tasks and verify completion against criteria
Project Rules Management: Initialize and update project-specific guidelines
Task Operations: Search, update, delete, or query tasks by keyword or ID
Reporting: Generate completion reports and maintain task history
Interface Options: Optional web GUI and detailed conversation history mode
Enables installation of the MCP Chain of Thought server via npm packages, with support for project-specific configuration.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-chain-of-thought plan task for adding user authentication to our web app"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🚀 An intelligent task management system based on Model Context Protocol (MCP), providing an efficient programming workflow framework for AI Agents.
Related MCP server: MCP Shrimp Task Manager
🧠 Task Planning & Analysis: Deep understanding of complex task requirements
🧩 Intelligent Task Decomposition: Break down large tasks into manageable smaller tasks
🔄 Dependency Management & Status Tracking: Handle dependencies and monitor progress
✅ Task Verification: Ensure results meet requirements
💾 Task Memory: Store task history for reference and learning
⛓️ Thought Chain Process: Step-by-step reasoning for complex problems
📋 Project Rules: Define standards to maintain consistency
🌐 Web GUI: Optional web interface (enable with ENABLE_GUI=true)
📝 Detailed Mode: View conversation history (enable with ENABLE_DETAILED_MODE=true)
🔽 Installation: Install MCP Chain of Thought via Smithery or manually
🏁 Initial Setup: Tell the Agent "init project rules" to establish project-specific guidelines
📝 Plan Tasks: Use "plan task [description]" to create a development plan
👀 Review & Feedback: Provide feedback during the planning process
▶️ Execute Tasks: Use "execute task [name/ID]" to implement a specific task
🔄 Continuous Mode: Say "continuous mode" to process all tasks sequentially
💾 Task Memory: Automatically saves execution history for reference
🔄 Thought Chain: Enables systematic reasoning through process_thought tool
📋 Project Rules: Maintains consistency across your codebase
npx -y @smithery/cli install @liorfranko/mcp-chain-of-thought --client claudenpm install
npm run buildAdd to your Cursor configuration file (~/.cursor/mcp.json or project-specific .cursor/mcp.json):
{
"mcpServers": {
"chain-of-thought": {
"command": "npx",
"args": ["-y", "mcp-chain-of-thought"],
"env": {
"DATA_DIR": "/path/to/project/data", // Must use absolute path
"ENABLE_THOUGHT_CHAIN": "true",
"TEMPLATES_USE": "en",
"ENABLE_GUI": "true",
"ENABLE_DETAILED_MODE": "true"
}
}
}
}⚠️ Important:
DATA_DIRmust use an absolute path.
📁 DATA_DIR: Directory for storing task data (absolute path required)
🧠 ENABLE_THOUGHT_CHAIN: Controls detailed thinking process (default: true)
🌐 TEMPLATES_USE: Template language (default: en)
🖥️ ENABLE_GUI: Enables web interface (default: false)
📝 ENABLE_DETAILED_MODE: Shows conversation history (default: false)
Category | Tool | Description |
📋 Planning |
| Start planning tasks |
| Analyze requirements | |
| Step-by-step reasoning | |
| Improve solution concepts | |
| Set project standards | |
🧩 Management |
| Break into subtasks |
| Show all tasks | |
| Search tasks | |
| Show task details | |
| Remove tasks | |
▶️ Execution |
| Run specific tasks |
| Verify completion | |
| Mark as completed |
👑 Claude 3.7: Offers strong understanding and generation capabilities
💎 Gemini 2.5: Google's latest model, performs excellently
This project is licensed under the MIT License - see the LICENSE file for details.
Deeply analyze task requirements and systematically check the codebase, evaluate technical feasibility and potential risks. If code is needed, use pseudocode format providing only high-level logic flow and key steps, avoiding complete code.
Inputs: initialConcept (required), summary (required), previousAnalysis.
Clear unfinished tasks and reset the task list
Inputs: confirm (required).
Formally mark a task as completed, generate a detailed completion report, and update the dependency status of related tasks
Inputs: taskId (required), summary.
Delete unfinished tasks, but does not allow deleting completed tasks, ensuring the integrity of system records
Inputs: taskId (required).
Execute a specific task according to the predefined plan, ensuring the output of each step meets quality standards
Inputs: taskId (required).
Get the complete detailed information of a task based on its ID, including unabridged implementation guides and verification criteria, etc.
Inputs: taskId (required).
Initialize project rules. Call this tool when the user requests to generate or initialize the project specification file, or if the user requests to change or update the project specification.
Inputs: no named parameters.
Generate a structured task list, including complete status tracking, priority, and dependencies
Inputs: status (required).
Initialize and detail the task flow, establish clear goals and success criteria, optionally reference existing tasks for continuation planning
Inputs: description (required), existingTasksReference, requirements.
Engage in a flexible and evolving thinking process by creating, questioning, validating, and refining ideas to progressively deepen understanding and generate effective solutions. When needing to gather data, analyze, or research, prioritize reviewing relevant project code; if such code doesn't exist, search the web rather than speculating. Set nextThoughtNeeded to false when thinking is sufficient, otherwise adjust total_thoughts to extend the process
Inputs: next_thought_needed (required), stage (required), thought (required), thought_number (required), +4 more.
Search tasks by keyword or ID, displaying abbreviated task information
Inputs: query (required), isId, page, pageSize.
Critically review analysis results, evaluate solution completeness and identify optimization opportunities, ensuring the solution aligns with best practices. If code is needed, use pseudocode format providing only high-level logic flow and key steps, avoiding complete code.
Inputs: analysis (required), summary (required).
Decompose complex tasks into independent subtasks, establishing dependencies and priorities.
append: Keep existing tasks and add new ones
overwrite: Delete unfinished tasks, keep completed ones
selective: Intelligently match and update existing tasks based on name
clearAllTasks: Clear all tasks and create a backup (preferred mode)
Provide concise pseudocode: Only provide high-level logic flow and key steps, avoid complete code
Consolidate when necessary: Simple modifications can be integrated with other tasks to avoid excessive task count
Submit in batches: If there are too many tasks, use the "split_tasks" tool with parameters not exceeding 5000 characters
Inputs: tasks (required), updateMode (required), globalAnalysisResult.
Update task content, including name, description and notes, dependent tasks, related files, implementation guide and verification criteria. Completed tasks only allow updating summary and related files
Inputs: taskId (required), dependencies, description, implementationGuide, +4 more.
Comprehensively verify task completion, ensuring all requirements and technical standards are met without missing details
Inputs: taskId (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 15 tools
The tools have overlapping purposes that could cause confusion, such as 'analyze_task' and 'reflect_task' both involving analysis and pseudocode, and 'list_tasks' and 'query_task' both retrieving task information. However, descriptions help differentiate some tools, like 'execute_task' for action versus 'plan_task' for planning, reducing ambiguity.
Most tools follow a consistent verb_noun pattern (e.g., 'analyze_task', 'list_tasks', 'update_task'), with only minor deviations like 'init_project_rules' using 'init' instead of a more standard verb. The naming is readable and predictable overall, though not perfectly uniform.
With 15 tools, the count is well-scoped for a task management and analysis system. Each tool appears to serve a distinct function in the workflow, from initialization to execution and verification, making the set comprehensive without being excessive.
The tool set provides complete coverage for task lifecycle management, including initialization ('init_project_rules'), planning ('plan_task'), execution ('execute_task'), monitoring ('list_tasks', 'query_task'), and completion ('complete_task', 'verify_task'). No obvious gaps exist, as it supports CRUD operations and advanced features like reflection and splitting.
Task management for teams building with AI agents. Agents claim tasks and report progress.
Task manager for AI agents. Orchestrate agents to achieve large goals in unified control plane.
AI-powered spec-to-task decomposition and execution orchestration for coding agents.
AI-native task management: list, create, update and archive tasks with rich context for AI agents
