TasksMultiserver

TasksMultiServer provides a multi-interface, hierarchical task management system that exposes a local MCP server for AI agents, a REST API, and a web UI. It supports pluggable storage, dependency-aware planning, tagging, search, bulk operations, and rich visualization, making it easy to manage complex task workflows across multiple agents and interfaces.

How to use

You can access TasksMultiServer through three interfaces: an MCP Server for AI agents, a REST API for programmatic access, and a web UI for visual management. Use the MCP Server when your agents need direct, low-latency task interactions. Use the REST API when you want to integrate TasksMultiServer into applications or automation scripts. Use the React UI to explore projects, task lists, and tasks interactively.

Key workflows you can accomplish include creating tasks, organizing them into projects and task lists, linking tasks with dependencies, tagging for flexible filtering, performing bulk operations, analyzing dependencies to find critical paths, and visualizing task graphs in ASCII, DOT, or Mermaid formats.

How to install

Prerequisites: you need Python and Git installed on your system. You will also use a virtual environment to isolate dependencies.

Step by step to install and run the MCP server locally:

# Clone the repository
git clone https://github.com/YOUR_USERNAME/tasks-multiserver.git
cd tasks-multiserver

# Create and activate a virtual environment
python -m venv .venv
source .venv/bin/activate

# Install in development mode
pip install -e ".[dev]"

# Run the MCP server (stdio-based, local)
python -m src.interfaces.mcp.server

Configuration and startup details

You can run the MCP server with a local filesystem store and specific environment variables to tailor behavior. The following configuration starts the server in dev mode and points to a filesystem-backed data store.

To run with a filesystem store, you can use a configuration block like this in your MCP client settings:

{
  "mcpServers": {
    "tasks_multiserver": {
      "command": "python",
      "args": ["-m", "src.interfaces.mcp.server"],
      "cwd": "/path/to/tasks-multiserver",
      "env": {
        "DATA_STORE_TYPE": "filesystem",
        "FILESYSTEM_PATH": "/path/to/tasks",
        "MULTI_AGENT_ENVIRONMENT_BEHAVIOR": "false"
      }
    }
  }
}

Additional usage notes

When you are ready to publish or deploy, you can switch to a REST API and UI setup using Docker Compose. The REST API and web UI are accessible after starting the services; use the provided environment controls to switch the storage backend or enable multi-agent coordination.

Configuration

TasksMultiServer supports two backing stores and multi-agent coordination settings. You manage these through environment variables and optional Docker Compose configuration.

Environment variables you may set in development or production include the following (examples shown):

# Storage Backend (required)
DATA_STORE_TYPE=filesystem  # Options: "filesystem" or "postgresql"

# Filesystem Configuration (when DATA_STORE_TYPE=filesystem)
FILESYSTEM_PATH=/path/to/tasks  # Default: /tmp/tasks

# PostgreSQL Configuration (when DATA_STORE_TYPE=postgresql)
POSTGRES_URL=postgresql://user:password@localhost:5432/dbname

# Multi-Agent Coordination (optional)
MULTI_AGENT_ENVIRONMENT_BEHAVIOR=false  # Options: "true" or "false"

Security and deployment notes

Keep your MCP server secured behind appropriate network controls when exposing the REST API. Use TLS for endpoints that traverse untrusted networks and manage credentials with environment variables or a secrets manager.

Troubleshooting and tips

If you encounter validation errors or blocking information during task operations, check the real-time feedback indicators and ensure you pass valid enum values such as NOT_STARTED, IN_PROGRESS, BLOCKED, or COMPLETED for statuses and CRITICAL, HIGH, MEDIUM, LOW, or TRIVIAL for priorities.

Notes and examples

The system supports bulk operations, tag management, and dependency analysis with visualizations. You can add and remove tags in batch, analyze dependencies to identify the critical path, and render dependency graphs in ASCII, DOT, or Mermaid formats.

Available tools

add_task_tags

Add tags to a specific task and deduplicate tags for consistent filtering.

remove_task_tags

Remove specified tags from a task and refresh its tag set.

search_tasks

Unified search across tasks with filters for text, status, priority, tags, and project.

analyze_dependencies

Analyze task dependencies to identify the critical path, bottlenecks, and circular dependencies.

visualize_dependencies

Render dependency graphs in ASCII, DOT, or Mermaid formats for documentation or terminal display.

bulk_create_tasks

Create multiple tasks in a single operation with validation and transactional safety.

bulk_update_tasks

Update multiple tasks in a single operation with partial failure reporting.