sequential-thinking-claude-code

sequential-thinking-claude-code

An enhanced version of the original mcp-sequentialthinking-tools by Scott Spence, which was adapted from the MCP Sequential Thinking Server.

This enhanced edition transforms the original framework into an intelligent tool recommendation system with:

• 26 pre-configured tools including all Claude Code tools
• Automatic tool recommendations based on thought content
• Deep integration with Basic Memory MCP for knowledge management
• Pattern-based intelligence that suggests the right tools at the right time

Credits: Original repository by Scott Spence. Basic Memory tools from Basic Machines Co. Enhanced with permission.

A Model Context Protocol (MCP) server that combines sequential thinking with tool usage suggestions. For each step in the problem-solving process, it provides confidence scores and rationale for tools that could be used, based on tools available in your environment.

What's New in This Enhanced Edition

🚀 Key Improvements

• Auto-recommends tools based on your thought content (no manual specification needed!)
• 26 pre-integrated tools ready to use out of the box
• Intelligent pattern matching that understands context
• Basic Memory integration for persistent knowledge management

📦 Included Tool Sets

Claude Code Tools (17 tools)

• File operations: Read, Write, Edit, MultiEdit, LS, Glob, Grep
• Execution: Bash, Agent
• Notebooks: NotebookRead, NotebookEdit
• Web: WebFetch, WebSearch
• Tasks: TodoRead, TodoWrite
• Special: StickerRequest

Basic Memory Tools (9 tools)

• mcp__basic-memory__write_note - Record knowledge
• mcp__basic-memory__read_note - Access saved information
• mcp__basic-memory__search_notes - Search your knowledge base
• mcp__basic-memory__build_context - Follow knowledge connections
• And more...

Original Features (Enhanced)

• 🤔 Dynamic and reflective problem-solving through sequential thoughts
• 🔄 Flexible thinking process that adapts and evolves
• 🌳 Support for branching and revision of thoughts
• 🛠️ NEW: Automatic tool suggestions based on thought content
• 📊 ENHANCED: Pre-configured confidence scores for each tool
• 🔍 ENHANCED: Context-aware rationale generation
• 📝 Step tracking with expected outcomes
• 🔄 Progress monitoring with previous and remaining steps
• 🎯 ENHANCED: Intelligent alternative tool suggestions

How It Works

Original Behavior

The original server provided a framework for tool recommendations but required manual tool specification.

Enhanced Behavior

This version automatically analyzes your thoughts and recommends appropriate tools:

Each recommendation includes:

• Confidence score (0-1) based on pattern matching
• Clear rationale explaining why the tool fits
• Priority level for execution order
• Alternative tools that could also work

The enhanced pattern matching understands context like:

• "record", "save", "document" → Basic Memory write_note
• "read", "examine", "check" → Read tool
• "multiple edits" → MultiEdit tool
• "run", "execute" → Bash tool

Example Usage

Here's an example of how the server guides tool usage:

The server tracks your progress and supports:

• Creating branches to explore different approaches
• Revising previous thoughts with new information
• Maintaining context across multiple steps
• Suggesting next steps based on current findings

Configuration

This server requires configuration through your MCP client. Here are examples for different environments:

Cline Configuration

Add this to your Cline MCP settings:

Claude Desktop with WSL Configuration

For WSL environments, add this to your Claude Desktop configuration:

API

The server implements a single MCP tool with configurable parameters:

sequentialthinking_tools

A tool for dynamic and reflective problem-solving through thoughts, with intelligent tool recommendations.

Parameters:

• thought (string, required): Your current thinking step
• next_thought_needed (boolean, required): Whether another thought step is needed
• thought_number (integer, required): Current thought number
• total_thoughts (integer, required): Estimated total thoughts needed
• is_revision (boolean, optional): Whether this revises previous thinking
• revises_thought (integer, optional): Which thought is being reconsidered
• branch_from_thought (integer, optional): Branching point thought number
• branch_id (string, optional): Branch identifier
• needs_more_thoughts (boolean, optional): If more thoughts are needed
• current_step (object, optional): Current step recommendation with:
  • step_description: What needs to be done
  • recommended_tools: Array of tool recommendations with confidence scores
  • expected_outcome: What to expect from this step
  • next_step_conditions: Conditions for next step
• previous_steps (array, optional): Steps already recommended
• remaining_steps (array, optional): High-level descriptions of upcoming steps

Development

Setup

1. Clone the repository
2. Install dependencies:

3. Build the project:

4. Run in development mode:

Publishing

The project uses changesets for version management. To publish:

1. Create a changeset:

2. Version the package:

3. Publish to npm:

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see the LICENSE file for details.

Acknowledgments

• Built on the Model Context Protocol
• Adapted from the MCP Sequential Thinking Server