DeltaTask MCP Server

How to use

You access the DeltaTask MCP Server through an MCP client to perform core task operations. Use it to create tasks with urgency and effort estimates, decompose larger work into subtasks, tag items for quick filtering, and mark items as complete. You can search by title, description, or tags, and you can retrieve statistics and subtasks to understand progress and structure. If you use Obsidian, you can sync between Obsidian markdown files and the local SQLite database for seamless cross-tool workflow.

Typical usage patterns include: creating a new task with a clear title, description, urgency, and effort; adding subtasks to break work down; tagging tasks to group related work; and periodically syncing with Obsidian to reflect markdown changes in the MCP database. You can list all tasks to review workload, retrieve subtasks for a parent task to inspect breakdowns, and finish tasks as you complete work. For analytics, request statistics to see trends in completion, tagging distribution, and workload over time.

To work with the server, rely on the MCP client to call the available endpoints such as creating tasks, updating attributes, searching, and syncing. You’ll typically perform a flow like: create a task, add subtasks as needed, assign tags, sync with Obsidian if you maintain a vault, then finish tasks when done. The system exposes a structured data model with parent-child relationships, tag support, and clear completion status to keep your project organized.

How to install

Prerequisites You need Python 3.10+ and SQLite3 on your machine. Obsidian is optional but recommended if you want markdown integration.

Step 1 — Prepare the environment and install dependencies Create a virtual environment and install dependencies with the following commands.

# Create and activate the virtual environment
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
uv pip install -r requirements.txt

Step 2 — Run the MCP server You will run the server using the MCP tool runner. The server entry point is server.py located in the DeltaTask project directory.

# Start the DeltaTask MCP server via the MCP runner
uv run server.py

Step 3 — Configure a local client If you use Claude for Desktop or another MCP client, register the DeltaTask MCP server with the client. The following example shows how to configure the client to start the DeltaTask server using the uv runner.

{
  "mcpServers": {
    "deltatask": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/DeltaTask",
        "run",
        "server.py"
      ]
    }
  }
}

Restart the client after adding the DeltaTask MCP server so the new configuration takes effect.

Configuration and notes

MCP server configuration for DeltaTask is provided above. The server runs locally and exposes endpoints for task operations such as creating, updating, deleting, searching, and syncing tasks. All data is stored in a local SQLite database, and Obsidian integration can synchronize task files and metadata with the database.

Environment and tooling notes You will use the uv tool to manage the local environment and dependencies. Typical commands you will run include creating the virtual environment, installing dependencies, and starting the MCP server. If you need to locate the uv executable on your system, you can use system commands to determine its path and then point your client at that path.

Endpoints and capabilities at a glance

DeltaTask exposes a range of endpoints for working with tasks, subtasks, and tags, as well as statistics and synchronization with Obsidian. You can expect to find operations for: getting a task by ID, searching tasks by title/description/tags, creating/updating/deleting tasks, listing tasks, and finishing tasks. You can also create subtasks from a parent task and retrieve subtasks for a given parent.

get_task_by_id

Retrieve a single task by its unique ID, returning full task details including subtasks, tags, and status.

search_tasks

Find tasks by title, description, or tag filters to quickly locate relevant work.

create_task

Create a new task with a title, description, urgency, and effort; optionally attach tags and subtasks.

update_task

Modify properties of an existing task such as title, description, status, and tags.

delete_task

Remove a task and its subtasks from the store.

sync_tasks

Synchronize task data between Obsidian markdown files and the SQLite database.

list_tasks

Return an overview of all tasks, suitable for dashboards or bulk operations.

get_statistics

Retrieve metrics about tasks, such as completion rate, distribution by tags, and workload trends.

create_subtasks

Split a parent task into multiple subtasks to better plan work.

get_all_tags

Return all unique tag names used across tasks.

get_subtasks

Get subtasks for a given parent task to inspect task decomposition.

finish_task

Mark a task as completed and record completion metadata.