🚀 Task Manager MCP Server (Go)

A powerful Go implementation of the Model Context Protocol (MCP) server for intelligent task and project management. This server integrates seamlessly with LLM applications to provide advanced task management capabilities with automatic complexity analysis and smart subtask creation.

✨ Features

📋 Core Task Management

Project-Based Organization: Create and manage multiple projects with markdown-based task files
Hierarchical Tasks: Support for tasks with subtasks and dependencies
Status Tracking: Comprehensive status management (todo, in_progress, done, blocked)
Smart Navigation: Get next uncompleted tasks automatically
File-Based Storage: Human-readable markdown files for easy version control

🧠 Enhanced Intelligence (LLM-Driven)

Complexity Analysis: LLM evaluates task complexity and suggests breakdowns
Smart Subtask Creation: Automatically break down complex tasks (recursive up to 3 levels)
Choice Management: Handle multiple implementation approaches with structured user input
Decision Tracking: Remember and track user decisions in project files

🏷️ Rich Metadata

Categories: [MVP], [AI], [UX], [INFRA] for organized task classification
Priorities: P0 (Critical), P1 (High), P2 (Medium), P3 (Low)
Complexity Levels: Low, Medium, High with estimated hours
Dependencies: Track task relationships and prerequisites

🚀 Quick Start

Prerequisites

Go 1.21+: Download Go
Git: For cloning the repository
MCP Client: Any MCP-compatible client (Claude Desktop, etc.)

Installation

# Clone the repository
git clone https://github.com/gosvig123/mcp-task-manager-go.git
cd mcp-task-manager-go

# Install dependencies
go mod tidy

# Build the server
go build -o task-manager-go main.go

# Test the installation
go run cmd/test/main.go

Configuration

Create a .env file (optional):

# Transport type (stdio or sse)
TRANSPORT=stdio

# For SSE transport (web-based clients)
HOST=0.0.0.0
PORT=8050

# Task storage directory (relative to project root)
TASKS_DIR=./tasks

# Task management settings
MAX_RECURSION_DEPTH=3
AUTO_SUBTASK_CREATION=true

🔧 Usage

Running the Server

Method 1: Direct Execution (Stdio)

# Run with stdio transport (default)
./task-manager-go

# Or with Go run
go run main.go

Method 2: SSE Transport (Web-based)

# Set environment variable and run
TRANSPORT=sse ./task-manager-go

# Or export and run
export TRANSPORT=sse
./task-manager-go

🔌 MCP Client Integration

Claude Desktop Configuration

Add to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "task-manager-go": {
      "command": "/path/to/your/task-manager-go",
      "env": {
        "TRANSPORT": "stdio",
        "TASKS_DIR": "tasks"
      }
    }
  }
}

Alternative: Using Go Run

{
  "mcpServers": {
    "task-manager-go": {
      "command": "go",
      "args": ["run", "main.go"],
      "cwd": "/path/to/mcp-task-manager-go",
      "env": {
        "TRANSPORT": "stdio"
      }
    }
  }
}

SSE Configuration (for web clients)

{
  "mcpServers": {
    "task-manager-go": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

🛠️ Available MCP Tools

📁 Project Management

create_task_file - Create new project task files

Parameters: project_name (string)
Returns: Confirmation with file path

list_projects - List all available projects

Parameters: None
Returns: Array of project names

✅ Task Operations

add_task - Add tasks with descriptions and subtasks

Parameters:
  - project_name (string)
  - title (string)
  - description (string)
  - subtasks (array, optional)
  - batch_mode (boolean, optional)
Returns: Confirmation message

update_task_status - Update task/subtask status

Parameters:
  - project_name (string)
  - task_title (string)
  - subtask_title (string, optional)
  - status (enum: todo|in_progress|done|blocked)
Returns: Status update confirmation

get_next_task - Get next uncompleted task

Parameters: project_name (string)
Returns: JSON with task and subtask details

🧠 Advanced Features (Coming Soon)

parse_prd - Convert PRDs into structured tasks
expand_task - Break down tasks into subtasks
estimate_task_complexity - LLM-based complexity analysis
suggest_next_actions - AI-powered suggestions
get_task_dependencies - Track task relationships
generate_task_file - Generate file templates

📖 Usage Examples

Basic Workflow

Create a new project:

LLM: "Create a task file for my web app project"
→ Calls: create_task_file(project_name="web-app")

Add tasks with complexity analysis:

LLM: "Add a task to implement user authentication"
→ LLM analyzes complexity → High complexity detected
→ Calls: add_task(project_name="web-app", title="User Authentication",
          description="Implement secure user login/logout system",
          subtasks=["Set up auth middleware", "Create login endpoints", ...])

Track progress:

LLM: "What should I work on next?"
→ Calls: get_next_task(project_name="web-app")
→ Returns: {"task": "User Authentication", "subtask": "Set up auth middleware"}

Update status:

LLM: "Mark the auth middleware as completed"
→ Calls: update_task_status(project_name="web-app",
          task_title="User Authentication",
          subtask_title="Set up auth middleware",
          status="done")

Example Task File Output

# Project Tasks

## Categories
- [MVP] Core functionality tasks
- [AI] AI-related features
- [UX] User experience improvements
- [INFRA] Infrastructure and setup

## Priority Levels
- P0: Blocker/Critical
- P1: High Priority
- P2: Medium Priority
- P3: Low Priority

## Task 1: [MVP] User Authentication (P0)

Implement secure user login/logout system with session management

### Dependencies:
- Task 2

### Complexity: high
Estimated hours: 16

### Subtasks:

- [x] Set up auth middleware
- [ ] Create login endpoints
- [ ] Add password hashing
- [ ] Implement session management

---

🏗️ Project Structure

mcp-task-manager-go/
├── main.go                    # Entry point
├── cmd/
│   └── test/                  # Test utilities
├── internal/
│   ├── server/               # MCP server implementation
│   │   └── server.go         # Tool handlers and server setup
│   └── task/                 # Task management core
│       ├── models.go         # Data structures
│       ├── manager.go        # File operations
│       ├── markdown.go       # Markdown processing
│       └── validation.go     # Input validation
├── tasks/                    # Task files storage (created at runtime)
├── go.mod                    # Go module definition
└── README.md                 # This file

🧠 Enhanced Rules System

Automatic Subtask Creation

The system intelligently breaks down complex tasks:

LLM Complexity Analysis: The calling LLM evaluates task descriptions
Automatic Breakdown: High complexity tasks get broken into manageable subtasks
Recursive Processing: Subtasks are also analyzed (up to 3 levels deep)
Smart Thresholds: Configurable complexity detection

Choice Management

Handle multiple implementation approaches:

Approach Detection: LLM identifies when multiple approaches exist
Structured Choices: Present options in a clear format
Decision Tracking: Store user selections in project files
Context Preservation: Remember decisions for future reference

Example Choice Flow

**Choice:** Choose authentication method
Options:
- [ ] JWT tokens
- [x] Session-based auth
- [ ] OAuth integration

Reasoning: Session-based auth is simpler for MVP and provides better security for this use case.

🔧 Development

Building

# Build for current platform
go build -o task-manager-go main.go

# Build for different platforms
GOOS=linux GOARCH=amd64 go build -o task-manager-go-linux main.go
GOOS=windows GOARCH=amd64 go build -o task-manager-go.exe main.go

Testing

# Run basic functionality test
go run cmd/test/main.go

# Run all tests (when implemented)
go test ./...

# Test with a real MCP client
./task-manager-go

Contributing

Fork the repository
Create a feature branch: git checkout -b feature-name
Make your changes and test thoroughly
Commit with clear messages: git commit -m "Add feature X"
Push and create a Pull Request

📋 Roadmap

Core Task Management - Basic CRUD operations
MCP Server Integration - Stdio and SSE transports
Markdown Storage - Human-readable task files
PRD Parsing - Convert requirements to tasks
Advanced Tools - Complexity analysis, suggestions
Choice Workflows - Interactive decision making
Dependencies - Task relationship management
Templates - File generation from tasks

📄 License

MIT License - see LICENSE file for details.

🤝 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Documentation: This README and inline code comments

Made with ❤️ for the MCP ecosystem

Task Manager (Go)