TaskFlow MCP 🔄✅

by pinkpixel-dev

28 stars

501 downloads

Not rated

GitHub

About

A task management Model Context Protocol (MCP) server that helps AI assistants break down user requests into manageable tasks with subtasks, dependencies, and notes. Enforces a structured workflow with user approval steps.

Details

Author: pinkpixel-dev
GitHub stars: 28
Downloads: 501
Categories: Other, Project Management

- Break down complex requests into tasks and subtasks
- Enforce user approval steps for quality control
- Persist tasks to disk in JSON or YAML format
- Export task status reports in Markdown, JSON, or HTML
- Track project and task-level dependencies with version information
- Archive completed requests and restore full history when needed

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name TaskFlow MCP 🔄✅

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

From the repository

Install it globally with npm install -g @pinkpixel/taskflow-mcp and start with taskflow-mcp, or run locally with npx @pinkpixel/taskflow-mcp. Configure the server by setting the TASK_MANAGER_FILE_PATH environment variable and add it to your MCP client’s mcp_config.json. AI assistants interact with TaskFlow MCP through tools like plan_task, get_next_task, and mark_task_done.

`plan_task`

Register a new user request and plan its associated tasks. You must provide 'originalRequest' and 'tasks', and optionally 'splitDetails'. Tasks can now include subtasks, which are smaller units of work that make up a task. All subtasks must be completed before a task can be marked as done. You can also include: - 'dependencies': List of project or task-specific dependencies (libraries, tools, etc.) - 'notes': General notes about the project (preferences, guidelines, etc.) - 'outputPath': Path to save a Markdown file with the task plan for reference. It's recommended to use absolute paths (e.g., 'C:/Users/username/Documents/task-plan.md') rather than relative paths for more reliable file creation. This tool initiates a new workflow for handling a user's request. The workflow is as follows: 1. Use 'plan_task' to register a request and its tasks (with optional subtasks, dependencies, and notes). 2. After adding tasks, you MUST use 'get_next_task' to retrieve the first task. A progress table will be displayed. 3. Use 'get_next_task' to retrieve the next uncompleted task. 4. If the task has subtasks, complete each subtask using 'mark_subtask_done' before marking the task as done. 5. **IMPORTANT:** After marking a task as done, a progress table will be displayed showing the updated status of all tasks. The assistant MUST NOT proceed to another task without the user's approval. Ask the user for approval before proceeding. 6. Once the user approves the completed task, you can proceed to 'get_next_task' again to fetch the next pending task. 7. Repeat this cycle until all tasks are done. 8. After all tasks are completed, 'get_next_task' will indicate that all tasks are done. At this point, ask the user for confirmation that the entire request has been completed satisfactorily. 9. If the user wants more tasks, you can use 'add_tasks_to_request' or 'plan_task' to add new tasks and continue the cycle. The critical point is to always wait for user approval after completing each task and after all tasks are done. Do not proceed automatically, UNLESS the user has explicitly told you to continue with all tasks and that you do not need approval.

`get_next_task`

Given a 'requestId', return the next pending task (not done yet). If all tasks are completed, it will indicate that no more tasks are left and that you must ask the user what to do next. A progress table showing the current status of all tasks will be displayed with each response. If the same task is returned again or if no new task is provided after a task was marked as done, you MUST NOT proceed. In such a scenario, you must prompt the user for approval before calling 'get_next_task' again. Do not skip the user's approval step. In other words: - After calling 'mark_task_done', do not call 'get_next_task' again until the user has given approval for the completed task. - If 'get_next_task' returns 'all_tasks_done', it means all tasks have been completed. At this point, confirm with the user that all tasks have been completed, and optionally add more tasks via 'add_tasks_to_request' or 'plan_task'.

`mark_task_done`

Mark a given task as done after you've completed it. Provide 'requestId' and 'taskId', and optionally 'completedDetails'. After marking a task as done, a progress table will be displayed showing the updated status of all tasks. After this, DO NOT proceed to 'get_next_task' again until the user has explicitly approved the completed task. Ask the user for approval before continuing.

`open_task_details`

Get details of a specific task by 'taskId'. This is for inspecting task information at any point.

`list_requests`

List all requests with their basic information and summary of tasks. This provides a quick overview of all requests in the system.

`add_tasks_to_request`

Add new tasks to an existing request. This allows extending a request with additional tasks. Tasks can include subtasks and dependencies. A progress table will be displayed showing all tasks including the newly added ones.

`update_task`

Update an existing task's title and/or description. Only uncompleted tasks can be updated. A progress table will be displayed showing the updated task information.

`delete_task`

Delete a specific task from a request. Only uncompleted tasks can be deleted. A progress table will be displayed showing the remaining tasks after deletion.

`add_subtasks`

Add subtasks to an existing task. Provide 'requestId', 'taskId', and 'subtasks' array. Subtasks are smaller units of work that make up a task. All subtasks must be completed before a task can be marked as done. A progress table will be displayed showing the updated task with its subtasks.

`mark_subtask_done`

Mark a subtask as done. Provide 'requestId', 'taskId', and 'subtaskId'. A progress table will be displayed showing the updated status of all tasks and subtasks. All subtasks must be completed before a task can be marked as done.

`update_subtask`

Update a subtask's title or description. Provide 'requestId', 'taskId', 'subtaskId', and optionally 'title' and/or 'description'. Only uncompleted subtasks can be updated. A progress table will be displayed showing the updated task with its subtasks.

`delete_subtask`

Delete a subtask from a task. Provide 'requestId', 'taskId', and 'subtaskId'. Only uncompleted subtasks can be deleted. A progress table will be displayed showing the updated task with its remaining subtasks.

`export_task_status`

Export the current status of all tasks in a request to a file. This tool saves the current state of tasks, subtasks, dependencies, and notes to a file for reference. You can specify: - 'format': 'markdown', 'json', or 'html' - 'outputPath': Full path to save the file, or just a directory path - 'filename': Optional custom filename (auto-generated if not provided) Path handling: - If outputPath is a directory, filename will be auto-generated as '{project-name}_tasks.{ext}' - If outputPath includes filename, it will be used as-is - Relative paths are resolved from current working directory - If no path specified, saves to current working directory

`add_note`

Add a note to a request. Notes can contain important information about the project, such as user preferences or guidelines. Notes are displayed in the task progress table and can be referenced when working on tasks.

`update_note`

Update an existing note's title or content. Provide the 'requestId' and 'noteId', and optionally 'title' and/or 'content' to update.

`delete_note`

Delete a note from a request. Provide the 'requestId' and 'noteId' of the note to delete.

`add_dependency`

Add a dependency to a request or task. Dependencies can be libraries, tools, or other requirements needed for the project or specific tasks. If 'taskId' is provided, the dependency will be added to that specific task. Otherwise, it will be added to the request.

`get_prompts`

Get the current prompts configuration including instructions, taskPrefix, and taskSuffix settings. This tool helps you view the current global prompts settings that are applied to all tasks.

`set_prompts`

Set the global prompts configuration with instructions, taskPrefix, and/or taskSuffix. This replaces any existing prompts settings with the new values provided. - 'instructions': General instructions or context shown at the top of each task - 'taskPrefix': Text to prepend before each task description - 'taskSuffix': Text to append after each task description

`update_prompts`

Update specific parts of the prompts configuration without replacing the entire object. Use this to modify individual fields (instructions, taskPrefix, or taskSuffix) while keeping other settings unchanged.

`remove_prompts`

Remove the entire prompts configuration or specific fields from it. If 'fields' is provided, only those specific fields will be removed. If 'fields' is not provided, the entire prompts configuration will be removed.

`archive_completed_requests`

Archive completed requests to a separate file to keep the active tasks file clean. If 'requestIds' is provided, only those specific completed requests will be archived. If 'requestIds' is not provided, all completed requests will be archived. This addresses the need to keep active tasks file uncluttered by moving completed work to archive storage.

`list_archived_requests`

List archived requests with optional search and filtering capabilities. Provides an overview of all archived requests with their metadata and completion information.

`restore_archived_request`

Restore a specific archived request back to the active tasks file. This moves the request from the archive back to active status, allowing you to continue working on it.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "taskflow mcp \ud83d\udd04\u2705": {
            "taskflow": {
                "command": "npx",
                "args": [
                    "-y",
                    "@pinkpixel/taskflow-mcp"
                ],
                "env": {
                    "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
                }
            }
        }
    }
}

McpServers

{
    "taskflow": {
        "command": "npx",
        "args": [
            "-y",
            "@pinkpixel/taskflow-mcp"
        ],
        "env": {
            "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json"
        }
    }
}

TaskFlow MCP 🔄✅

<p align="center">
TaskFlow MCP
</p>

A task management Model Context Protocol (MCP) server for planning and executing tasks with AI assistants.

🌟 Overview

TaskFlow MCP is a specialized server that helps AI assistants break down user requests into manageable tasks and track their completion. It enforces a structured workflow with user approval steps to ensure tasks are properly tracked and users maintain control over the process.

✨ Features

- 📋 Task Planning: Break down complex requests into manageable tasks
- 🔍 Subtasks: Divide tasks into smaller, more manageable subtasks
- 📊 Progress Tracking: Track the status of tasks, subtasks, and requests with visual progress tables
- 👍 User Approval: Enforce user approval steps to ensure quality and control
- 💾 Persistence: Save tasks and requests to disk for persistence across sessions
- 🔄 Flexible Management: Add, update, or delete tasks and subtasks as needed
- 📝 Detailed Reporting: View task details and progress tables
- 📤 Export Options: Export task plans and status reports in Markdown, JSON, or HTML formats
- 📦 Dependencies: Track project and task-level dependencies with version information
- 📌 Notes: Add project-level notes for important information and preferences
- 📄 YAML Support: Save tasks in YAML format for better handling of multiline content
- 🛡️ Robust Text Handling: Comprehensive newline sanitization for reliable data persistence
- 🎯 Prompts System: Global instructions and task prefix/suffix for consistent LLM guidance
- 📚 Task Archiving: Archive completed requests to keep active task lists clean
- 🗂️ Archive Management: Browse, search, and restore archived tasks with full history
- 📍 Relative Path Support: Use relative paths for flexible project-based workflows

🚀 Installation

Global Installation

npm install -g @pinkpixel/taskflow-mcp

Local Installation

npm install @pinkpixel/taskflow-mcp

🛠️ Usage

Starting the Server

If installed globally:

taskflow-mcp

If installed locally:

npx taskflow-mcp

Configuration

By default, TaskFlow MCP saves tasks to tasks.yaml in the current working directory. You can customize this by setting the TASK_MANAGER_FILE_PATH environment variable:

File Path Options

Absolute paths (recommended for production):
```bash
TASK_MANAGER_FILE_PATH=/home/user/projects/my-tasks.yaml taskflow-mcp

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

plan_task

get_next_task

mark_task_done

open_task_details

list_requests

add_tasks_to_request

update_task

delete_task

add_subtasks

mark_subtask_done

update_subtask

delete_subtask

export_task_status

add_note

update_note

delete_note

add_dependency

get_prompts

set_prompts

update_prompts

remove_prompts

archive_completed_requests

list_archived_requests

restore_archived_request

Claude Desktop / Cursor

McpServers

TaskFlow MCP 🔄✅

🌟 Overview

✨ Features

🚀 Installation

Global Installation

Local Installation

🛠️ Usage

Starting the Server

Configuration

File Path Options

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

GitLab

Reactive Resume

`plan_task`

`get_next_task`

`mark_task_done`

`open_task_details`

`list_requests`

`add_tasks_to_request`

`update_task`

`delete_task`

`add_subtasks`

`mark_subtask_done`

`update_subtask`

`delete_subtask`

`export_task_status`

`add_note`

`update_note`

`delete_note`

`add_dependency`

`get_prompts`

`set_prompts`

`update_prompts`

`remove_prompts`

`archive_completed_requests`

`list_archived_requests`

`restore_archived_request`