Adaptive Parallel Reasoning MCP Server

An MCP server implementation that provides a tool for dynamic, adaptive, and parallel problem-solving. This MCP aims to outperform sequential thinking by decomposing complex problems, executing sub-tasks in parallel, and dynamically adapting its strategy.

Features

• Decomposes complex problems into manageable sub-tasks.
• Executes sub-tasks in parallel using Worker Agents.
• Dynamically monitors and adapts problem-solving strategy.
• Synthesizes results from parallel workers into a coherent solution.

Architecture

The Adaptive Parallel Reasoning MCP operates with three core agent types, each exposed as a distinct tool:

1. Orchestrator Agent (adaptive_parallel_reasoning tool):

   • Role: The central control unit. It receives the initial complex problem, decomposes it into smaller sub-tasks, and manages the overall workflow.
   • Key Responsibilities: Problem decomposition, spawning and monitoring Worker Agents, adapting the plan based on worker feedback (successes or failures), and coordinating with the Synthesizer Agent.
   • Workflow: Starts by decomposing the problem, then spawns workers, monitors their progress, and eventually triggers synthesis or plan refinement.

2. Worker Agent (worker_process_subtask tool):

   • Role: Executes specific sub-tasks assigned by the Orchestrator in parallel.
   • Key Responsibilities: Focused problem-solving for its assigned sub-task, reporting progress, intermediate outputs, and final results (or errors) back to the Orchestrator.
   • Workflow: Receives a sub-task, processes it (potentially in multiple steps), and reports its status and output.

3. Synthesizer Agent (synthesize_results tool):

   • Role: Integrates and consolidates the findings from all Worker Agents into a coherent, comprehensive final solution.
   • Key Responsibilities: Aggregating successful worker outputs, reconciling conflicting information, summarizing the integrated findings, and finalizing the overall solution.
   • Workflow: Takes all worker outputs, aggregates them, reconciles any discrepancies, summarizes the findings, and produces the final solution.

Tools

1. adaptive_parallel_reasoning (Orchestrator Tool)

Facilitates a dynamic, adaptive, and parallel reasoning process for complex problem-solving.

Inputs:

• problem_statement (string): The initial complex problem or task to solve.
• current_plan (string, optional): The current high-level plan or strategy being followed by the Orchestrator.
• sub_tasks_status (array of objects, optional): An array describing the status of active sub-tasks (e.g., [{id: "task1", status: "in_progress", progress: "50%"}]).
• worker_outputs (array of strings, optional): Outputs or findings from Worker Agents that need to be considered or synthesized.
• action (string): The action the Orchestrator should take (e.g., "decompose", "spawn_workers", "monitor", "synthesize", "refine_plan", "report_final_solution").
• context (string, optional): Additional context or information relevant to the current action.

Usage Flow:

1. Start by calling this tool with action: "decompose" and providing the problem_statement.
2. Follow the next_action suggested in the tool's output.
3. Provide sub_tasks_status and worker_outputs when calling with action: "monitor" to update the Orchestrator on worker progress.
4. Continue calling the tool with the suggested next_action until status: "completed" is returned.
5. If an error occurs, analyze the error field in the output and adjust your approach.

2. worker_process_subtask (Worker Tool)

A tool for a Worker Agent to process a specific sub-task assigned by the Orchestrator.

Inputs:

• sub_task_id (string): The unique identifier for the sub-task assigned by the Orchestrator.
• sub_task_description (string): A description of the sub-task to be processed.
• worker_id (string): The unique identifier of this Worker Agent.
• action (string): The specific action the Worker Agent should perform (e.g., "start", "process", "report_progress", "complete", "fail").
• context (string, optional): Additional context or information relevant to the current action.

Usage Flow:

1. Start by calling this tool with action: "start" after receiving a sub-task from the Orchestrator.
2. Periodically call this tool with action: "process" to simulate work or perform actual computations.
3. Use action: "report_progress" to provide updates to the Orchestrator.
4. Call this tool with action: "complete" when the sub-task is successfully finished, providing the final output.
5. Call this tool with action: "fail" if the sub-task encounters an unrecoverable error, providing an error message.

3. synthesize_results (Synthesizer Tool)

A tool for the Synthesizer Agent to aggregate, reconcile, and summarize outputs from Worker Agents to produce a final coherent solution to a complex problem.

Inputs:

• problem_statement (string): The original problem statement that the Orchestrator is solving.
• worker_outputs (array of objects): An array of objects containing the outputs from Worker Agents.
• action (string): The specific action the Synthesizer should perform (e.g., "aggregate", "reconcile", "summarize", "finalize").
• context (string, optional): Additional context or information relevant to the current action.

Usage Flow:

1. Start by calling this tool with action: "aggregate" and providing the problem_statement and worker_outputs.
2. Follow the logical flow: aggregate -> reconcile -> summarize -> finalize.
3. Provide context if specific instructions are needed for reconciliation or summarization.
4. Continue calling the tool with the next logical action until status: "completed" is returned, which will contain the final_solution.

Configuration

To use this MCP server, you need to configure it in your MCP client (e.g., Claude Desktop, VS Code).

Example mcp.json configuration (for npx):

{
  "servers": {
    "adaptive-parallel-reasoning": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-adaptive-parallel-reasoning"
      ]
    }
  }
}

Example mcp.json configuration (for docker):

{
  "servers": {
    "adaptive-parallel-reasoning": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "mcp/adaptiveparallelreasoning"
      ]
    }
  }
}

Building

To build the Docker image:

docker build -t mcp/adaptiveparallelreasoning -f Dockerfile .

License

This MCP server is licensed under the MIT License.