Task Manager MCP Server

A template implementation of the Model Context Protocol (MCP) server for managing tasks and projects. This server provides a comprehensive task management system with support for project organization, task tracking, and PRD parsing.

Overview

This project demonstrates how to build an MCP server that enables AI agents to manage tasks, track project progress, and break down Product Requirements Documents (PRDs) into actionable tasks. It serves as a practical template for creating your own MCP servers with task management capabilities.

The implementation follows the best practices laid out by Anthropic for building MCP servers, allowing seamless integration with any MCP-compatible client.

Features

The server provides several essential task management tools:

Task Management
- create_task_file: Create new project task files
- add_task: Add tasks to projects with descriptions and subtasks
- update_task_status: Update the status of tasks and subtasks
- get_next_task: Get the next uncompleted task from a project
Project Planning
- parse_prd: Convert PRDs into structured tasks automatically
- expand_task: Break down tasks into smaller, manageable subtasks
- estimate_task_complexity: Estimate task complexity and time requirements
- get_task_dependencies: Track task dependencies
Development Support
- generate_task_file: Generate file templates based on task descriptions
- suggest_next_actions: Get AI-powered suggestions for next steps

Prerequisites

Python 3.12+
API keys for your chosen LLM provider (OpenAI, OpenRouter, or Ollama)
Docker if running the MCP server as a container (recommended)

Installation

Using uv

Install uv if you don't have it:
pip install uv
Clone this repository:
git clone https://github.com/coleam00/mcp-mem0.git cd mcp-mem0
Install dependencies:
uv pip install -e .
Create a .env file based on .env.example:
cp .env.example .env
Configure your environment variables in the .env file (see Configuration section)

Using Docker (Recommended)

Build the Docker image:
docker build -t mcp/mem0 --build-arg PORT=8050 .
Create a .env file based on .env.example and configure your environment variables

Configuration

The following environment variables can be configured in your .env file:

Variable	Description	Example
`TRANSPORT`	Transport protocol (sse or stdio)	`sse`
`HOST`	Host to bind to when using SSE transport	`0.0.0.0`
`PORT`	Port to listen on when using SSE transport	`8050`
`LLM_PROVIDER`	LLM provider (openai, openrouter, or ollama)	`openai`
`LLM_BASE_URL`	Base URL for the LLM API	`https://api.openai.com/v1`
`LLM_API_KEY`	API key for the LLM provider	`sk-...`
`LLM_CHOICE`	LLM model to use for task analysis	`gpt-4`

Running the Server

Using Python 3

# Set TRANSPORT=sse in .env then:
python3 src/main.py

The server will start on the configured host and port (default: http://0.0.0.0:8050).

Using Docker

docker build -t task-manager-mcp .
docker run --env-file .env -p 8050:8050 task-manager-mcp

Using the Task Manager

Creating a New Project

Create a task file for your project:

await mcp.create_task_file(project_name="my-project")

Add tasks to your project:

await mcp.add_task(
    project_name="my-project",
    title="Setup Development Environment",
    description="Configure the development environment with required tools",
    subtasks=[
        "Install dependencies",
        "Configure linters",
        "Set up testing framework"
    ]
)

Parse a PRD to create tasks automatically:

await mcp.parse_prd(
    project_name="my-project",
    prd_content="# Your PRD content..."
)

Managing Tasks

Update task status:

await mcp.update_task_status(
    project_name="my-project",
    task_title="Setup Development Environment",
    subtask_title="Install dependencies",
    status="done"
)

Get the next task to work on:

next_task = await mcp.get_next_task(project_name="my-project")

Expand a task into subtasks:

await mcp.expand_task(
    project_name="my-project",
    task_title="Implement Authentication"
)

Development Workflow

Generate a file template for a task:

await mcp.generate_task_file(
    project_name="my-project",
    task_title="User Authentication"
)

Get task complexity estimate:

complexity = await mcp.estimate_task_complexity(
    project_name="my-project",
    task_title="User Authentication"
)

Get suggestions for next actions:

suggestions = await mcp.suggest_next_actions(
    project_name="my-project",
    task_title="User Authentication"
)

Integration with MCP Clients

SSE Configuration

To connect to the server using SSE transport, use this configuration:

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

Stdio Configuration

For stdio transport, use this configuration:

{
  "mcpServers": {
    "task-manager": {
      "command": "python3",
      "args": ["src/main.py"],
      "env": {
        "TRANSPORT": "stdio",
        "LLM_PROVIDER": "openai",
        "LLM_API_KEY": "YOUR-API-KEY",
        "LLM_CHOICE": "gpt-4"
      }
    }
  }
}

Building Your Own Server

This template provides a foundation for building more complex task management MCP servers. To extend it:

Add new task management tools using the @mcp.tool() decorator
Implement custom task analysis and automation features
Add project-specific task templates and workflows
Integrate with your existing development tools and processes

Integrations