Sequential Thinking MCP Server - Streamable HTTP Implementation

An MCP server that provides a powerful sequential thinking tool for complex problem-solving through thoughts.

This server enables AI assistants to work through problems step-by-step, with the ability to revise, branch, and explore alternative approaches as understanding deepens.

Features

• Dynamic Thought Process: Adjust the number of thoughts as you progress
• Revision Capability: Question and revise previous thoughts
• Branching Logic: Explore alternative approaches
• Flexible Planning: Add more thoughts even after reaching initial estimates
• Context Preservation: Maintain context across multiple thinking steps

Getting Started

To get started with this server, clone the repository and install the necessary dependencies.

git clone https://github.com/camilovelezr/server-sequential-thinking.git
cd server-sequential-thinking
npm install

Usage

Streamable HTTP Transport

The server uses the modern Streamable HTTP transport protocol for communication. Start the server:

npm start

The server will start on http://127.0.0.1:3000 by default. You can change the port using the PORT environment variable:

PORT=8080 npm start

Endpoints

• MCP Endpoint: POST/GET/DELETE http://127.0.0.1:3000/mcp - Main MCP communication endpoint
  • POST - Send messages to the server (initialize, tool calls, etc.)
  • GET - Establish SSE stream for server-to-client notifications
  • DELETE - Terminate session
• Health Check: GET http://127.0.0.1:3000/health - Check server status and active sessions
• Test Interface: GET http://127.0.0.1:3000/ - Browser-based test interface

Transport Features

The Streamable HTTP transport provides several advantages:

• Session-Based State: Manages state for each client session in memory. The core server is long-running and can be scaled with sticky sessions.
• Flexible Streaming: Server can upgrade any response to SSE for streaming
• Infrastructure Compatible: Works with standard HTTP middleware and proxies
• Resumable Connections: Support for connection resumption
• Automatic Session Cleanup: Inactive sessions and their associated data are automatically cleared after 1 hour to conserve resources.

Security

The implementation includes security measures:

• Origin header validation to prevent DNS rebinding attacks
• Server binds only to localhost (127.0.0.1)
• CORS headers are properly configured
• Session IDs are cryptographically secure
• Privacy by Design: No sensitive tool inputs or outputs are logged to the console.

Adding to Cursor

To use this server with Cursor, add the following to your Cursor configuration:

{
  "mcpServers": {
    "sequential-thinking": {
      "url": "http://localhost:3000/mcp"
    },
  }
}

Running with Docker

You can also run the server in a containerized environment using Docker for easier deployment and isolation.

1. Build the Docker image:

   docker build -t mcp-server-sequential-thinking .
   

2. Run the Docker container:

   docker run -p 3000:3000 mcp-server-sequential-thinking
   

The server will be accessible at http://127.0.0.1:3000.

Available Tool

sequentialthinking

A detailed tool for dynamic and reflective problem-solving through thoughts.

When to use:

• Breaking down complex problems into steps
• Planning and design with room for revision
• Analysis that might need course correction
• Problems where the full scope might not be clear initially
• Multi-step solutions requiring context preservation

Parameters:

• thought (string, required): Your current thinking step
• nextThoughtNeeded (boolean, required): Whether another thought step is needed
• thoughtNumber (integer, required): Current thought number
• totalThoughts (integer, required): Estimated total thoughts needed
• isRevision (boolean, optional): Whether this revises previous thinking
• revisesThought (integer, optional): Which thought is being reconsidered
• branchFromThought (integer, optional): Branching point thought number
• branchId (string, optional): Branch identifier
• needsMoreThoughts (boolean, optional): If more thoughts are needed

License

MIT