claude-task-master

claude-task-master

4.8
Certified
ai_chatbotdeveloper_tools

claude-task-master is hosted online, so all tools can be tested directly either in theInspector tabor in theOnline Client.

Task Master is a task management system for AI-driven development with Claude, designed to work seamlessly with Cursor AI.

initialize_project

Initializes a new Task Master project structure by calling the core initialization logic. Creates necessary folders and configuration files for Task Master in the current directory.

Try it

Skip installing dependencies automatically. Never do this unless you are sure the project is already installed.

Skip installing dependencies automatically. Never do this unless you are sure the project is already installed.

    Add shell aliases (tm, taskmaster) to shell config file.

    Add shell aliases (tm, taskmaster) to shell config file.

      Initialize Git repository in project root.

      Initialize Git repository in project root.

        Store tasks in Git (tasks.json and tasks/ directory).

        Store tasks in Git (tasks.json and tasks/ directory).

          Skip prompts and use default values. Always set to true for MCP tools.

          Skip prompts and use default values. Always set to true for MCP tools.

            The root directory for the project. ALWAYS SET THIS TO THE PROJECT ROOT DIRECTORY. IF NOT SET, THE TOOL WILL NOT WORK.

              List of rule profiles to include at initialization. If omitted, defaults to all available profiles. Available options: claude, cline, codex, cursor, roo, trae, vscode, windsurf

              rules

              List of rule profiles to include at initialization. If omitted, defaults to all available profiles. Available options: claude, cline, codex, cursor, roo, trae, vscode, windsurf

              No items yet. Use the button below to add some.

                  Result:

                  models

                  Get information about available AI models or set model configurations. Run without arguments to get the current model configuration and API key status for the selected model providers.

                  Try it

                  Set the primary model for task generation/updates. Model provider API key is required in the MCP config ENV.

                    Set the model for research-backed operations. Model provider API key is required in the MCP config ENV.

                      Set the model to use if the primary fails. Model provider API key is required in the MCP config ENV.

                        List all available models not currently in use. Input/output costs values are in dollars (3 is $3.00).

                        List all available models not currently in use. Input/output costs values are in dollars (3 is $3.00).

                          The directory of the project. Must be an absolute path.

                            Indicates the set model ID is a custom OpenRouter model.

                            Indicates the set model ID is a custom OpenRouter model.

                              Indicates the set model ID is a custom Ollama model.

                              Indicates the set model ID is a custom Ollama model.

                                Indicates the set model ID is a custom AWS Bedrock model.

                                Indicates the set model ID is a custom AWS Bedrock model.

                                  Indicates the set model ID is a custom Azure OpenAI model.

                                  Indicates the set model ID is a custom Azure OpenAI model.

                                    Indicates the set model ID is a custom Google Vertex AI model.

                                    Indicates the set model ID is a custom Google Vertex AI model.

                                        Result:

                                        rules

                                        Add or remove rule profiles from the project.

                                        Try it

                                        Whether to add or remove rule profiles.

                                        ▼
                                        • add
                                        • remove

                                          List of rule profiles to add or remove (e.g., ["cursor", "roo"]). Available options: claude, cline, codex, cursor, roo, trae, vscode, windsurf

                                          profiles

                                          List of rule profiles to add or remove (e.g., ["cursor", "roo"]). Available options: claude, cline, codex, cursor, roo, trae, vscode, windsurf

                                          ▼
                                          • claude
                                          • cline
                                          • codex
                                          • cursor
                                          • roo
                                          • trae
                                          • vscode
                                          • windsurf

                                              The root directory of the project. Must be an absolute path.

                                                DANGEROUS: Force removal even if it would leave no rule profiles. Only use if you are absolutely certain.

                                                DANGEROUS: Force removal even if it would leave no rule profiles. Only use if you are absolutely certain.

                                                    Result:

                                                    parse_prd

                                                    Parse a Product Requirements Document (PRD) text file to automatically generate initial tasks. Reinitializing the project is not necessary to run this tool. It is recommended to run parse-prd after initializing the project and creating/importing a prd.txt file in the project root's .taskmaster/docs directory.

                                                    Try it

                                                    Absolute path to the PRD document file (.txt, .md, etc.)

                                                      The directory of the project. Must be an absolute path.

                                                        Output path for tasks.json file (default: .taskmaster/tasks/tasks.json)

                                                          Approximate number of top-level tasks to generate (default: 10). As the agent, if you have enough information, ensure to enter a number of tasks that would logically scale with project complexity. Avoid entering numbers above 50 due to context window limitations.

                                                            Overwrite existing output file without prompting.

                                                            Overwrite existing output file without prompting.

                                                              Enable Taskmaster to use the research role for potentially more informed task generation. Requires appropriate API key.

                                                              Enable Taskmaster to use the research role for potentially more informed task generation. Requires appropriate API key.

                                                                Append generated tasks to existing file.

                                                                Append generated tasks to existing file.

                                                                    Result:

                                                                    analyze_project_complexity

                                                                    Analyze task complexity and generate expansion recommendations.

                                                                    Try it

                                                                    Complexity score threshold (1-10) to recommend expansion.

                                                                      Use Perplexity AI for research-backed analysis.

                                                                      Use Perplexity AI for research-backed analysis.

                                                                        Output file path relative to project root (default: .taskmaster/reports/task-complexity-report.json).

                                                                          Path to the tasks file relative to project root (default: tasks/tasks.json).

                                                                            Comma-separated list of task IDs to analyze specifically (e.g., "1,3,5").

                                                                              Starting task ID in a range to analyze.

                                                                                Ending task ID in a range to analyze.

                                                                                  The directory of the project. Must be an absolute path.

                                                                                      Result:

                                                                                      expand_task

                                                                                      Expand a task into subtasks for detailed implementation

                                                                                      Try it

                                                                                      ID of task to expand

                                                                                        Number of subtasks to generate

                                                                                          Use research role for generation

                                                                                          Use research role for generation

                                                                                            Additional context for subtask generation

                                                                                              Path to the tasks file relative to project root (e.g., tasks/tasks.json)

                                                                                                The directory of the project. Must be an absolute path.

                                                                                                  Force expansion even if subtasks exist

                                                                                                  Force expansion even if subtasks exist

                                                                                                    Tag context to operate on

                                                                                                        Result:

                                                                                                        expand_all

                                                                                                        Expand all pending tasks into subtasks based on complexity or defaults

                                                                                                        Try it

                                                                                                        Target number of subtasks per task (uses complexity/defaults otherwise)

                                                                                                          Enable research-backed subtask generation (e.g., using Perplexity)

                                                                                                          Enable research-backed subtask generation (e.g., using Perplexity)

                                                                                                            Additional context to guide subtask generation for all tasks

                                                                                                              Force regeneration of subtasks for tasks that already have them

                                                                                                              Force regeneration of subtasks for tasks that already have them

                                                                                                                Absolute path to the tasks file in the /tasks folder inside the project root (default: tasks/tasks.json)

                                                                                                                  Absolute path to the project root directory (derived from session if possible)

                                                                                                                      Result:

                                                                                                                      get_tasks

                                                                                                                      Get all tasks from Task Master, optionally filtering by status and including subtasks.

                                                                                                                      Try it

                                                                                                                      Filter tasks by status (e.g., 'pending', 'done') or multiple statuses separated by commas (e.g., 'blocked,deferred')

                                                                                                                        Include subtasks nested within their parent tasks in the response

                                                                                                                        Include subtasks nested within their parent tasks in the response

                                                                                                                          Path to the tasks file (relative to project root or absolute)

                                                                                                                            Path to the complexity report file (relative to project root or absolute)

                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                  Result:

                                                                                                                                  get_task

                                                                                                                                  Get detailed information about a specific task

                                                                                                                                  Try it

                                                                                                                                  Task ID(s) to get (can be comma-separated for multiple tasks)

                                                                                                                                    Filter subtasks by status (e.g., 'pending', 'done')

                                                                                                                                      Path to the tasks file relative to project root

                                                                                                                                        Path to the complexity report file (relative to project root or absolute)

                                                                                                                                          Absolute path to the project root directory (Optional, usually from session)

                                                                                                                                              Result:

                                                                                                                                              next_task

                                                                                                                                              Find the next task to work on based on dependencies and status

                                                                                                                                              Try it

                                                                                                                                              Absolute path to the tasks file

                                                                                                                                                Path to the complexity report file (relative to project root or absolute)

                                                                                                                                                  The directory of the project. Must be an absolute path.

                                                                                                                                                      Result:

                                                                                                                                                      complexity_report

                                                                                                                                                      Display the complexity analysis report in a readable format

                                                                                                                                                      Try it

                                                                                                                                                      Path to the report file (default: .taskmaster/reports/task-complexity-report.json)

                                                                                                                                                        The directory of the project. Must be an absolute path.

                                                                                                                                                            Result:

                                                                                                                                                            set_task_status

                                                                                                                                                            Set the status of one or more tasks or subtasks.

                                                                                                                                                            Try it

                                                                                                                                                            Task ID or subtask ID (e.g., '15', '15.2'). Can be comma-separated to update multiple tasks/subtasks at once.

                                                                                                                                                              New status to set (e.g., 'pending', 'done', 'in-progress', 'review', 'deferred', 'cancelled'.

                                                                                                                                                              ▼
                                                                                                                                                              • pending
                                                                                                                                                              • done
                                                                                                                                                              • in-progress
                                                                                                                                                              • review
                                                                                                                                                              • deferred
                                                                                                                                                              • cancelled

                                                                                                                                                                Absolute path to the tasks file

                                                                                                                                                                  Path to the complexity report file (relative to project root or absolute)

                                                                                                                                                                    The directory of the project. Must be an absolute path.

                                                                                                                                                                        Result:

                                                                                                                                                                        generate

                                                                                                                                                                        Generates individual task files in tasks/ directory based on tasks.json

                                                                                                                                                                        Try it

                                                                                                                                                                        Absolute path to the tasks file

                                                                                                                                                                          Output directory (default: same directory as tasks file)

                                                                                                                                                                            The directory of the project. Must be an absolute path.

                                                                                                                                                                                Result:

                                                                                                                                                                                add_task

                                                                                                                                                                                Add a new task using AI

                                                                                                                                                                                Try it

                                                                                                                                                                                Description of the task to add (required if not using manual fields)

                                                                                                                                                                                  Task title (for manual task creation)

                                                                                                                                                                                    Task description (for manual task creation)

                                                                                                                                                                                      Implementation details (for manual task creation)

                                                                                                                                                                                        Test strategy (for manual task creation)

                                                                                                                                                                                          Comma-separated list of task IDs this task depends on

                                                                                                                                                                                            Task priority (high, medium, low)

                                                                                                                                                                                              Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                The directory of the project. Must be an absolute path.

                                                                                                                                                                                                  Whether to use research capabilities for task creation

                                                                                                                                                                                                  Whether to use research capabilities for task creation

                                                                                                                                                                                                      Result:

                                                                                                                                                                                                      add_subtask

                                                                                                                                                                                                      Add a subtask to an existing task

                                                                                                                                                                                                      Try it

                                                                                                                                                                                                      Parent task ID (required)

                                                                                                                                                                                                        Existing task ID to convert to subtask

                                                                                                                                                                                                          Title for the new subtask (when creating a new subtask)

                                                                                                                                                                                                            Description for the new subtask

                                                                                                                                                                                                              Implementation details for the new subtask

                                                                                                                                                                                                                Status for the new subtask (default: 'pending')

                                                                                                                                                                                                                  Comma-separated list of dependency IDs for the new subtask

                                                                                                                                                                                                                    Absolute path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                      Skip regenerating task files

                                                                                                                                                                                                                      Skip regenerating task files

                                                                                                                                                                                                                        The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                            Result:

                                                                                                                                                                                                                            update

                                                                                                                                                                                                                            Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task or 'update_subtask' for subtasks.

                                                                                                                                                                                                                            Try it

                                                                                                                                                                                                                            Task ID from which to start updating (inclusive). IMPORTANT: This tool uses 'from', not 'id'

                                                                                                                                                                                                                              Explanation of changes or new context to apply

                                                                                                                                                                                                                                Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                  Path to the tasks file relative to project root

                                                                                                                                                                                                                                    The directory of the project. (Optional, usually from session)

                                                                                                                                                                                                                                        Result:

                                                                                                                                                                                                                                        update_task

                                                                                                                                                                                                                                        Updates a single task by ID with new information or context provided in the prompt.

                                                                                                                                                                                                                                        Try it

                                                                                                                                                                                                                                        ID of the task (e.g., '15') to update. Subtasks are supported using the update-subtask tool.

                                                                                                                                                                                                                                          New information or context to incorporate into the task

                                                                                                                                                                                                                                            Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                            Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                              Append timestamped information to task details instead of full update

                                                                                                                                                                                                                                              Append timestamped information to task details instead of full update

                                                                                                                                                                                                                                                Absolute path to the tasks file

                                                                                                                                                                                                                                                  The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                      Result:

                                                                                                                                                                                                                                                      update_subtask

                                                                                                                                                                                                                                                      Appends timestamped information to a specific subtask without replacing existing content. If you just want to update the subtask status, use set_task_status instead.

                                                                                                                                                                                                                                                      Try it

                                                                                                                                                                                                                                                      ID of the subtask to update in format "parentId.subtaskId" (e.g., "5.2"). Parent ID is the ID of the task that contains the subtask.

                                                                                                                                                                                                                                                        Information to add to the subtask

                                                                                                                                                                                                                                                          Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                                          Use Perplexity AI for research-backed updates

                                                                                                                                                                                                                                                            Absolute path to the tasks file

                                                                                                                                                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                  Result:

                                                                                                                                                                                                                                                                  remove_task

                                                                                                                                                                                                                                                                  Remove a task or subtask permanently from the tasks list

                                                                                                                                                                                                                                                                  Try it

                                                                                                                                                                                                                                                                  ID of the task or subtask to remove (e.g., '5' or '5.2'). Can be comma-separated to update multiple tasks/subtasks at once.

                                                                                                                                                                                                                                                                    Absolute path to the tasks file

                                                                                                                                                                                                                                                                      The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                        Whether to skip confirmation prompt (default: false)

                                                                                                                                                                                                                                                                        Whether to skip confirmation prompt (default: false)

                                                                                                                                                                                                                                                                            Result:

                                                                                                                                                                                                                                                                            remove_subtask

                                                                                                                                                                                                                                                                            Remove a subtask from its parent task

                                                                                                                                                                                                                                                                            Try it

                                                                                                                                                                                                                                                                            Subtask ID to remove in format 'parentId.subtaskId' (required)

                                                                                                                                                                                                                                                                              Convert the subtask to a standalone task instead of deleting it

                                                                                                                                                                                                                                                                              Convert the subtask to a standalone task instead of deleting it

                                                                                                                                                                                                                                                                                Absolute path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                  Skip regenerating task files

                                                                                                                                                                                                                                                                                  Skip regenerating task files

                                                                                                                                                                                                                                                                                    The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                        Result:

                                                                                                                                                                                                                                                                                        clear_subtasks

                                                                                                                                                                                                                                                                                        Clear subtasks from specified tasks

                                                                                                                                                                                                                                                                                        Try it

                                                                                                                                                                                                                                                                                        Task IDs (comma-separated) to clear subtasks from

                                                                                                                                                                                                                                                                                          Clear subtasks from all tasks

                                                                                                                                                                                                                                                                                          Clear subtasks from all tasks

                                                                                                                                                                                                                                                                                            Absolute path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                Tag context to operate on

                                                                                                                                                                                                                                                                                                    Result:

                                                                                                                                                                                                                                                                                                    move_task

                                                                                                                                                                                                                                                                                                    Move a task or subtask to a new position

                                                                                                                                                                                                                                                                                                    Try it

                                                                                                                                                                                                                                                                                                    ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated to move multiple tasks (e.g., "5,6,7")

                                                                                                                                                                                                                                                                                                      ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated

                                                                                                                                                                                                                                                                                                        Custom path to tasks.json file

                                                                                                                                                                                                                                                                                                          Root directory of the project (typically derived from session)

                                                                                                                                                                                                                                                                                                              Result:

                                                                                                                                                                                                                                                                                                              add_dependency

                                                                                                                                                                                                                                                                                                              Add a dependency relationship between two tasks

                                                                                                                                                                                                                                                                                                              Try it

                                                                                                                                                                                                                                                                                                              ID of task that will depend on another task

                                                                                                                                                                                                                                                                                                                ID of task that will become a dependency

                                                                                                                                                                                                                                                                                                                  Absolute path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                    The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                        Result:

                                                                                                                                                                                                                                                                                                                        remove_dependency

                                                                                                                                                                                                                                                                                                                        Remove a dependency from a task

                                                                                                                                                                                                                                                                                                                        Try it

                                                                                                                                                                                                                                                                                                                        Task ID to remove dependency from

                                                                                                                                                                                                                                                                                                                          Task ID to remove as a dependency

                                                                                                                                                                                                                                                                                                                            Absolute path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                  Result:

                                                                                                                                                                                                                                                                                                                                  validate_dependencies

                                                                                                                                                                                                                                                                                                                                  Check tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.

                                                                                                                                                                                                                                                                                                                                  Try it

                                                                                                                                                                                                                                                                                                                                  Absolute path to the tasks file

                                                                                                                                                                                                                                                                                                                                    The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                        Result:

                                                                                                                                                                                                                                                                                                                                        fix_dependencies

                                                                                                                                                                                                                                                                                                                                        Fix invalid dependencies in tasks automatically

                                                                                                                                                                                                                                                                                                                                        Try it

                                                                                                                                                                                                                                                                                                                                        Absolute path to the tasks file

                                                                                                                                                                                                                                                                                                                                          The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                              Result:

                                                                                                                                                                                                                                                                                                                                              list_tags

                                                                                                                                                                                                                                                                                                                                              List all available tags with task counts and metadata

                                                                                                                                                                                                                                                                                                                                              Try it

                                                                                                                                                                                                                                                                                                                                              Whether to include metadata in the output (default: false)

                                                                                                                                                                                                                                                                                                                                              Whether to include metadata in the output (default: false)

                                                                                                                                                                                                                                                                                                                                                Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                  The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                      Result:

                                                                                                                                                                                                                                                                                                                                                      add_tag

                                                                                                                                                                                                                                                                                                                                                      Create a new tag for organizing tasks in different contexts

                                                                                                                                                                                                                                                                                                                                                      Try it

                                                                                                                                                                                                                                                                                                                                                      Name of the new tag to create

                                                                                                                                                                                                                                                                                                                                                        Whether to copy tasks from the current tag (default: false)

                                                                                                                                                                                                                                                                                                                                                        Whether to copy tasks from the current tag (default: false)

                                                                                                                                                                                                                                                                                                                                                          Specific tag to copy tasks from

                                                                                                                                                                                                                                                                                                                                                            Create tag name from current git branch (ignores name parameter)

                                                                                                                                                                                                                                                                                                                                                            Create tag name from current git branch (ignores name parameter)

                                                                                                                                                                                                                                                                                                                                                              Optional description for the tag

                                                                                                                                                                                                                                                                                                                                                                Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                                  The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                      Result:

                                                                                                                                                                                                                                                                                                                                                                      delete_tag

                                                                                                                                                                                                                                                                                                                                                                      Delete an existing tag and all its tasks

                                                                                                                                                                                                                                                                                                                                                                      Try it

                                                                                                                                                                                                                                                                                                                                                                      Name of the tag to delete

                                                                                                                                                                                                                                                                                                                                                                        Skip confirmation prompts (default: true for MCP)

                                                                                                                                                                                                                                                                                                                                                                        Skip confirmation prompts (default: true for MCP)

                                                                                                                                                                                                                                                                                                                                                                          Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                                            The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                Result:

                                                                                                                                                                                                                                                                                                                                                                                use_tag

                                                                                                                                                                                                                                                                                                                                                                                Switch to a different tag context for task operations

                                                                                                                                                                                                                                                                                                                                                                                Try it

                                                                                                                                                                                                                                                                                                                                                                                Name of the tag to switch to

                                                                                                                                                                                                                                                                                                                                                                                  Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                                                    The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                        Result:

                                                                                                                                                                                                                                                                                                                                                                                        rename_tag

                                                                                                                                                                                                                                                                                                                                                                                        Rename an existing tag

                                                                                                                                                                                                                                                                                                                                                                                        Try it

                                                                                                                                                                                                                                                                                                                                                                                        Current name of the tag to rename

                                                                                                                                                                                                                                                                                                                                                                                          New name for the tag

                                                                                                                                                                                                                                                                                                                                                                                            Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                                  Result:

                                                                                                                                                                                                                                                                                                                                                                                                  copy_tag

                                                                                                                                                                                                                                                                                                                                                                                                  Copy an existing tag to create a new tag with all tasks and metadata

                                                                                                                                                                                                                                                                                                                                                                                                  Try it

                                                                                                                                                                                                                                                                                                                                                                                                  Name of the source tag to copy from

                                                                                                                                                                                                                                                                                                                                                                                                    Name of the new tag to create

                                                                                                                                                                                                                                                                                                                                                                                                      Optional description for the new tag

                                                                                                                                                                                                                                                                                                                                                                                                        Path to the tasks file (default: tasks/tasks.json)

                                                                                                                                                                                                                                                                                                                                                                                                          The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                                              Result:

                                                                                                                                                                                                                                                                                                                                                                                                              research

                                                                                                                                                                                                                                                                                                                                                                                                              Perform AI-powered research queries with project context

                                                                                                                                                                                                                                                                                                                                                                                                              Try it

                                                                                                                                                                                                                                                                                                                                                                                                              Research query/prompt (required)

                                                                                                                                                                                                                                                                                                                                                                                                                Comma-separated list of task/subtask IDs for context (e.g., "15,16.2,17")

                                                                                                                                                                                                                                                                                                                                                                                                                  Comma-separated list of file paths for context (e.g., "src/api.js,docs/readme.md")

                                                                                                                                                                                                                                                                                                                                                                                                                    Additional custom context text to include in the research

                                                                                                                                                                                                                                                                                                                                                                                                                      Include project file tree structure in context (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                      Include project file tree structure in context (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                        Detail level for the research response (default: medium)

                                                                                                                                                                                                                                                                                                                                                                                                                        ▼
                                                                                                                                                                                                                                                                                                                                                                                                                        • low
                                                                                                                                                                                                                                                                                                                                                                                                                        • medium
                                                                                                                                                                                                                                                                                                                                                                                                                        • high

                                                                                                                                                                                                                                                                                                                                                                                                                          Automatically save research results to specified task/subtask ID (e.g., "15" or "15.2")

                                                                                                                                                                                                                                                                                                                                                                                                                            Save research results to .taskmaster/docs/research/ directory (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                            Save research results to .taskmaster/docs/research/ directory (default: false)

                                                                                                                                                                                                                                                                                                                                                                                                                              The directory of the project. Must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Result:

                                                                                                                                                                                                                                                                                                                                                                                                                                  Related MCP Servers

                                                                                                                                                                                                                                                                                                                                                                                                                                  View all ai_chatbot servers →
                                                                                                                                                                                                                                                                                                                                                                                                                                  elevenlabs-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  elevenlabs-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.6

                                                                                                                                                                                                                                                                                                                                                                                                                                  by elevenlabs

                                                                                                                                                                                                                                                                                                                                                                                                                                  Official ElevenLabs Model Context Protocol (MCP) server for interaction with Text to Speech and audio processing APIs.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  mindsdb

                                                                                                                                                                                                                                                                                                                                                                                                                                  mindsdb

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.5

                                                                                                                                                                                                                                                                                                                                                                                                                                  by mindsdb

                                                                                                                                                                                                                                                                                                                                                                                                                                  MindsDB is an open-source server that enables seamless interaction with large-scale federated data using the Model Context Protocol (MCP).

                                                                                                                                                                                                                                                                                                                                                                                                                                  databases
                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-notion-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-notion-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.3

                                                                                                                                                                                                                                                                                                                                                                                                                                  by suekou

                                                                                                                                                                                                                                                                                                                                                                                                                                  MCP Server for the Notion API, enabling LLM to interact with Notion workspaces. Additionally, it employs Markdown conversion to reduce context size when communicating with LLMs, optimizing token usage and making interactions more efficient.

                                                                                                                                                                                                                                                                                                                                                                                                                                  databases
                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequential Thinking

                                                                                                                                                                                                                                                                                                                                                                                                                                  Sequential Thinking

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.3

                                                                                                                                                                                                                                                                                                                                                                                                                                  by modelcontextprotocol

                                                                                                                                                                                                                                                                                                                                                                                                                                  An MCP server implementation that provides a tool for dynamic and reflective problem-solving through a structured thinking process.

                                                                                                                                                                                                                                                                                                                                                                                                                                  research_and_data
                                                                                                                                                                                                                                                                                                                                                                                                                                  tavily-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  tavily-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.3

                                                                                                                                                                                                                                                                                                                                                                                                                                  by tavily-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                  The Tavily MCP server is a Model Context Protocol server that integrates with AI systems to provide real-time web search and data extraction capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                  browser_automation
                                                                                                                                                                                                                                                                                                                                                                                                                                  HowToCook-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  HowToCook-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.3

                                                                                                                                                                                                                                                                                                                                                                                                                                  by worryzyy

                                                                                                                                                                                                                                                                                                                                                                                                                                  HowToCook-MCP Server is a Model Context Protocol server that transforms AI assistants into personal chefs, helping users plan meals and recommend recipes.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  whois-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  whois-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.3

                                                                                                                                                                                                                                                                                                                                                                                                                                  by bharathvaj-ganesan

                                                                                                                                                                                                                                                                                                                                                                                                                                  The Whois MCP server allows AI agents to perform WHOIS lookups to retrieve domain details.

                                                                                                                                                                                                                                                                                                                                                                                                                                  research_and_data
                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-server-reddit

                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-server-reddit

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.1

                                                                                                                                                                                                                                                                                                                                                                                                                                  by Hawstein

                                                                                                                                                                                                                                                                                                                                                                                                                                  A Model Context Protocol server providing access to Reddit public API for LLMs.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  github-mcp-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  github-mcp-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.1

                                                                                                                                                                                                                                                                                                                                                                                                                                  by github

                                                                                                                                                                                                                                                                                                                                                                                                                                  The GitHub MCP Server is a Model Context Protocol server that integrates with GitHub APIs for automation and interaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                  developer_tools
                                                                                                                                                                                                                                                                                                                                                                                                                                  rapidocr-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  rapidocr-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.0

                                                                                                                                                                                                                                                                                                                                                                                                                                  by z4none

                                                                                                                                                                                                                                                                                                                                                                                                                                  RapidOCR MCP Server is a Model Context Protocol server that provides an easy-to-use OCR interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  gateway

                                                                                                                                                                                                                                                                                                                                                                                                                                  gateway

                                                                                                                                                                                                                                                                                                                                                                                                                                  4.0

                                                                                                                                                                                                                                                                                                                                                                                                                                  by centralmind

                                                                                                                                                                                                                                                                                                                                                                                                                                  CentralMind Gateway is a tool designed to expose databases to AI agents via MCP or OpenAPI protocols, providing secure, LLM-optimized APIs.

                                                                                                                                                                                                                                                                                                                                                                                                                                  databases
                                                                                                                                                                                                                                                                                                                                                                                                                                  runno MCP

                                                                                                                                                                                                                                                                                                                                                                                                                                  runno MCP

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.9

                                                                                                                                                                                                                                                                                                                                                                                                                                  by taybenlor

                                                                                                                                                                                                                                                                                                                                                                                                                                  `@runno/mcp` is a Model Context Protocol server that provides a secure code execution environment for AI assistants.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  magic-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  magic-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by 21st-dev

                                                                                                                                                                                                                                                                                                                                                                                                                                  Magic Component Platform (MCP) is a powerful AI-driven tool that helps developers create beautiful, modern UI components instantly through natural language descriptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                  developer_tools
                                                                                                                                                                                                                                                                                                                                                                                                                                  blender-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  blender-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by ahujasid

                                                                                                                                                                                                                                                                                                                                                                                                                                  BlenderMCP connects Blender to Claude AI through the Model Context Protocol (MCP), enabling prompt-assisted 3D modeling, scene creation, and manipulation.

                                                                                                                                                                                                                                                                                                                                                                                                                                  entertainment_and_media
                                                                                                                                                                                                                                                                                                                                                                                                                                  unity-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  unity-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by justinpbarnett

                                                                                                                                                                                                                                                                                                                                                                                                                                  Unity MCP connects your Unity Editor to LLMs using the Model Context Protocol, enabling AI assistants to interact with Unity for asset management, scene control, script editing, and task automation.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  Cua Agent

                                                                                                                                                                                                                                                                                                                                                                                                                                  Cua Agent

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by trycua

                                                                                                                                                                                                                                                                                                                                                                                                                                  cua-mcp-server is a Model Context Protocol (MCP) server for the Computer-Use Agent (CUA), enabling integration with Claude Desktop and other MCP clients.

                                                                                                                                                                                                                                                                                                                                                                                                                                  developer_tools
                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-crawl4ai-rag

                                                                                                                                                                                                                                                                                                                                                                                                                                  mcp-crawl4ai-rag

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by coleam00

                                                                                                                                                                                                                                                                                                                                                                                                                                  Crawl4AI RAG MCP Server is a powerful implementation of the Model Context Protocol (MCP) integrated with Crawl4AI and Supabase, providing AI agents and AI coding assistants with advanced web crawling and RAG capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                  browser_automation
                                                                                                                                                                                                                                                                                                                                                                                                                                  whatsapp-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  whatsapp-mcp

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by lharries

                                                                                                                                                                                                                                                                                                                                                                                                                                  This is a Model Context Protocol (MCP) server for WhatsApp, allowing users to interact with their WhatsApp messages and contacts through an LLM like Claude.

                                                                                                                                                                                                                                                                                                                                                                                                                                  communication
                                                                                                                                                                                                                                                                                                                                                                                                                                  modelcontextprotocol

                                                                                                                                                                                                                                                                                                                                                                                                                                  modelcontextprotocol

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.8

                                                                                                                                                                                                                                                                                                                                                                                                                                  by ppl-ai

                                                                                                                                                                                                                                                                                                                                                                                                                                  The Perplexity Ask MCP Server integrates the Sonar API to provide Claude with real-time, web-wide research capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                  research_and_data
                                                                                                                                                                                                                                                                                                                                                                                                                                  minima

                                                                                                                                                                                                                                                                                                                                                                                                                                  minima

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by dmayboroda

                                                                                                                                                                                                                                                                                                                                                                                                                                  Minima is an open-source RAG on-premises container solution that integrates with ChatGPT and MCP, allowing for fully local or hybrid installations.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  just-prompt

                                                                                                                                                                                                                                                                                                                                                                                                                                  just-prompt

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by disler

                                                                                                                                                                                                                                                                                                                                                                                                                                  Just Prompt is a lightweight MCP server providing a unified interface to various LLM providers.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  k8m

                                                                                                                                                                                                                                                                                                                                                                                                                                  k8m

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by weibaohui

                                                                                                                                                                                                                                                                                                                                                                                                                                  K8M is an AI-driven lightweight Kubernetes dashboard designed to simplify cluster management.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot
                                                                                                                                                                                                                                                                                                                                                                                                                                  UnityMCP

                                                                                                                                                                                                                                                                                                                                                                                                                                  UnityMCP

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by Arodoid

                                                                                                                                                                                                                                                                                                                                                                                                                                  UnityMCP is a Unity Editor plugin that integrates the Model Context Protocol (MCP) for seamless interaction between Unity and AI assistants.

                                                                                                                                                                                                                                                                                                                                                                                                                                  developer_tools
                                                                                                                                                                                                                                                                                                                                                                                                                                  Baidu AI Search

                                                                                                                                                                                                                                                                                                                                                                                                                                  Baidu AI Search

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by baidubce

                                                                                                                                                                                                                                                                                                                                                                                                                                  Baidu AI Search integrates Baidu's search capabilities with large language model technology to provide intelligent responses with real-time web information references.

                                                                                                                                                                                                                                                                                                                                                                                                                                  research_and_data
                                                                                                                                                                                                                                                                                                                                                                                                                                  MCP Component Server

                                                                                                                                                                                                                                                                                                                                                                                                                                  MCP Component Server

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by baidubce

                                                                                                                                                                                                                                                                                                                                                                                                                                  The MCP Component Server is a FastMCP server-based implementation that converts AppBuilder Components into FastMCP tools, enabling seamless integration of Baidu cloud AI services into MCP-compatible environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                  cloud_platforms
                                                                                                                                                                                                                                                                                                                                                                                                                                  rails-mcp-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  rails-mcp-server

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by maquina-app

                                                                                                                                                                                                                                                                                                                                                                                                                                  A Ruby implementation of a Model Context Protocol (MCP) server for Rails projects, allowing LLMs to interact with Rails projects.

                                                                                                                                                                                                                                                                                                                                                                                                                                  developer_tools
                                                                                                                                                                                                                                                                                                                                                                                                                                  blender-mcp-vxai

                                                                                                                                                                                                                                                                                                                                                                                                                                  blender-mcp-vxai

                                                                                                                                                                                                                                                                                                                                                                                                                                  3.7

                                                                                                                                                                                                                                                                                                                                                                                                                                  by VxASI

                                                                                                                                                                                                                                                                                                                                                                                                                                  Blender MCP VXAI is a powerful integration that allows you to control Blender using natural language through MCP Clients.

                                                                                                                                                                                                                                                                                                                                                                                                                                  ai_chatbot