task-manager-mcp

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.

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.

The server provides several essential task management tools:

1. 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

2. 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

3. Development Support

   • generate_task_file: Generate file templates based on task descriptions
   • suggest_next_actions: Get AI-powered suggestions for next steps

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

1. Install uv if you don't have it:

   pip install uv

2. Clone this repository:

   git clone https://github.com/coleam00/mcp-mem0.git
   cd mcp-mem0

3. Install dependencies:

   uv pip install -e .

4. Create a .env file based on .env.example:

   cp .env.example .env

5. Configure your environment variables in the .env file (see Configuration section)

1. Build the Docker image:

   docker build -t mcp/mem0 --build-arg PORT=8050 .

2. Create a .env file based on .env.example and configure your environment variables

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

# 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).

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

1. Create a task file for your project:

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

2. 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"
    ]
)

3. Parse a PRD to create tasks automatically:

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

1. Update task status:

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

2. Get the next task to work on:

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

3. Expand a task into subtasks:

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

1. Generate a file template for a task:

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

2. Get task complexity estimate:

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

3. Get suggestions for next actions:

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

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

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

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"
      }
    }
  }
}

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

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