Problem Solving MCP Server

An intelligent problem-solving server that automatically forms multi-role teams and uses the Eisenhower matrix for efficient task management and collaboration.

GitHub

🚀 Problem Solving MCP Server

Multi-Role Collaborative Problem Solving Framework Based on Model Context Protocol

License: MIT Node Version TypeScript

📖 Documentation Navigation

DocumentDescriptionLanguage
README.mdComplete project documentation中文
README.mdComplete project documentationEnglish
INSTALLATION.mdInstallation and configuration guideEnglish
QUICK_START.mdQuick start guide (5 minutes)English
example-usage.mdDetailed usage examplesEnglish
安装指南安装和配置指南中文
快速开始5分钟快速配置中文
使用示例详细使用示例中文

🌟 Overview

This is an intelligent problem-solving MCP server that creates 3-12 professional roles based on problem complexity, uses the Eisenhower Matrix for priority management, and implements parallel processing optimization to generate comprehensive, executable, and efficient solutions.

✨ Core Features

  • 🎭 Intelligent Team Configuration: Automatically recommend 3-12 member teams based on problem complexity
  • 🔍 Multi-dimensional Quality Assurance: Comprehensive checks on completeness, feasibility, quality, risk, and timeline
  • ⚡ Parallel Processing Optimization: Automatically detect repetitive tasks and expand teams (up to 30 members)
  • 📊 Eisenhower Matrix Analysis: Important-urgent quadrant analysis for priority management
  • 🤝 Multi-role Collaboration: 12 professional role types for comprehensive problem solving
  • 💡 Reflection and Improvement: Built-in reflection mechanism for continuous optimization

🛠️ Quick Configuration

In Cursor

{
  "mcpServers": {
    "problem-solving": {
      "command": "node",
      "args": ["/path/to/problem-solving-mcp/dist/index.js"],
      "cwd": "/path/to/problem-solving-mcp",
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

In Claude Desktop

{
  "mcpServers": {
    "problem-solving": {
      "command": "node", 
      "args": ["/path/to/problem-solving-mcp/dist/index.js"],
      "cwd": "/path/to/problem-solving-mcp",
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

Note: Replace /path/to/problem-solving-mcp with your actual project path

🎯 API Documentation

Core Tools (4)

ToolDescriptionParameters
create_problemCreate problem definitiontitle, description, domain, complexity_score
solve_problemIntelligent problem solving (core function)problem_id
get_role_recommendationsGet role configuration suggestionsproblem_id
check_solutionCheck solution qualityproblem_id

Management Tools (4)

ToolDescriptionParameters
get_problem_historyView problem history-
get_team_statusView team statusproblem_id
update_team_memberUpdate team memberproblem_id, role_id, updates
assign_taskAssign tasksproblem_id, task, assigned_to, priority

Analysis Tools (4)

ToolDescriptionParameters
eisenhower_matrix_analysisImportant-urgent quadrant analysisproblem_id
analyze_task_dependenciesTask dependency analysisproblem_id
optimize_parallel_executionParallel execution optimizationproblem_id
get_execution_reportGet execution reportproblem_id

Reflection Tools (3)

ToolDescriptionParameters
create_reflectionCreate reflection recordproblem_id, phase, insights, lessons_learned
get_reflection_summaryGet reflection summaryproblem_id
improve_solutionImprove solutionproblem_id, feedback

🏗️ System Architecture

graph TB
    A[Problem Input] --> B[Role Creator]
    B --> C[Team Assembly]
    C --> D[Solution Generation]
    D --> E[Result Checker]
    E --> F{Quality Check}
    F -->|Pass| G[Execution Plan]
    F -->|Fail| H[Improvement Suggestions]
    H --> D
    G --> I[Parallel Optimizer]
    I --> J[Team Expansion]
    J --> K[Parallel Execution]
    K --> L[Coordinator]
    L --> M[Final Solution]
    M --> N[Reflection & Learning]
    
    subgraph "Core Components"
        B
        E
        L
        I
    end
    
    subgraph "Quality Assurance"
        F
        H
        N
    end
    
    subgraph "Execution Optimization"
        I
        J
        K
    end

🎭 Core Components

1. Role Creator (role-creator.ts)

  • Function: Intelligently create professional teams based on problem characteristics
  • Team Size: 3-12 members (expandable to 30 for parallel processing)
  • Role Types: 12 professional roles including analyst, researcher, designer, developer, etc.
  • Smart Matching: Select core and supporting roles based on problem domain and complexity

2. Result Checker (result-checker.ts)

  • Multi-dimensional Assessment: Completeness, feasibility, quality, risk, timeline
  • Problem Identification: Classify issues by severity (low, medium, high, critical)
  • Improvement Suggestions: Generate specific, actionable recommendations
  • Scoring System: Comprehensive scoring (0-100) with approval decisions

3. Coordinator (coordinator.ts)

  • Process Management: Complete problem-solving workflow orchestration
  • Task Dependencies: Manage task relationships and parallel execution
  • Progress Tracking: Real-time monitoring of solution progress
  • Quality Control: Multi-round improvement and iteration support

4. Parallel Optimizer (parallel-optimizer.ts)

  • Task Analysis: Evaluate task repetitiveness and workload
  • Team Expansion: Intelligent scaling based on workload analysis
  • Role Subdivision: Single-function multi-role parallel processing
  • Efficiency Target: 2.5x performance improvement goal

🚀 Best Practices

Problem Definition

// Good example
{
  title: "Develop AI Customer Service System",
  description: "Develop intelligent customer service system for e-commerce platform, supporting multi-turn dialogue, sentiment analysis, and automatic replies",
  domain: "software_development", 
  complexity_score: 8
}

Team Configuration

  • Simple Problems (1-3): 3-5 members, core roles
  • Medium Problems (4-6): 6-8 members, core + supporting roles
  • Complex Problems (7-10): 9-12 members, full professional team

Priority Management

Use Eisenhower Matrix for task prioritization:

  • Urgent & Important: Immediate action
  • Important & Not Urgent: Planned execution
  • Urgent & Not Important: Delegate or automate
  • Not Urgent & Not Important: Eliminate or postpone

⚙️ Configuration and Extension

Environment Variables

NODE_ENV=production          # Production mode
DEBUG_MODE=false            # Debug mode
MAX_TEAM_SIZE=30           # Maximum team size
PARALLEL_THRESHOLD=0.7     # Parallel processing threshold

Custom Role Types

// Extend role types in types.ts
export enum RoleType {
  // ... existing roles
  custom_specialist = 'custom_specialist'
}

📊 Performance Metrics

Efficiency Improvements

  • Team Expansion: Up to 30 members for complex tasks
  • Parallel Processing: 2.5x efficiency improvement target
  • Quality Assurance: Multi-dimensional scoring system
  • Iteration Optimization: Reflection-based continuous improvement

Resource Allocation

  • Capability-based: Workload distribution based on role capabilities
  • Conflict Avoidance: Prevent resource conflicts
  • Dynamic Load Balancing: Real-time workload adjustment

🧪 Testing and Debugging

Development Mode

npm run dev

Debug Logging

NODE_ENV=development npm start

Test Commands

# Basic functionality test
npm test

# Integration test
npm run test:integration

# Performance test
npm run test:performance

🚀 Deployment and Operations

Production Deployment

# Build project
npm run build

# Start service
npm start

# Process management (PM2)
pm2 start dist/index.js --name problem-solving-mcp

Monitoring

  • Health Checks: Service status monitoring
  • Performance Metrics: Response time, success rate tracking
  • Error Logging: Comprehensive error logging and alerting

Scaling

  • Horizontal Scaling: Multiple service instances
  • Load Balancing: Request distribution
  • Resource Monitoring: CPU, memory usage tracking

🤝 Community and Support

Getting Help

Contributing

  • 🔧 Code Contributions: Follow our Contributing Guide
  • 📝 Documentation: Help improve documentation
  • 🐛 Bug Reports: Report issues with detailed information
  • 💡 Feature Requests: Suggest new features

🗺️ Roadmap

Version 1.1

  • Persistent storage support (PostgreSQL, MongoDB)
  • Web dashboard interface
  • RESTful API endpoints
  • Role template marketplace

Version 1.2

  • Machine learning-based role recommendations
  • Advanced parallel processing algorithms
  • Integration with external project management tools
  • Multi-language support expansion

Version 2.0

  • Distributed processing architecture
  • Real-time collaboration features
  • Advanced analytics and reporting
  • Enterprise-grade security features

📄 License

MIT License - see LICENSE file for details

🎉 Congratulations! Your Problem Solving MCP Server is ready!

Start enjoying the power of intelligent problem solving! 🚀✨

관련 서버