DeltaTask

Local 2025-08-31 23:43:46 0

Provides API access to a locally-hosted task management system with features for creating, updating, and organizing tasks, including support for urgency levels, effort estimates, subtasks, and bi-directional sync with Obsidian markdown files.

A powerful, locally-hosted task management application with Obsidian integration and a Model Context Protocol (MCP) server.

Features

Smart Task Management: Create tasks with urgency levels and effort estimates
Prioritization Engine: Automatically sorts tasks by urgency and effort
Task Decomposition: Split larger tasks into manageable subtasks
Tagging System: Organize tasks with custom tags
Local Storage: All data stored locally in SQLite database
Obsidian Integration: Bi-directional sync with Obsidian markdown files
MCP Server: Full API access through Model Context Protocol

Technical Details

Data Model

Tasks: Core task entity with properties:
Title and description
Urgency (1-5 scale, 5 being highest)
Effort (1-21 scale, following Fibonacci sequence)
Completion status
Parent-child relationships for subtasks
Tags for categorization

Database Schema

The application uses SQLite with the following tables:

todos: Stores all task items and their properties
tags: Stores unique tag names
todo_tags: Junction table for many-to-many relationship between tasks and tags

Obsidian Integration

DeltaTask creates and maintains a structured Obsidian vault:

Task files with frontmatter metadata
Tag-based views for filtering tasks
Statistics dashboard
Bi-directional sync between Obsidian markdown and SQLite database

MCP API Endpoints

The MCP server exposes the following operations:

get_task_by_id: Get a specific task by ID
search_tasks: Find tasks by title, description, or tags
create_task: Create a new task
update_task: Update a task's properties
delete_task: Remove a task
sync_tasks: Sync tasks from Obsidian markdown into SQLite
list_tasks: List all tasks
get_statistics: Retrieve metrics about tasks
create_subtasks: Split a task into multiple subtasks
get_all_tags: Get all unique tag names
get_subtasks: Get subtasks for a given parent task
finish_task: Mark a task as completed

Getting Started

Prerequisites

Python 3.10+
SQLite3
Obsidian (optional, for markdown integration)

Installation

Clone this repository
Set up the Python environment using uv:

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

# Install dependencies
uv pip install -r requirements.txt

Running the MCP Server

The DeltaTask MCP server can be used with Claude for Desktop:

Configure Claude for Desktop:
Open or create ~/Library/Application Support/Claude/claude_desktop_config.json
Add the DeltaTask server configuration:

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

Restart Claude for Desktop

If you run into issues or want more details, check out the Docs for the MCP.

For instance from the docs:

You may need to put the full path to the uv executable in the command field. You can get this by running which uv on MacOS/Linux or where uv on Windows.

Use the DeltaTask tools in Claude for Desktop by clicking the hammer icon

Model Context Protocol (MCP)

This application implements a Model Context Protocol approach for task management:

Structured Data Model: Clearly defined schema for tasks with relationships
Priority Calculation: Intelligent sorting based on multiple factors
Hierarchical Organization: Parent-child relationships for task decomposition
Tagging System: Flexible categorization for better context
Statistics and Insights: Data aggregation for understanding task patterns
Obsidian Integration: Markdown-based visualization and editing

License

MIT License

[
  {
    "description": "Get details for a specific task by ID.",
    "inputSchema": {
      "properties": {
        "task_id": {
          "title": "Task Id",
          "type": "string"
        }
      },
      "required": [
        "task_id"
      ],
      "title": "get_task_by_idArguments",
      "type": "object"
    },
    "name": "get_task_by_id"
  },
  {
    "description": "Search tasks by title, description, or tags.",
    "inputSchema": {
      "properties": {
        "query": {
          "title": "Query",
          "type": "string"
        }
      },
      "required": [
        "query"
      ],
      "title": "search_tasksArguments",
      "type": "object"
    },
    "name": "search_tasks"
  },
  {
    "description": "Create a new task.",
    "inputSchema": {
      "properties": {
        "description": {
          "default": "",
          "title": "Description",
          "type": "string"
        },
        "effort": {
          "default": 1,
          "title": "Effort",
          "type": "integer"
        },
        "tags": {
          "default": [],
          "items": {
            "type": "string"
          },
          "title": "Tags",
          "type": "array"
        },
        "title": {
          "title": "Title",
          "type": "string"
        },
        "urgency": {
          "default": 1,
          "title": "Urgency",
          "type": "integer"
        }
      },
      "required": [
        "title"
      ],
      "title": "create_taskArguments",
      "type": "object"
    },
    "name": "create_task"
  },
  {
    "description": "Update an existing task.",
    "inputSchema": {
      "properties": {
        "task_id": {
          "title": "Task Id",
          "type": "string"
        },
        "updates": {
          "title": "Updates",
          "type": "object"
        }
      },
      "required": [
        "task_id",
        "updates"
      ],
      "title": "update_taskArguments",
      "type": "object"
    },
    "name": "update_task"
  },
  {
    "description": "Delete a task.",
    "inputSchema": {
      "properties": {
        "task_id": {
          "title": "Task Id",
          "type": "string"
        }
      },
      "required": [
        "task_id"
      ],
      "title": "delete_taskArguments",
      "type": "object"
    },
    "name": "delete_task"
  },
  {
    "description": "Sync tasks from Obsidian markdown into SQLite.",
    "inputSchema": {
      "properties": {},
      "title": "sync_tasksArguments",
      "type": "object"
    },
    "name": "sync_tasks"
  },
  {
    "description": "List all tasks with optional tags, if you user asks for a tag, please provide it in the request.",
    "inputSchema": {
      "properties": {
        "tags": {
          "default": {
            "path": "setup.py",
            "type": "blob"
          },
          "items": {
            "type": "string"
          },
          "title": "Tags",
          "type": "array"
        }
      },
      "title": "list_tasksArguments",
      "type": "object"
    },
    "name": "list_tasks"
  },
  {
    "description": "Get task statistics including completion rates and urgency distribution.",
    "inputSchema": {
      "properties": {},
      "title": "get_statisticsArguments",
      "type": "object"
    },
    "name": "get_statistics"
  },
  {
    "description": "Create multiple subtasks for a parent task with categories.",
    "inputSchema": {
      "properties": {
        "subtasks": {
          "items": {
            "type": "object"
          },
          "title": "Subtasks",
          "type": "array"
        },
        "task_id": {
          "title": "Task Id",
          "type": "string"
        }
      },
      "required": [
        "task_id",
        "subtasks"
      ],
      "title": "create_subtasksArguments",
      "type": "object"
    },
    "name": "create_subtasks"
  },
  {
    "description": "Get all unique tag names used in tasks.",
    "inputSchema": {
      "properties": {},
      "title": "get_all_tagsArguments",
      "type": "object"
    },
    "name": "get_all_tags"
  },
  {
    "description": "Get subtasks for a given parent task ID.",
    "inputSchema": {
      "properties": {
        "parent_id": {
          "title": "Parent Id",
          "type": "string"
        }
      },
      "required": [
        "parent_id"
      ],
      "title": "get_subtasksArguments",
      "type": "object"
    },
    "name": "get_subtasks"
  },
  {
    "description": "Mark a task as completed.",
    "inputSchema": {
      "properties": {
        "task_id": {
          "title": "Task Id",
          "type": "string"
        }
      },
      "required": [
        "task_id"
      ],
      "title": "finish_taskArguments",
      "type": "object"
    },
    "name": "finish_task"
  }
]