decompose_thinking

Break down complex problems into manageable components using hierarchical, functional, or temporal methods to simplify analysis and problem-solving.

Instructions

Break down complex problems into manageable components

Input Schema

TableJSON Schema

Name	Required	Description	Default
`problem`	Yes	Complex problem or topic to decompose
`method`	No	Decomposition method	hierarchical

Implementation Reference

src/tools/research/thinking-analysis-tools.ts:193-222 (handler)

The execute handler function for decompose_thinking tool. It takes a problem and optional method, creates a decomposition structure with components and relationships, and returns structured output or error.

execute: async (args: ToolInput): Promise<ToolOutput> => {
  try {
    const { problem, method = 'hierarchical' } = args;
    
    const decomposition = {
      problem,
      method,
      components: [
        { level: 1, component: `${problem} - Component 1` },
        { level: 2, component: `${problem} - Component 2` }
      ],
      relationships: ['Component dependencies', 'Sequential relationships']
    };

    return {
      success: true,
      data: decomposition,
      metadata: {
        tool: 'decompose_thinking',
        timestamp: new Date().toISOString()
      }
    };
  } catch (error) {
    return {
      success: false,
      error: `Problem decomposition failed: ${error instanceof Error ? error.message : String(error)}`,
      data: null
    };
  }
}

src/tools/research/thinking-analysis-tools.ts:177-192 (schema)

Input schema for decompose_thinking tool defining problem (required string) and optional method (enum: hierarchical, functional, temporal).

inputSchema: {
  type: 'object',
  properties: {
    problem: {
      type: 'string',
      description: 'Complex problem or topic to decompose'
    },
    method: {
      type: 'string',
      enum: ['hierarchical', 'functional', 'temporal'],
      description: 'Decomposition method',
      default: 'hierarchical'
    }
  },
  required: ['problem']
},

src/tools/research/thinking-analysis-tools.ts:172-223 (registration)

Local registration of the decompose_thinking tool within the registerThinkingAnalysisTools function, including name, description, schema, and handler.

registry.registerTool({
  name: 'decompose_thinking',
  description: 'Break down complex problems into manageable components',
  category: 'research',
  source: 'Thinking Analysis Engine',
  inputSchema: {
    type: 'object',
    properties: {
      problem: {
        type: 'string',
        description: 'Complex problem or topic to decompose'
      },
      method: {
        type: 'string',
        enum: ['hierarchical', 'functional', 'temporal'],
        description: 'Decomposition method',
        default: 'hierarchical'
      }
    },
    required: ['problem']
  },
  execute: async (args: ToolInput): Promise<ToolOutput> => {
    try {
      const { problem, method = 'hierarchical' } = args;
      
      const decomposition = {
        problem,
        method,
        components: [
          { level: 1, component: `${problem} - Component 1` },
          { level: 2, component: `${problem} - Component 2` }
        ],
        relationships: ['Component dependencies', 'Sequential relationships']
      };

      return {
        success: true,
        data: decomposition,
        metadata: {
          tool: 'decompose_thinking',
          timestamp: new Date().toISOString()
        }
      };
    } catch (error) {
      return {
        success: false,
        error: `Problem decomposition failed: ${error instanceof Error ? error.message : String(error)}`,
        data: null
      };
    }
  }
});

src/index.ts:255-255 (registration)
Top-level registration call in main server initialization that registers the thinking analysis tools group including decompose_thinking.
```
registerThinkingAnalysisTools(this.toolRegistry);   // 4 tools: deep_research, visualize_thinking, decompose_thinking, check_research_saturation
```

Open Search MCP