Sequential thinking integration

Sequential-Thinking Integration Guide

This document provides comprehensive guidance on integrating and using the sequential-thinking MCP server within the Remind Tools development workflow.

Overview

The sequential-thinking integration enhances Claude Code with intelligent problem analysis capabilities, automatically triggering structured thinking for complex development tasks. This system helps teams make better decisions through systematic analysis and reasoning.

Architecture

Components

File Structure

.claude/
├── thinking-config.json          # Complexity rules and patterns
├── settings.json                 # Hooks configuration
├── commands/
│   ├── create-prd-smart.md      # Enhanced PRD creation
│   ├── implement-task-smart.md  # Smart implementation
│   ├── debug-issue-smart.md     # Systematic debugging
│   └── architect-solution-smart.md # Architectural analysis
└── scripts/
    ├── thinking-wrapper.sh      # Automation script
    └── thinking-patterns.js     # Pattern library

Configuration

MCP Server Setup

The sequential-thinking MCP server is configured in .mcp.json:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking@latest"]
    }
  }
}

Thinking Configuration

The .claude/thinking-config.json file defines:

• Complexity Rules: Automatic triggers for thinking analysis
• Role-Based Patterns: Different thinking styles for different roles
• Task Patterns: Specific patterns for common task types
• Integration Settings: Memory system integration and performance settings

Complexity Triggers

Tasks automatically trigger sequential-thinking when they involve:

• File Count: >3 files affected
• Cross-Package Operations: Changes affecting multiple packages
• External API Integrations: Supabase, MapBox, Gemini integrations
• Performance Issues: System performance optimization
• Architecture Changes: Major architectural decisions
• Refactoring Operations: Complex code restructuring

Role-Based Thinking Patterns

Role	Thinking Style	Focus Areas
Product Owner	Business Analysis	User needs, market fit, business metrics
Tech Lead	Architectural Analysis	System design, scalability, team coordination
Senior Developer	Technical Implementation	Code quality, testing, performance
Claude Expert	Optimization Analysis	Automation, tooling, developer experience

Hooks Configuration

The .claude/settings.json includes hooks that:

• Detect when sequential-thinking is initiated
• Provide context for thinking sessions
• Integrate thinking traces with memory systems
• Log thinking session outcomes

Usage

Automatic Triggers

The system automatically suggests sequential-thinking for complex tasks:

🧠 INTELLIGENT ANALYSIS DETECTED
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Task complexity threshold met. Initiating sequential-thinking analysis...
Thinking Style: technical_implementation
Role Context: Senior Developer

Recommended thinking prompt:
"Plan the technical implementation approach for: Implement real-time chat with Supabase. Consider architecture fit, design patterns, testing strategy, and performance implications. Context: Remind Tools Flutter monorepo project"

Use: mcp__sequential-thinking__sequentialthinking tool with the above prompt
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Smart Commands

Enhanced commands with integrated thinking analysis:

/create-prd-smart

• Automatically triggers business analysis thinking
• Focuses on market opportunity and user impact
• Integrates with core memory for user research

/implement-task-smart

• Initiates technical implementation thinking
• Considers architectural fit and design patterns
• Integrates with architecture memory for patterns

/debug-issue-smart

• Triggers systematic debugging thinking
• Structured root cause analysis approach
• Saves debugging patterns to architecture memory

/architect-solution-smart

• Activates architectural analysis thinking
• Deep system design and trade-off analysis
• Comprehensive integration planning

Manual Usage

For complex tasks that don’t auto-trigger, manually invoke sequential-thinking:

// Use thinking-patterns.js to generate appropriate prompts
node .claude/scripts/thinking-patterns.js "Design user authentication flow" "Tech Lead"

// Or use thinking-wrapper.sh for complexity analysis
bash .claude/scripts/thinking-wrapper.sh check "Implement MapBox 3D rendering optimization"

Thinking Styles

Business Analysis

Structure: problem_definition -> user_analysis -> solution_design -> impact_assessment

Best for:

• Product requirements definition
• Market opportunity assessment
• User experience planning
• Business case development

Technical Implementation

Structure: requirements_analysis -> architecture_fit -> implementation_planning -> testing_strategy

Best for:

• Feature development planning
• Integration design
• Testing strategy development
• Performance optimization

Systematic Debugging

Structure: problem_identification -> root_cause_analysis -> reproduction_steps -> solution_implementation

Best for:

• Complex bug investigation
• System performance issues
• Integration problems
• Multi-platform debugging

Architectural Analysis

Structure: requirements_gathering -> solution_exploration -> trade_off_analysis -> integration_planning

Best for:

• System architecture design
• Technology selection
• Scalability planning
• Migration strategy

Optimization Analysis

Structure: performance_profiling -> optimization_identification -> risk_assessment -> success_metrics

Best for:

• Performance improvements
• Workflow optimization
• Resource utilization
• Process improvements

Memory Integration

Sequential-thinking integrates with the memory systems:

Architecture Memory (mcp__memory-arch)

• Architectural decisions and patterns
• System design trade-offs
• Technical solution approaches
• Performance optimization strategies

Team Memory (mcp__memory-team)

• Role-specific thinking patterns
• Workflow optimization insights
• Collaboration patterns
• Process improvements

Core Memory (mcp__memory)

• Product decisions and requirements
• User research insights
• Business analysis outcomes
• Feature planning decisions

Automation Scripts

thinking-wrapper.sh

Provides command-line interface for:

# Check if task requires thinking
./thinking-wrapper.sh check "Implement authentication system"

# Generate thinking prompt
./thinking-wrapper.sh prompt "Debug performance issue"

# View recent thinking sessions
./thinking-wrapper.sh log

# Show configuration
./thinking-wrapper.sh config

thinking-patterns.js

JavaScript library providing:

• Structured thinking patterns for different scenarios
• Role-based pattern selection
• Prompt generation with project context
• Memory integration recommendations

Performance Optimization

Caching

• Thinking patterns are cached for reuse
• Recent thinking sessions are stored locally
• Memory integration results are cached

Timeouts

• Maximum thinking time: 10 minutes (600 seconds)
• Thinking sessions auto-save progress
• Graceful fallback for timeout scenarios

Resource Management

• Thinking traces are automatically cleaned after 30 days
• Large thinking sessions are compressed
• Memory usage is monitored and optimized

Monitoring and Analytics

Session Tracking

• All thinking sessions are logged with timestamps
• Complexity scores and triggers are recorded
• Thinking effectiveness metrics are collected

Usage Analytics

• Most common thinking patterns
• Role-specific usage patterns
• Complexity threshold effectiveness
• Memory integration success rates

Performance Metrics

• Thinking session duration and outcomes
• Memory system query performance
• Hook execution performance
• User satisfaction with thinking quality

Best Practices

When to Use Sequential-Thinking

Always use for:

• Features affecting >3 files or packages
• External API integrations (Supabase, MapBox, Gemini)
• Performance optimization tasks
• Complex debugging scenarios
• Architectural refactoring decisions
• Cross-platform compatibility issues

Consider using for:

• New feature planning (>5 story points)
• User experience design decisions
• Security implementation planning
• Data modeling and migration planning
• CI/CD pipeline optimization

Thinking Session Guidelines

1. Start with clear context: Provide specific task description and constraints
2. Use appropriate thinking style: Match pattern to task and role
3. Save insights: Document key decisions and rationale
4. Share with team: Make thinking traces available for collaboration
5. Build on previous thinking: Reference past sessions for consistency

Memory Integration Best Practices

1. Categorize appropriately: Use correct memory system for content type
2. Save key insights: Extract actionable patterns and decisions
3. Link related content: Connect thinking sessions to relevant entities
4. Update regularly: Keep memory systems current with new insights
5. Review periodically: Clean up outdated or irrelevant information

Troubleshooting

Common Issues

Sequential-Thinking Not Triggering

• Check complexity rules: Verify task meets threshold criteria
• Review thinking-config.json: Ensure patterns are correctly defined
• Check MCP server: Verify sequential-thinking server is running
• Test manually: Use thinking-wrapper.sh to debug

Thinking Sessions Timeout

• Reduce scope: Break complex problems into smaller parts
• Use structured prompts: Follow thinking pattern guidelines
• Check server resources: Ensure adequate memory and processing power
• Enable caching: Use cached patterns for common scenarios

Memory Integration Issues

• Verify permissions: Check memory server access rights
• Test connections: Ensure all memory servers are responding
• Check entity limits: Verify memory capacity constraints
• Review integration logs: Check for connection or data issues

Debugging Tools

# Test thinking configuration
bash .claude/scripts/thinking-wrapper.sh config

# Verify MCP server connection
# (Use Claude Code's built-in MCP diagnostics)

# Check thinking session logs
tail -f .claude/logs/thinking-sessions.log

# Test pattern generation
node .claude/scripts/thinking-patterns.js "test task" --json

Migration Guide

From Manual Planning to Sequential-Thinking

1. Identify current planning workflows: Document existing approaches
2. Map to thinking patterns: Match workflows to appropriate styles
3. Update team processes: Train team on new smart commands
4. Gradual rollout: Start with complex tasks, expand gradually
5. Measure effectiveness: Track time savings and decision quality

Integration with Existing Tools

• GitHub Issues: Link thinking traces to relevant issues
• MkDocs: Reference thinking documentation in guides
• Codemagic: Include thinking outputs in build documentation
• Team Communication: Share thinking insights in standups and reviews

Future Enhancements

Planned Features

• Collaborative Thinking: Multi-user thinking sessions
• Visual Thinking Maps: Graphical representation of thinking flows
• AI-Assisted Pattern Recognition: Automatic pattern suggestion
• Advanced Analytics: Predictive thinking recommendations
• Integration Expansion: More MCP servers and tools

Research Areas

• Thinking Effectiveness Measurement: Quantifying decision quality
• Pattern Learning: AI-driven pattern discovery and optimization
• Team Thinking Dynamics: Collaborative intelligence research
• Domain-Specific Patterns: Industry and technology-specific thinking

---

For questions or support with sequential-thinking integration, reference the team training materials in intelligent-planning.md or consult the Claude Code documentation.