Mcp.TaskAndResearch 1.0.22

MCP Task and Research Server

🦐 A .NET port of mcp-shrimp-task-manager — Intelligent task management for AI-powered development.

A powerful Model Context Protocol (MCP) server that provides advanced task management and research capabilities for AI assistants. This server enables structured task planning, dependency management, and guided research workflows — with an optional Blazor Server UI dashboard.

🚀 Quick Start

1. Install

dotnet tool install -g Mcp.TaskAndResearch

2. Configure VS Code

Create or edit .vscode/mcp.json in your project:

{
  "servers": {
    "task-and-research": {
      "type": "stdio",
      "command": "mcp-task-and-research",
      "env": {
        "DATA_DIR": "${workspaceFolder}/.mcp-tasks",
        "TASK_MANAGER_UI": "true",
        "TASK_MANAGER_UI_AUTO_OPEN": "true"
      }
    }
  }
}

💡 Important: Always set DATA_DIR to a project-specific path to keep tasks isolated between projects.

3. Start Using

1. Reload VS Code (Ctrl+Shift+P → "Developer: Reload Window")
2. Browser opens automatically to the Tasks UI
3. Use MCP tools via Copilot/Claude: plan_task, execute_task, verify_task, etc.

Update to latest version:

dotnet tool update -g Mcp.TaskAndResearch

💡 What is This?

MCP Task and Research Server transforms how AI agents approach software development. Instead of losing context or repeating work, it provides:

• 🧠 Persistent Memory: Tasks and progress persist across sessions
• 📋 Structured Workflows: Guided processes for planning, execution, and verification
• 🔄 Smart Decomposition: Automatically breaks complex tasks into manageable subtasks
• 🎯 Context Preservation: Never lose your place, even with token limits
• 🔗 Dependency Tracking: Automatic management of task relationships

✨ Core Features

📋 Task Management

🔬 Research Mode

• Guided Research: Systematic exploration of technologies and solutions
• State Management: Track research progress across sessions
• Next Steps Planning: Define and follow research directions

📏 Project Rules

• Project Standards: Define and maintain coding standards across your project
• Consistency: Ensure AI assistants follow your conventions

🤔 Thinking Tools

• Process Thought: Structured thinking with branching and revision support
• Chain-of-Thought: Encourages reflection and style consistency

💾 Memory & Data Management

• Task Snapshots: Automatic preservation of task state when clear_all_tasks runs (completed tasks are stored in DATA_DIR/memory)
• Memory Store: Dedicated memory management for context storage
• Automatic Backups: Completed tasks are written to timestamped JSON under DATA_DIR/memory before a clear; pending tasks are dropped during clear
• Per-Project Isolation: Set DATA_DIR to a project-scoped path (e.g., .mcp-tasks) and launch from the workspace root; without DATA_DIR, data is stored in the user-level default directory and shared across projects

🖥️ Blazor UI Dashboard

When TASK_MANAGER_UI=true:

• Tasks View: DataGrid with sorting, filtering, search, status indicators
• Task Details: Dialog for viewing/editing tasks, dependencies, related files
• History View: Browse all task activity including archived tasks
• Settings View: Configure preferences, theme, language
• Dark/Light Theme: Toggle with persistent preference
• Keyboard Shortcuts: Ctrl+N, Ctrl+F, Ctrl+S, Ctrl+R, Esc, ?
• Real-time Updates: Tasks sync instantly between MCP and UI

🎯 Common Use Cases

<details> <summary><b>Feature Development</b></summary>

You: "plan task: add user authentication with JWT"
# Agent analyzes codebase, creates subtasks with dependencies

You: "execute task"
# Implements authentication step by step, tracking progress

</details>

<details> <summary><b>Bug Fixing</b></summary>

You: "plan task: fix memory leak in data processing"
# Agent researches issue, creates fix plan with verification criteria

You: "execute all pending tasks"
# Executes all fix tasks, verifying each one

</details>

<details> <summary><b>Research & Learning</b></summary>

You: "research: compare Blazor vs React for this project"
# Systematic analysis with pros/cons, saved to memory

You: "plan task: migrate component to chosen framework"
# Creates migration plan based on research findings

</details>

<details> <summary><b>Project Setup</b></summary>

You: "init project rules"
# Establishes coding standards and conventions

You: "plan task: set up CI/CD pipeline"
# Creates structured plan following your project rules

</details>

🛠️ Available MCP Tools

Task Management Tools

Research & Thinking Tools

Project & Utility Tools

🛠️ Advanced Installation Options

For most users, the Quick Start above is all you need. For advanced scenarios:

Clone & Build (For Development)

git clone https://github.com/d-german/mcp-task-and-research.git
cd mcp-task-and-research
dotnet publish src/Mcp.TaskAndResearch/Mcp.TaskAndResearch.csproj -c Release -o ./publish

Then configure with the published DLL path instead of the command name.

⚠️ Data Storage & Project Isolation

TL;DR: Always set DATA_DIR to a project-specific path in your .vscode/mcp.json to keep tasks isolated between projects.

Why This Matters

Without DATA_DIR, all projects share one global task list, which causes:

• Tasks from different projects mixed together
• Wrong task execution (agent picks tasks from other projects)
• Broken dependencies across unrelated projects

Recommended Setup

Use project-specific paths in each project's .vscode/mcp.json:

{
  "env": {
    "DATA_DIR": "${workspaceFolder}/.mcp-tasks"
  }
}

Or use absolute paths:

{
  "env": {
    "DATA_DIR": "C:/projects/my-project/.mcp-tasks"
  }
}

Best practices:

• Use .mcp-tasks folder convention
• Add to .gitignore for private tasks (or commit for team sharing)
• One DATA_DIR per project ensures complete isolation

Environment Variables

Core Settings

Audio Notification Settings

Note: The play_beep tool only works on Windows. It's useful for getting notified when an AI agent completes a long-running task.

📚 History & Task Archival

When you clear the task list (via clear_all_tasks MCP tool or UI), completed tasks are automatically saved to snapshot files in the memory/ folder. The History View displays:

• Active tasks: Current tasks from tasks.json
• Archived tasks: Previously cleared tasks from all snapshot files

This means you never lose visibility into past work - cleared tasks remain viewable in History indefinitely.

Architecture

How It Works

┌─────────────────┐     ┌──────────────────┐
│   MCP Client    │────▶│  MCP Server      │
│ (Copilot/Claude)│     │  (stdio)         │
└─────────────────┘     └────────┬─────────┘
                                 │
                        ┌────────▼─────────┐
                        │   Shared DI      │
                        │   Container      │
                        └────────┬─────────┘
                                 │
              ┌──────────────────┼──────────────────┐
              │                  │                  │
     ┌────────▼────────┐ ┌──────▼───────┐ ┌───────▼───────┐
     │   TaskStore     │ │ MemoryStore  │ │  RulesStore   │
     │   (tasks)       │ │ (context)    │ │  (conventions)│
     └────────┬────────┘ └──────────────┘ └───────────────┘
              │
     ┌────────▼────────┐
     │  Blazor UI      │  (optional, auto-port)
     │  (MudBlazor)    │
     └─────────────────┘

• Shared Services: UI and MCP share the same data stores via DI
• Real-time Sync: Changes via MCP tools appear instantly in UI and vice versa
• Conditional Hosting: UI only starts when TASK_MANAGER_UI=true

Project Structure

src/Mcp.TaskAndResearch/
├── Config/           # Configuration and path resolution
├── Data/             # TaskStore, MemoryStore, data models
├── Prompts/          # Prompt template builders
├── Server/           # MCP server configuration
├── Tools/            # MCP tool implementations
├── UI/               # Blazor UI (when enabled)
│   ├── Components/   # Razor components
│   ├── Services/     # UI services
│   └── Theme/        # MudBlazor theme
└── wwwroot/          # Static assets

Development

Prerequisites

• .NET SDK
• VS Code with GitHub Copilot or Claude extension

Build from Source

# Clone the repository
git clone https://github.com/your-repo/mcp-task-and-research.git
cd mcp-task-and-research

# Build (debug)
dotnet build

# Run tests
dotnet test

# Publish release build
dotnet publish src/Mcp.TaskAndResearch/Mcp.TaskAndResearch.csproj -c Release -o ./publish

Rebuilding After Updates

When you pull updates from the repository:

cd mcp-task-and-research
git pull
dotnet publish src/Mcp.TaskAndResearch/Mcp.TaskAndResearch.csproj -c Release -o ./publish

Note: You must stop the MCP server before republishing (reload VS Code or close it), otherwise the DLL will be locked.

Run Standalone (Development)

For development without an MCP client:

# MCP server only (no UI)
dotnet run --project src/Mcp.TaskAndResearch

# With UI enabled
set TASK_MANAGER_UI=true && dotnet run --project src/Mcp.TaskAndResearch
# Then open http://localhost:9998

Using dotnet run vs Published DLL

For production use, always use the published DLL - it's faster to start and doesn't require recompilation.

Known Limitations

1. JSON File Storage: Tasks are persisted to DATA_DIR/tasks.json - changes from both UI and MCP tools are saved immediately
2. Single Project: Currently reads from one DATA_DIR; no multi-project switching in UI
3. No Authentication: UI has no auth; use for local development only
4. SignalR Reconnection: Brief stale data possible during connection recovery

📄 License

MIT License - See LICENSE file for details.

🌟 Credits

• Original Concept: mcp-shrimp-task-manager by cjo4m06
• .NET Port: d-german

<p align="center"> <a href="https://github.com/d-german/mcp-task-and-research">GitHub</a> • <a href="https://www.nuget.org/packages/Mcp.TaskAndResearch">NuGet</a> • <a href="https://github.com/d-german/mcp-task-and-research/issues">Issues</a> </p>