Skip to main content
Glama
MCP Task Management Server

MCP Task Management Server

by jimfisher

MCP Task Management Server

An advanced Model Context Protocol (MCP) server for comprehensive task management with groups, custom statuses, task relationships, and AI integration. Now powered by SQLite for enhanced performance and reliability.

Features

  • Task Management: Create, update, delete, and search tasks with rich metadata

  • Bulk Operations: Create, update, and change status of multiple tasks simultaneously

  • Task Groups: Organize tasks into projects, areas, or any custom groupings

  • Custom Statuses: Define your own workflow statuses with colors and descriptions

  • Task References: Create relationships between tasks (blocks, relates-to, child-of, etc.)

  • Status History: Automatic tracking of status changes with timestamps

  • Markdown Support: Task descriptions support full markdown formatting

  • AI-Friendly: Designed for AI assistants to automatically manage tasks during conversations

  • Persistent Storage: SQLite database with automatic migration from JSON format

Related MCP server: Personal Task Manager MCP

Installation

  1. Clone or download this repository

  2. Install dependencies:

    npm install
  3. Build the project:

    npm run build

Usage

As an MCP Server

Add to your MCP client configuration (e.g., Claude Desktop):

{
  "mcpServers": {
    "mcp-task": {
      "command": "node",
      "args": ["/path/to/mcp-task/build/index.js"]
    }
  }
}

Direct Usage

You can also run the server directly:

npm start

Data Storage

SQLite Database (Default)

The server now uses SQLite as the default database for improved performance, reliability, and data integrity. Tasks are stored in ~/.mcp-tasks.sqlite.

Benefits of SQLite:

  • Better performance for large datasets

  • ACID transactions ensure data consistency

  • Structured queries and indexing

  • Automatic migration from JSON format

Legacy JSON Support

For compatibility, the server can still use JSON storage by setting the environment variable:

export MCP_TASK_USE_SQLITE=false

Automatic Migration: When upgrading from JSON to SQLite, the server automatically migrates your existing ~/.mcp-tasks.json data to the new SQLite format.

Available Tools

Task Operations

  • create_task: Create a new task with title, description, status, group, priority, tags, assignee, due date, and time estimates

  • update_task: Update any task properties. Status changes are automatically tracked with timestamps

  • get_task: Get detailed task information including history and references

  • list_tasks: List and filter tasks by status, group, assignee, tags, priority, due dates, or search terms

  • delete_task: Delete a task and remove all references to it

Bulk Operations

  • bulk_create_tasks: Create multiple tasks at once with shared properties (group, status, assignee, tags)

  • bulk_update_tasks: Update multiple tasks simultaneously with the same changes

  • bulk_change_status: Change the status of multiple tasks at once with optional notes

Group Management

  • create_group: Create task groups for organizing related tasks (projects, areas, etc.)

  • list_groups: List all groups with metadata

  • delete_group: Delete a group (tasks remain but become ungrouped)

Status Management

  • create_status: Create custom workflow statuses with colors and descriptions

  • list_statuses: List all available statuses

  • delete_status: Delete custom statuses (cannot delete default or in-use statuses)

Task Relationships

  • add_task_reference: Create relationships between tasks:

    • blocks / blocked-by: Dependency relationships

    • relates-to: General relationship

    • duplicates: Duplicate tasks

    • child-of / parent-of: Hierarchical relationships

  • remove_task_reference: Remove task relationships

  • get_task_references: View all incoming and outgoing task references

AI Integration

This MCP server is specifically designed for AI assistants to:

  1. Automatically create tasks when users mention work they need to do

  2. Update task status as work progresses during conversations

  3. Break down complex requests into manageable subtasks with references

  4. Track project progress by organizing tasks into groups

  5. Manage dependencies by creating task references

  6. Provide context by searching and filtering existing tasks

  7. Handle bulk operations for efficient project setup and team management

Example AI Usage Patterns

Creating tasks from conversation:

User: "I need to implement user authentication and then build the dashboard"
AI: Creates two tasks:
- "Implement user authentication"
- "Build dashboard" (with "blocked-by" reference to auth task)

Status tracking:

User: "I finished the login form"
AI: Updates relevant task status to "Done" and adds completion timestamp

Project organization:

User: "Let's start working on the mobile app redesign"
AI: Creates a "Mobile App Redesign" group and organizes related tasks

Bulk project setup:

User: "I need to set up tasks for the Q1 marketing campaign"
AI: Uses bulk_create_tasks to create multiple related tasks at once:
- "Design campaign assets", "Write copy", "Set up analytics", etc.

Team workflow management:

User: "Move all the design tasks to review status"
AI: Uses bulk_change_status to transition multiple tasks simultaneously

Data Model

Task Properties

  • Basic Info: ID, title, description, summary

  • Organization: status, group, priority, tags, assignee

  • Timing: due date, estimated hours, actual hours

  • Tracking: created/updated timestamps, completion date

  • Relationships: references to other tasks

  • History: Complete status change history

Task Statuses

Default statuses include "To Do", "In Progress", and "Done", but you can create custom statuses like "Review", "Testing", "Blocked", etc.

Task Groups

Organize tasks into logical groups like:

  • Projects ("Website Redesign", "Mobile App")

  • Areas ("Marketing", "Development", "Operations")

  • Contexts ("Home", "Office", "Travel")

Task References

Model complex relationships:

  • Dependencies: Task A blocks Task B

  • Hierarchy: Parent/child task relationships

  • Related work: Tasks that relate to each other

  • Duplicates: Mark duplicate tasks

Complete Tool Reference

The server provides 17 comprehensive tools designed for AI assistants:

Task Operations: create_task, update_task, get_task, list_tasks, delete_task Bulk Operations: bulk_create_tasks, bulk_update_tasks, bulk_change_status Groups: create_group, list_groups, delete_group Statuses: create_status, list_statuses, delete_status References: add_task_reference, remove_task_reference, get_task_references

Bulk Operations in Detail

bulk_create_tasks: Perfect for project initialization, breaking down large initiatives into subtasks, or importing task lists. Supports shared properties (group, status, assignee, tags) that apply to all tasks while allowing individual task customization.

bulk_update_tasks: Ideal for team management scenarios like reassigning multiple tasks, updating priorities across a project, or applying deadline changes to related tasks.

bulk_change_status: Essential for workflow management such as moving multiple tasks through pipeline stages, marking sprint tasks as complete, or transitioning project phases.

Each tool includes comprehensive error handling, detailed result reporting, and maintains data integrity even during partial failures.

Development

Build

npm run build

Development mode with auto-rebuild

npm run dev

Project Structure

src/
├── types.ts      # TypeScript type definitions
├── database.ts   # Data persistence and management
└── index.ts      # MCP server implementation

License

ISC License

Available Tools

17 tools
add_task_referenceA

Create a reference between two tasks (blocks, blocked-by, relates-to, etc.). Use this to model task dependencies and relationships.

Inputs: type (required), taskId (required), referencedTaskId (required), description.

bulk_change_statusA

Change the status of multiple tasks at once with optional note. Perfect for workflow transitions.

Inputs: taskIds (required), statusId (required), note.

bulk_create_tasksA

Create multiple tasks at once with shared properties. Ideal for breaking down large projects or importing task lists.

Inputs: tasks (required), tags, groupId, assignee, +1 more.

bulk_update_tasksA

Update multiple tasks simultaneously with the same changes. Useful for batch operations like changing assignees or priorities.

Inputs: taskIds (required), updates (required).

create_groupA

Create a new task group for organizing related tasks (e.g., projects, areas, etc.).

Inputs: name (required), color, description.

create_statusB

Create a custom task status with optional color and description.

Inputs: name (required), color, isDefault, description.

create_taskA

Create a new task with optional group, status, and metadata. AI should use this to track user requests and break down complex work into manageable tasks.

Inputs: title (required), tags, dueDate, groupId, +6 more.

delete_groupA

Delete a group. Tasks in the group will be ungrouped but not deleted.

Inputs: id (required).

delete_statusA

Delete a custom status. Cannot delete default status or statuses in use.

Inputs: id (required).

delete_taskA

Delete a task and remove all references to it from other tasks.

Inputs: id (required).

get_taskA

Get detailed information about a specific task including its history, references, and metadata.

Inputs: id (required).

get_task_referencesA

Get all incoming and outgoing references for a task to understand dependencies.

Inputs: taskId (required).

list_groupsA

List all task groups with their metadata.

Inputs: no named parameters.

list_statusesA

List all available task statuses.

Inputs: no named parameters.

list_tasksB

List tasks with optional filtering. AI should use this to understand current workload, find related tasks, and provide context-aware assistance.

Inputs: tags, search, dueAfter, groupIds, +4 more.

remove_task_referenceB

Remove a reference between two tasks.

Inputs: type (required), taskId (required), referencedTaskId (required).

update_taskA

Update an existing task. Use this to change status, add progress notes, update estimates, etc. Status changes are automatically tracked with timestamps.

Inputs: id (required), tags, title, dueDate, +8 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 17 tools

    Disambiguation5/5

    Each tool targets a distinct resource and action: tasks, groups, statuses, references, and bulk operations are clearly separated. No two tools overlap in purpose, and the singular vs. bulk distinction is explicit.

    Naming Consistency5/5

    All tools use a consistent verb_noun pattern in snake_case, with 'bulk_' prefixed for batch operations. This makes the tool set highly predictable and easy to navigate.

    Tool Count4/5

    With 17 tools, the server covers tasks, groups, statuses, references, and bulk operations comprehensively. While slightly above the ideal 10-15 range, the count is justified by the broad domain and no tools seem redundant.

    Completeness4/5

    The task lifecycle (CRUD), references, and bulk operations are fully covered. Minor gaps include missing update operations for groups and statuses (e.g., rename group, change status metadata), but these can be worked around.

    Related MCP Connectors

    Related MCP Servers