sequential-thinking-mcp 1.0.0

package/README.md

@@ -0,0 +1,167 @@
+# Sequential Thinking MCP
+
+A Model Context Protocol (MCP) server that provides sequential thinking and problem-solving tools for systematic analysis and planning.
+
+## Features
+
+This MCP server provides four powerful tools for structured thinking:
+
+### 🧠 Sequential Thinking
+Apply a systematic methodology to solve complex problems step-by-step with structured analysis phases.
+
+### 🔍 Problem Breakdown
+Break down complex problems into smaller, manageable components across multiple levels of detail.
+
+### 📊 Problem Analysis
+Analyze problems using proven frameworks:
+- **SWOT Analysis**: Strengths, Weaknesses, Opportunities, Threats
+- **Pros/Cons Analysis**: Weighted decision making
+- **Root Cause Analysis**: 5 Whys and Fishbone diagrams
+- **Decision Tree Analysis**: Probabilistic decision making
+
+### 📋 Step-by-Step Planning
+Create detailed implementation plans with phases, milestones, and actionable tasks.
+
+## Installation
+
+```bash
+npm install -g sequential-thinking-mcp
+```
+
+## Usage
+
+### With MCP Clients
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "sequential-thinking-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+### Available Tools
+
+#### 1. Sequential Thinking
+```javascript
+{
+  "name": "sequential_thinking",
+  "arguments": {
+    "problem": "How to improve team productivity",
+    "context": "Remote team of 10 developers",
+    "constraints": ["Budget limited to $5000", "Must implement in 3 months"],
+    "goals": ["Increase productivity by 20%", "Improve team satisfaction"]
+  }
+}
+```
+
+#### 2. Problem Breakdown
+```javascript
+{
+  "name": "problem_breakdown",
+  "arguments": {
+    "problem": "Implement new customer onboarding system",
+    "levels": 3
+  }
+}
+```
+
+#### 3. Problem Analysis
+```javascript
+{
+  "name": "analyze_problem",
+  "arguments": {
+    "problem": "High customer churn rate",
+    "approach": "root-cause"
+  }
+}
+```
+
+#### 4. Step-by-Step Planning
+```javascript
+{
+  "name": "step_by_step_plan",
+  "arguments": {
+    "task": "Launch new product feature",
+    "details": true
+  }
+}
+```
+
+## Analysis Frameworks
+
+### SWOT Analysis
+- **Strengths**: Internal positive factors
+- **Weaknesses**: Internal negative factors
+- **Opportunities**: External positive factors
+- **Threats**: External negative factors
+
+### Root Cause Analysis
+- **5 Whys**: Drill down to root causes
+- **Fishbone Diagram**: Categorize contributing factors
+
+### Decision Tree Analysis
+- **Probabilistic outcomes**: Assign probabilities to different scenarios
+- **Expected value calculation**: Make data-driven decisions
+
+## Example Output
+
+The tools provide structured, actionable analysis in markdown format, including:
+
+- 📋 Clear problem definitions
+- 🎯 Specific action items
+- 📊 Structured frameworks
+- ✅ Checkboxes for tracking progress
+- 💡 Recommendations for next steps
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- MCP-compatible client (Claude Desktop, etc.)
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/taybr99/sequential-thinking-mcp
+cd sequential-thinking-mcp
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run in development mode
+npm run dev
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Keywords
+
+- MCP (Model Context Protocol)
+- Sequential Thinking
+- Problem Solving
+- Analysis Framework
+- Decision Making
+- Planning
+- SWOT Analysis
+- Root Cause Analysis
+- Project Management
+- AI Tools

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+const isValidSequentialThinkingArgs = (args) => typeof args === 'object' &&
+    args !== null &&
+    typeof args.problem === 'string' &&
+    (args.context === undefined || typeof args.context === 'string') &&
+    (args.constraints === undefined || Array.isArray(args.constraints)) &&
+    (args.goals === undefined || Array.isArray(args.goals));
+const isValidBreakdownArgs = (args) => typeof args === 'object' &&
+    args !== null &&
+    typeof args.problem === 'string' &&
+    (args.levels === undefined || typeof args.levels === 'number');
+const isValidAnalyzeArgs = (args) => typeof args === 'object' &&
+    args !== null &&
+    typeof args.problem === 'string' &&
+    (args.approach === undefined || ['swot', 'pros-cons', 'root-cause', 'decision-tree'].includes(args.approach));
+const isValidStepByStepArgs = (args) => typeof args === 'object' &&
+    args !== null &&
+    typeof args.task === 'string' &&
+    (args.details === undefined || typeof args.details === 'boolean');
+class SequentialThinkingServer {
+    constructor() {
+        this.server = new Server({
+            name: 'sequential-thinking-server',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        // Error handling
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'sequential_thinking',
+                    description: 'Apply sequential thinking methodology to solve complex problems step-by-step',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            problem: {
+                                type: 'string',
+                                description: 'The problem or challenge to analyze',
+                            },
+                            context: {
+                                type: 'string',
+                                description: 'Additional context about the problem',
+                            },
+                            constraints: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Known constraints or limitations',
+                            },
+                            goals: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Desired outcomes or goals',
+                            },
+                        },
+                        required: ['problem'],
+                    },
+                },
+                {
+                    name: 'problem_breakdown',
+                    description: 'Break down complex problems into smaller, manageable components',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            problem: {
+                                type: 'string',
+                                description: 'The complex problem to break down',
+                            },
+                            levels: {
+                                type: 'number',
+                                description: 'Number of breakdown levels (default: 3)',
+                            },
+                        },
+                        required: ['problem'],
+                    },
+                },
+                {
+                    name: 'analyze_problem',
+                    description: 'Analyze problems using structured frameworks (SWOT, pros/cons, root cause, decision tree)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            problem: {
+                                type: 'string',
+                                description: 'The problem to analyze',
+                            },
+                            approach: {
+                                type: 'string',
+                                enum: ['swot', 'pros-cons', 'root-cause', 'decision-tree'],
+                                description: 'Analysis framework to use',
+                            },
+                        },
+                        required: ['problem'],
+                    },
+                },
+                {
+                    name: 'step_by_step_plan',
+                    description: 'Create a detailed step-by-step plan for executing a task or solving a problem',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            task: {
+                                type: 'string',
+                                description: 'The task or problem to create a plan for',
+                            },
+                            details: {
+                                type: 'boolean',
+                                description: 'Include detailed sub-steps and considerations',
+                            },
+                        },
+                        required: ['task'],
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                switch (request.params.name) {
+                    case 'sequential_thinking':
+                        if (!isValidSequentialThinkingArgs(request.params.arguments)) {
+                            throw new McpError(ErrorCode.InvalidParams, 'Invalid sequential thinking arguments');
+                        }
+                        return await this.sequentialThinking(request.params.arguments);
+                    case 'problem_breakdown':
+                        if (!isValidBreakdownArgs(request.params.arguments)) {
+                            throw new McpError(ErrorCode.InvalidParams, 'Invalid problem breakdown arguments');
+                        }
+                        return await this.problemBreakdown(request.params.arguments);
+                    case 'analyze_problem':
+                        if (!isValidAnalyzeArgs(request.params.arguments)) {
+                            throw new McpError(ErrorCode.InvalidParams, 'Invalid analyze problem arguments');
+                        }
+                        return await this.analyzeProblem(request.params.arguments);
+                    case 'step_by_step_plan':
+                        if (!isValidStepByStepArgs(request.params.arguments)) {
+                            throw new McpError(ErrorCode.InvalidParams, 'Invalid step by step plan arguments');
+                        }
+                        return await this.stepByStepPlan(request.params.arguments);
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+                }
+            }
+            catch (error) {
+                console.error('Tool execution error:', error);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async sequentialThinking(args) {
+        const { problem, context, constraints, goals } = args;
+        const sections = [
+            '# Sequential Thinking Analysis',
+            '',
+            '## Problem Definition',
+            `**Problem**: ${problem}`,
+        ];
+        if (context) {
+            sections.push(`**Context**: ${context}`);
+        }
+        if (constraints && constraints.length > 0) {
+            sections.push('**Constraints**:');
+            constraints.forEach(constraint => sections.push(`- ${constraint}`));
+        }
+        if (goals && goals.length > 0) {
+            sections.push('**Goals**:');
+            goals.forEach(goal => sections.push(`- ${goal}`));
+        }
+        sections.push('', '## Step-by-Step Analysis', '', '### Step 1: Information Gathering', '- What information do we have?', '- What information do we need?', '- What assumptions are we making?', '', '### Step 2: Problem Decomposition', '- Break the problem into smaller parts', '- Identify dependencies between parts', '- Prioritize components by importance/urgency', '', '### Step 3: Solution Generation', '- Brainstorm potential approaches', '- Consider multiple perspectives', '- Evaluate feasibility of each approach', '', '### Step 4: Solution Evaluation', '- Compare solutions against goals', '- Assess risks and benefits', '- Consider resource requirements', '', '### Step 5: Implementation Planning', '- Define clear next steps', '- Identify required resources', '- Set milestones and checkpoints', '', '### Step 6: Monitoring and Adjustment', '- Define success metrics', '- Plan for regular reviews', '- Prepare contingency plans', '', '## Recommended Next Actions', '1. **Immediate**: Gather additional information if needed', '2. **Short-term**: Break down the problem further using problem_breakdown tool', '3. **Medium-term**: Analyze specific aspects using analyze_problem tool', '4. **Long-term**: Create detailed implementation plan using step_by_step_plan tool');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: sections.join('\n'),
+                },
+            ],
+        };
+    }
+    async problemBreakdown(args) {
+        const { problem, levels = 3 } = args;
+        const sections = [
+            '# Problem Breakdown Analysis',
+            '',
+            `**Main Problem**: ${problem}`,
+            ''
+        ];
+        for (let level = 1; level <= levels; level++) {
+            sections.push(`## Level ${level} Breakdown`);
+            switch (level) {
+                case 1:
+                    sections.push('### Primary Components', '- **Technical aspects**: What technical challenges need to be addressed?', '- **Human factors**: What people-related issues are involved?', '- **Process elements**: What processes need to be considered?', '- **Resource requirements**: What resources are needed?', '- **External dependencies**: What external factors affect this problem?', '');
+                    break;
+                case 2:
+                    sections.push('### Secondary Components', '**Technical Aspects**:', '- System requirements and constraints', '- Integration challenges', '- Performance considerations', '', '**Human Factors**:', '- Stakeholder needs and expectations', '- Skills and training requirements', '- Communication needs', '', '**Process Elements**:', '- Workflow design', '- Quality assurance', '- Risk management', '', '**Resource Requirements**:', '- Budget and financial considerations', '- Time constraints', '- Equipment and tools', '', '**External Dependencies**:', '- Third-party services', '- Regulatory requirements', '- Market conditions', '');
+                    break;
+                case 3:
+                    sections.push('### Detailed Components', '**Immediate Actions Required**:', '- Research and analysis tasks', '- Stakeholder consultations', '- Resource allocation decisions', '', '**Short-term Objectives**:', '- Proof of concept development', '- Team formation and training', '- Initial implementation steps', '', '**Long-term Goals**:', '- Full solution deployment', '- Performance optimization', '- Maintenance and support', '');
+                    break;
+            }
+        }
+        sections.push('## Summary', 'Use this breakdown to:', '- Focus on one component at a time', '- Identify critical path dependencies', '- Assign responsibilities to team members', '- Create detailed project timelines', '- Monitor progress systematically');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: sections.join('\n'),
+                },
+            ],
+        };
+    }
+    async analyzeProblem(args) {
+        const { problem, approach = 'swot' } = args;
+        const sections = [
+            '# Problem Analysis',
+            '',
+            `**Problem**: ${problem}`,
+            `**Analysis Method**: ${approach.toUpperCase()}`,
+            ''
+        ];
+        switch (approach) {
+            case 'swot':
+                sections.push('## SWOT Analysis', '', '### Strengths', '- What advantages do we have?', '- What do we do well?', '- What resources do we have access to?', '- What others see as our strengths?', '', '### Weaknesses', '- What could we improve?', '- What do we do poorly?', '- What should we avoid?', '- What factors lose us opportunities?', '', '### Opportunities', '- What opportunities are available?', '- What trends could we take advantage of?', '- How can we turn strengths into opportunities?', '- What changes in environment could benefit us?', '', '### Threats', '- What threats could harm us?', '- What is our competition doing?', '- What obstacles do we face?', '- What changes in environment could threaten us?');
+                break;
+            case 'pros-cons':
+                sections.push('## Pros and Cons Analysis', '', '### Pros (Advantages)', '- **Benefit 1**: [Describe specific advantage]', '- **Benefit 2**: [Describe specific advantage]', '- **Benefit 3**: [Describe specific advantage]', '', '### Cons (Disadvantages)', '- **Risk 1**: [Describe specific disadvantage]', '- **Risk 2**: [Describe specific disadvantage]', '- **Risk 3**: [Describe specific disadvantage]', '', '### Neutral Factors', '- **Factor 1**: [Neither advantage nor disadvantage]', '- **Factor 2**: [Depends on implementation]', '', '### Decision Matrix', '- Weight each pro and con by importance (1-10)', '- Calculate total weighted score', '- Compare with alternatives');
+                break;
+            case 'root-cause':
+                sections.push('## Root Cause Analysis', '', '### Problem Symptoms', '- What are the visible effects?', '- When do these symptoms occur?', '- Who is affected by these symptoms?', '', '### 5 Whys Analysis', '1. **Why** does this problem occur?', '   - [First level cause]', '2. **Why** does that cause occur?', '   - [Second level cause]', '3. **Why** does that cause occur?', '   - [Third level cause]', '4. **Why** does that cause occur?', '   - [Fourth level cause]', '5. **Why** does that cause occur?', '   - [Root cause]', '', '### Fishbone Diagram Categories', '**People**: Human factors contributing to the problem', '**Process**: Procedural issues', '**Technology**: Technical or equipment issues', '**Environment**: External factors', '**Materials**: Resource-related issues', '**Measurement**: Data or metric issues');
+                break;
+            case 'decision-tree':
+                sections.push('## Decision Tree Analysis', '', '### Decision Points', '```', 'Problem: [Main Problem]', '├── Option A: [First major choice]', '│   ├── Outcome A1: [Possible result]', '│   │   ├── Probability: [%]', '│   │   └── Impact: [High/Medium/Low]', '│   └── Outcome A2: [Possible result]', '│       ├── Probability: [%]', '│       └── Impact: [High/Medium/Low]', '├── Option B: [Second major choice]', '│   ├── Outcome B1: [Possible result]', '│   │   ├── Probability: [%]', '│   │   └── Impact: [High/Medium/Low]', '│   └── Outcome B2: [Possible result]', '│       ├── Probability: [%]', '│       └── Impact: [High/Medium/Low]', '└── Option C: [Third major choice]', '    └── [Continue pattern...]', '```', '', '### Expected Value Calculation', '- **Option A**: (Probability A1 × Impact A1) + (Probability A2 × Impact A2)', '- **Option B**: (Probability B1 × Impact B1) + (Probability B2 × Impact B2)', '- **Option C**: [Continue calculation...]', '', '### Recommended Decision', '- Compare expected values', '- Consider risk tolerance', '- Account for qualitative factors');
+                break;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: sections.join('\n'),
+                },
+            ],
+        };
+    }
+    async stepByStepPlan(args) {
+        const { task, details = false } = args;
+        const sections = [
+            '# Step-by-Step Implementation Plan',
+            '',
+            `**Task**: ${task}`,
+            ''
+        ];
+        if (details) {
+            sections.push('## Phase 1: Planning and Preparation', '### Step 1: Define Objectives', '- [ ] Clarify the end goal', '- [ ] Identify success criteria', '- [ ] Set measurable milestones', '- [ ] Determine timeline', '', '### Step 2: Gather Resources', '- [ ] Identify required skills', '- [ ] Allocate team members', '- [ ] Secure necessary tools', '- [ ] Confirm budget availability', '', '### Step 3: Risk Assessment', '- [ ] Identify potential obstacles', '- [ ] Develop mitigation strategies', '- [ ] Create contingency plans', '- [ ] Establish communication protocols', '', '## Phase 2: Execution', '### Step 4: Initial Implementation', '- [ ] Begin with pilot or prototype', '- [ ] Test core functionality', '- [ ] Gather initial feedback', '- [ ] Make necessary adjustments', '', '### Step 5: Full Deployment', '- [ ] Roll out complete solution', '- [ ] Monitor performance metrics', '- [ ] Address issues promptly', '- [ ] Document lessons learned', '', '### Step 6: Optimization', '- [ ] Analyze performance data', '- [ ] Identify improvement opportunities', '- [ ] Implement optimizations', '- [ ] Validate improvements', '', '## Phase 3: Maintenance and Review', '### Step 7: Ongoing Maintenance', '- [ ] Establish maintenance schedule', '- [ ] Train support team', '- [ ] Create documentation', '- [ ] Set up monitoring systems', '', '### Step 8: Performance Review', '- [ ] Measure against objectives', '- [ ] Gather stakeholder feedback', '- [ ] Identify areas for improvement', '- [ ] Plan future enhancements');
+        }
+        else {
+            sections.push('## High-Level Steps', '1. **Plan**: Define objectives and gather resources', '2. **Prepare**: Set up environment and tools', '3. **Execute**: Implement the solution step by step', '4. **Test**: Validate functionality and performance', '5. **Deploy**: Roll out to production or final environment', '6. **Monitor**: Track performance and gather feedback', '7. **Optimize**: Make improvements based on data', '8. **Maintain**: Provide ongoing support and updates', '', '## Next Steps', '- Break down each high-level step into specific tasks', '- Assign owners and deadlines to each task', '- Create a project timeline with dependencies', '- Set up regular check-ins and progress reviews');
+        }
+        sections.push('', '## Success Metrics', '- **Quality**: Define what "done" looks like', '- **Timeline**: Track progress against milestones', '- **Budget**: Monitor resource utilization', '- **Stakeholder Satisfaction**: Gather feedback regularly', '', '## Tips for Success', '- Start small and iterate', '- Communicate progress regularly', '- Be prepared to adapt the plan', '- Document decisions and lessons learned', '- Celebrate milestones and achievements');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: sections.join('\n'),
+                },
+            ],
+        };
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Sequential Thinking MCP server running on stdio');
+    }
+}
+const server = new SequentialThinkingServer();
+server.run().catch(console.error);
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "sequential-thinking-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for sequential thinking and problem solving",
+  "main": "build/index.js",
+  "type": "module",
+  "bin": {
+    "sequential-thinking-mcp": "build/index.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.15.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "sequential-thinking",
+    "problem-solving",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "reasoning"
+  ],
+  "author": "taybr99",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/taybr99/sequential-thinking-mcp"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+
+interface SequentialThinkingArgs {
+  problem: string;
+  context?: string;
+  constraints?: string[];
+  goals?: string[];
+}
+
+interface BreakdownArgs {
+  problem: string;
+  levels?: number;
+}
+
+interface AnalyzeArgs {
+  problem: string;
+  approach?: 'swot' | 'pros-cons' | 'root-cause' | 'decision-tree';
+}
+
+interface StepByStepArgs {
+  task: string;
+  details?: boolean;
+}
+
+const isValidSequentialThinkingArgs = (args: any): args is SequentialThinkingArgs =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.problem === 'string' &&
+  (args.context === undefined || typeof args.context === 'string') &&
+  (args.constraints === undefined || Array.isArray(args.constraints)) &&
+  (args.goals === undefined || Array.isArray(args.goals));
+
+const isValidBreakdownArgs = (args: any): args is BreakdownArgs =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.problem === 'string' &&
+  (args.levels === undefined || typeof args.levels === 'number');
+
+const isValidAnalyzeArgs = (args: any): args is AnalyzeArgs =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.problem === 'string' &&
+  (args.approach === undefined || ['swot', 'pros-cons', 'root-cause', 'decision-tree'].includes(args.approach));
+
+const isValidStepByStepArgs = (args: any): args is StepByStepArgs =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.task === 'string' &&
+  (args.details === undefined || typeof args.details === 'boolean');
+
+class SequentialThinkingServer {
+  private server: Server;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'sequential-thinking-server',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupToolHandlers();
+    
+    // Error handling
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'sequential_thinking',
+          description: 'Apply sequential thinking methodology to solve complex problems step-by-step',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              problem: {
+                type: 'string',
+                description: 'The problem or challenge to analyze',
+              },
+              context: {
+                type: 'string',
+                description: 'Additional context about the problem',
+              },
+              constraints: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Known constraints or limitations',
+              },
+              goals: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Desired outcomes or goals',
+              },
+            },
+            required: ['problem'],
+          },
+        },
+        {
+          name: 'problem_breakdown',
+          description: 'Break down complex problems into smaller, manageable components',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              problem: {
+                type: 'string',
+                description: 'The complex problem to break down',
+              },
+              levels: {
+                type: 'number',
+                description: 'Number of breakdown levels (default: 3)',
+              },
+            },
+            required: ['problem'],
+          },
+        },
+        {
+          name: 'analyze_problem',
+          description: 'Analyze problems using structured frameworks (SWOT, pros/cons, root cause, decision tree)',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              problem: {
+                type: 'string',
+                description: 'The problem to analyze',
+              },
+              approach: {
+                type: 'string',
+                enum: ['swot', 'pros-cons', 'root-cause', 'decision-tree'],
+                description: 'Analysis framework to use',
+              },
+            },
+            required: ['problem'],
+          },
+        },
+        {
+          name: 'step_by_step_plan',
+          description: 'Create a detailed step-by-step plan for executing a task or solving a problem',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              task: {
+                type: 'string',
+                description: 'The task or problem to create a plan for',
+              },
+              details: {
+                type: 'boolean',
+                description: 'Include detailed sub-steps and considerations',
+              },
+            },
+            required: ['task'],
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        switch (request.params.name) {
+          case 'sequential_thinking':
+            if (!isValidSequentialThinkingArgs(request.params.arguments)) {
+              throw new McpError(
+                ErrorCode.InvalidParams,
+                'Invalid sequential thinking arguments'
+              );
+            }
+            return await this.sequentialThinking(request.params.arguments);
+
+          case 'problem_breakdown':
+            if (!isValidBreakdownArgs(request.params.arguments)) {
+              throw new McpError(
+                ErrorCode.InvalidParams,
+                'Invalid problem breakdown arguments'
+              );
+            }
+            return await this.problemBreakdown(request.params.arguments);
+
+          case 'analyze_problem':
+            if (!isValidAnalyzeArgs(request.params.arguments)) {
+              throw new McpError(
+                ErrorCode.InvalidParams,
+                'Invalid analyze problem arguments'
+              );
+            }
+            return await this.analyzeProblem(request.params.arguments);
+
+          case 'step_by_step_plan':
+            if (!isValidStepByStepArgs(request.params.arguments)) {
+              throw new McpError(
+                ErrorCode.InvalidParams,
+                'Invalid step by step plan arguments'
+              );
+            }
+            return await this.stepByStepPlan(request.params.arguments);
+
+          default:
+            throw new McpError(
+              ErrorCode.MethodNotFound,
+              `Unknown tool: ${request.params.name}`
+            );
+        }
+      } catch (error) {
+        console.error('Tool execution error:', error);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  private async sequentialThinking(args: SequentialThinkingArgs) {
+    const { problem, context, constraints, goals } = args;
+    
+    const sections = [
+      '# Sequential Thinking Analysis',
+      '',
+      '## Problem Definition',
+      `**Problem**: ${problem}`,
+    ];
+
+    if (context) {
+      sections.push(`**Context**: ${context}`);
+    }
+
+    if (constraints && constraints.length > 0) {
+      sections.push('**Constraints**:');
+      constraints.forEach(constraint => sections.push(`- ${constraint}`));
+    }
+
+    if (goals && goals.length > 0) {
+      sections.push('**Goals**:');
+      goals.forEach(goal => sections.push(`- ${goal}`));
+    }
+
+    sections.push(
+      '',
+      '## Step-by-Step Analysis',
+      '',
+      '### Step 1: Information Gathering',
+      '- What information do we have?',
+      '- What information do we need?',
+      '- What assumptions are we making?',
+      '',
+      '### Step 2: Problem Decomposition',
+      '- Break the problem into smaller parts',
+      '- Identify dependencies between parts',
+      '- Prioritize components by importance/urgency',
+      '',
+      '### Step 3: Solution Generation',
+      '- Brainstorm potential approaches',
+      '- Consider multiple perspectives',
+      '- Evaluate feasibility of each approach',
+      '',
+      '### Step 4: Solution Evaluation',
+      '- Compare solutions against goals',
+      '- Assess risks and benefits',
+      '- Consider resource requirements',
+      '',
+      '### Step 5: Implementation Planning',
+      '- Define clear next steps',
+      '- Identify required resources',
+      '- Set milestones and checkpoints',
+      '',
+      '### Step 6: Monitoring and Adjustment',
+      '- Define success metrics',
+      '- Plan for regular reviews',
+      '- Prepare contingency plans',
+      '',
+      '## Recommended Next Actions',
+      '1. **Immediate**: Gather additional information if needed',
+      '2. **Short-term**: Break down the problem further using problem_breakdown tool',
+      '3. **Medium-term**: Analyze specific aspects using analyze_problem tool',
+      '4. **Long-term**: Create detailed implementation plan using step_by_step_plan tool'
+    );
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: sections.join('\n'),
+        },
+      ],
+    };
+  }
+
+  private async problemBreakdown(args: BreakdownArgs) {
+    const { problem, levels = 3 } = args;
+    
+    const sections = [
+      '# Problem Breakdown Analysis',
+      '',
+      `**Main Problem**: ${problem}`,
+      ''
+    ];
+
+    for (let level = 1; level <= levels; level++) {
+      sections.push(`## Level ${level} Breakdown`);
+      
+      switch (level) {
+        case 1:
+          sections.push(
+            '### Primary Components',
+            '- **Technical aspects**: What technical challenges need to be addressed?',
+            '- **Human factors**: What people-related issues are involved?',
+            '- **Process elements**: What processes need to be considered?',
+            '- **Resource requirements**: What resources are needed?',
+            '- **External dependencies**: What external factors affect this problem?',
+            ''
+          );
+          break;
+        case 2:
+          sections.push(
+            '### Secondary Components',
+            '**Technical Aspects**:',
+            '- System requirements and constraints',
+            '- Integration challenges',
+            '- Performance considerations',
+            '',
+            '**Human Factors**:',
+            '- Stakeholder needs and expectations',
+            '- Skills and training requirements',
+            '- Communication needs',
+            '',
+            '**Process Elements**:',
+            '- Workflow design',
+            '- Quality assurance',
+            '- Risk management',
+            '',
+            '**Resource Requirements**:',
+            '- Budget and financial considerations',
+            '- Time constraints',
+            '- Equipment and tools',
+            '',
+            '**External Dependencies**:',
+            '- Third-party services',
+            '- Regulatory requirements',
+            '- Market conditions',
+            ''
+          );
+          break;
+        case 3:
+          sections.push(
+            '### Detailed Components',
+            '**Immediate Actions Required**:',
+            '- Research and analysis tasks',
+            '- Stakeholder consultations',
+            '- Resource allocation decisions',
+            '',
+            '**Short-term Objectives**:',
+            '- Proof of concept development',
+            '- Team formation and training',
+            '- Initial implementation steps',
+            '',
+            '**Long-term Goals**:',
+            '- Full solution deployment',
+            '- Performance optimization',
+            '- Maintenance and support',
+            ''
+          );
+          break;
+      }
+    }
+
+    sections.push(
+      '## Summary',
+      'Use this breakdown to:',
+      '- Focus on one component at a time',
+      '- Identify critical path dependencies',
+      '- Assign responsibilities to team members',
+      '- Create detailed project timelines',
+      '- Monitor progress systematically'
+    );
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: sections.join('\n'),
+        },
+      ],
+    };
+  }
+
+  private async analyzeProblem(args: AnalyzeArgs) {
+    const { problem, approach = 'swot' } = args;
+    
+    const sections = [
+      '# Problem Analysis',
+      '',
+      `**Problem**: ${problem}`,
+      `**Analysis Method**: ${approach.toUpperCase()}`,
+      ''
+    ];
+
+    switch (approach) {
+      case 'swot':
+        sections.push(
+          '## SWOT Analysis',
+          '',
+          '### Strengths',
+          '- What advantages do we have?',
+          '- What do we do well?',
+          '- What resources do we have access to?',
+          '- What others see as our strengths?',
+          '',
+          '### Weaknesses',
+          '- What could we improve?',
+          '- What do we do poorly?',
+          '- What should we avoid?',
+          '- What factors lose us opportunities?',
+          '',
+          '### Opportunities',
+          '- What opportunities are available?',
+          '- What trends could we take advantage of?',
+          '- How can we turn strengths into opportunities?',
+          '- What changes in environment could benefit us?',
+          '',
+          '### Threats',
+          '- What threats could harm us?',
+          '- What is our competition doing?',
+          '- What obstacles do we face?',
+          '- What changes in environment could threaten us?'
+        );
+        break;
+
+      case 'pros-cons':
+        sections.push(
+          '## Pros and Cons Analysis',
+          '',
+          '### Pros (Advantages)',
+          '- **Benefit 1**: [Describe specific advantage]',
+          '- **Benefit 2**: [Describe specific advantage]',
+          '- **Benefit 3**: [Describe specific advantage]',
+          '',
+          '### Cons (Disadvantages)',
+          '- **Risk 1**: [Describe specific disadvantage]',
+          '- **Risk 2**: [Describe specific disadvantage]',
+          '- **Risk 3**: [Describe specific disadvantage]',
+          '',
+          '### Neutral Factors',
+          '- **Factor 1**: [Neither advantage nor disadvantage]',
+          '- **Factor 2**: [Depends on implementation]',
+          '',
+          '### Decision Matrix',
+          '- Weight each pro and con by importance (1-10)',
+          '- Calculate total weighted score',
+          '- Compare with alternatives'
+        );
+        break;
+
+      case 'root-cause':
+        sections.push(
+          '## Root Cause Analysis',
+          '',
+          '### Problem Symptoms',
+          '- What are the visible effects?',
+          '- When do these symptoms occur?',
+          '- Who is affected by these symptoms?',
+          '',
+          '### 5 Whys Analysis',
+          '1. **Why** does this problem occur?',
+          '   - [First level cause]',
+          '2. **Why** does that cause occur?',
+          '   - [Second level cause]',
+          '3. **Why** does that cause occur?',
+          '   - [Third level cause]',
+          '4. **Why** does that cause occur?',
+          '   - [Fourth level cause]',
+          '5. **Why** does that cause occur?',
+          '   - [Root cause]',
+          '',
+          '### Fishbone Diagram Categories',
+          '**People**: Human factors contributing to the problem',
+          '**Process**: Procedural issues',
+          '**Technology**: Technical or equipment issues',
+          '**Environment**: External factors',
+          '**Materials**: Resource-related issues',
+          '**Measurement**: Data or metric issues'
+        );
+        break;
+
+      case 'decision-tree':
+        sections.push(
+          '## Decision Tree Analysis',
+          '',
+          '### Decision Points',
+          '```',
+          'Problem: [Main Problem]',
+          '├── Option A: [First major choice]',
+          '│   ├── Outcome A1: [Possible result]',
+          '│   │   ├── Probability: [%]',
+          '│   │   └── Impact: [High/Medium/Low]',
+          '│   └── Outcome A2: [Possible result]',
+          '│       ├── Probability: [%]',
+          '│       └── Impact: [High/Medium/Low]',
+          '├── Option B: [Second major choice]',
+          '│   ├── Outcome B1: [Possible result]',
+          '│   │   ├── Probability: [%]',
+          '│   │   └── Impact: [High/Medium/Low]',
+          '│   └── Outcome B2: [Possible result]',
+          '│       ├── Probability: [%]',
+          '│       └── Impact: [High/Medium/Low]',
+          '└── Option C: [Third major choice]',
+          '    └── [Continue pattern...]',
+          '```',
+          '',
+          '### Expected Value Calculation',
+          '- **Option A**: (Probability A1 × Impact A1) + (Probability A2 × Impact A2)',
+          '- **Option B**: (Probability B1 × Impact B1) + (Probability B2 × Impact B2)',
+          '- **Option C**: [Continue calculation...]',
+          '',
+          '### Recommended Decision',
+          '- Compare expected values',
+          '- Consider risk tolerance',
+          '- Account for qualitative factors'
+        );
+        break;
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: sections.join('\n'),
+        },
+      ],
+    };
+  }
+
+  private async stepByStepPlan(args: StepByStepArgs) {
+    const { task, details = false } = args;
+    
+    const sections = [
+      '# Step-by-Step Implementation Plan',
+      '',
+      `**Task**: ${task}`,
+      ''
+    ];
+
+    if (details) {
+      sections.push(
+        '## Phase 1: Planning and Preparation',
+        '### Step 1: Define Objectives',
+        '- [ ] Clarify the end goal',
+        '- [ ] Identify success criteria',
+        '- [ ] Set measurable milestones',
+        '- [ ] Determine timeline',
+        '',
+        '### Step 2: Gather Resources',
+        '- [ ] Identify required skills',
+        '- [ ] Allocate team members',
+        '- [ ] Secure necessary tools',
+        '- [ ] Confirm budget availability',
+        '',
+        '### Step 3: Risk Assessment',
+        '- [ ] Identify potential obstacles',
+        '- [ ] Develop mitigation strategies',
+        '- [ ] Create contingency plans',
+        '- [ ] Establish communication protocols',
+        '',
+        '## Phase 2: Execution',
+        '### Step 4: Initial Implementation',
+        '- [ ] Begin with pilot or prototype',
+        '- [ ] Test core functionality',
+        '- [ ] Gather initial feedback',
+        '- [ ] Make necessary adjustments',
+        '',
+        '### Step 5: Full Deployment',
+        '- [ ] Roll out complete solution',
+        '- [ ] Monitor performance metrics',
+        '- [ ] Address issues promptly',
+        '- [ ] Document lessons learned',
+        '',
+        '### Step 6: Optimization',
+        '- [ ] Analyze performance data',
+        '- [ ] Identify improvement opportunities',
+        '- [ ] Implement optimizations',
+        '- [ ] Validate improvements',
+        '',
+        '## Phase 3: Maintenance and Review',
+        '### Step 7: Ongoing Maintenance',
+        '- [ ] Establish maintenance schedule',
+        '- [ ] Train support team',
+        '- [ ] Create documentation',
+        '- [ ] Set up monitoring systems',
+        '',
+        '### Step 8: Performance Review',
+        '- [ ] Measure against objectives',
+        '- [ ] Gather stakeholder feedback',
+        '- [ ] Identify areas for improvement',
+        '- [ ] Plan future enhancements'
+      );
+    } else {
+      sections.push(
+        '## High-Level Steps',
+        '1. **Plan**: Define objectives and gather resources',
+        '2. **Prepare**: Set up environment and tools',
+        '3. **Execute**: Implement the solution step by step',
+        '4. **Test**: Validate functionality and performance',
+        '5. **Deploy**: Roll out to production or final environment',
+        '6. **Monitor**: Track performance and gather feedback',
+        '7. **Optimize**: Make improvements based on data',
+        '8. **Maintain**: Provide ongoing support and updates',
+        '',
+        '## Next Steps',
+        '- Break down each high-level step into specific tasks',
+        '- Assign owners and deadlines to each task',
+        '- Create a project timeline with dependencies',
+        '- Set up regular check-ins and progress reviews'
+      );
+    }
+
+    sections.push(
+      '',
+      '## Success Metrics',
+      '- **Quality**: Define what "done" looks like',
+      '- **Timeline**: Track progress against milestones',
+      '- **Budget**: Monitor resource utilization',
+      '- **Stakeholder Satisfaction**: Gather feedback regularly',
+      '',
+      '## Tips for Success',
+      '- Start small and iterate',
+      '- Communicate progress regularly',
+      '- Be prepared to adapt the plan',
+      '- Document decisions and lessons learned',
+      '- Celebrate milestones and achievements'
+    );
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: sections.join('\n'),
+        },
+      ],
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('Sequential Thinking MCP server running on stdio');
+  }
+}
+
+const server = new SequentialThinkingServer();
+server.run().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./build",
+    "rootDir": "./src",
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "build"
+  ]
+}