Sequential Thinking

by modelcontextprotocol

Recommended
37k stars
10.3k downloads
Not rated
GitHub Website

About

A collection of reference implementations for the Model Context Protocol (MCP), demonstrating secure and controlled access to tools and data sources for Large Language Models (LLMs).

Details

Author
modelcontextprotocol
Repository
modelcontextprotocol/servers
GitHub stars
37,025
Downloads
10,269
License
Other
Categories
Search, Developer Tools, Database, Other, Web Scraping, Productivity, File Management, Design, Workplace, AI, Infrastructure, Cloud Service, Knowledge Base, Communication, Media, Automation, API, Frontend
Tags
#study, #google

Jump to

- Break down complex problems into manageable steps
- Revise and refine thoughts as understanding deepens
- Branch into alternative paths of reasoning
- Adjust the total number of thoughts dynamically
- Generate and verify solution hypotheses

Setting up with Highlight

Follow these steps to add this server as a custom Highlight plugin:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name Sequential Thinking
    Command (node, npx, python, etc.) npx
    Arguments
    • Argument 1 -y
    • Argument 2 @modelcontextprotocol/server-sequential-thinking

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

After installing the server in your MCP host:

1. Restart or reload the host so it reconnects to the server.
2. Confirm the sequential_thinking tool appears in the host's MCP tool list or inspector.
3. Ask the host to solve a non-trivial problem in a step-by-step way.
4. Verify that the host invokes the tool multiple times instead of returning a one-shot answer.

Add this to your claude_desktop_config.json:

For quick installation, click one of the installation buttons below...

Install with NPX in VS Code Install with NPX in VS Code Insiders

Install with Docker in VS Code Install with Docker in VS Code Insiders

For manual installation, you can configure the MCP server using one of these methods:

Method 1: User Configuration (Recommended)
Add the configuration to your user-level MCP configuration file. Open the Command Palette (Ctrl + Shift + P) and run MCP: Open User Configuration. This will open your user mcp.json file where you can add the server configuration.

Method 2: Workspace Configuration
Alternatively, you can add the configuration to a file called .vscode/mcp.json in your workspace. This will allow you to share the configuration with others.

> For more details about MCP configuration in VS Code, see the official VS Code MCP documentation.

For NPX installation:

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

On Windows, use:

{
  "servers": {
    "sequential-thinking": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ]
    }
  }
}

For Docker installation:

{
  "servers": {
    "sequential-thinking": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "mcp/sequentialthinking"
      ]
    }
  }
}

Run the following:

sequential_thinking

Facilitates a detailed, step-by-step thinking process for problem-solving and analysis. Inputs: thought (string), nextThoughtNeeded (boolean), thoughtNumber (integer), totalThoughts (integer), isRevision (boolean, optional), revisesThought (integer, optional), branchFromThought (integer, optional), branchId (string, optional), needsMoreThoughts (boolean, optional).

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

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

Linux

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

Macos

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

Windows

{
    "env": [],
    "args": [
        "/c",
        "npx",
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
    ],
    "command": "cmd"
}
A collection of reference implementations for the Model Context Protocol (MCP), demonstrating secure and controlled access to tools and data sources for Large Language Models (LLMs). This repository is a collection of*reference implementations*for the[Model Context Protocol(MCP), as well as references to community-built servers and additional resources. ](https://modelcontextprotocol.io/)[!IMPORTANT] If you are looking for a list of MCP servers, you can browse published servers on[the MCP Registry. The repository served by this README is dedicated to housing just the small number of reference servers maintained by the MCP steering group. ](https://registry.modelcontextprotocol.io/)[!WARNING] The servers in this repository are intended as**reference implementations**to demonstrate MCP features and SDK usage. They are meant to serve as educational examples for developers building their own MCP servers, not as production-ready solutions. Developers should evaluate their own security requirements and implement appropriate safeguards based on their specific threat model and use case. The servers in this repository showcase the versatility and extensibility of MCP, demonstrating how it can be used to give Large Language Models (LLMs) secure, controlled access to tools and data sources. Typically, each MCP server is implemented with an MCP SDK: - [C# MCP SDK - ](https://github.com/modelcontextprotocol/csharp-sdk)[Go MCP SDK - ](https://github.com/modelcontextprotocol/go-sdk)[Java MCP SDK - ](https://github.com/modelcontextprotocol/java-sdk)[Kotlin MCP SDK - ](https://github.com/modelcontextprotocol/kotlin-sdk)[PHP MCP SDK - ](https://github.com/modelcontextprotocol/php-sdk)[Python MCP SDK - ](https://github.com/modelcontextprotocol/python-sdk)[Ruby MCP SDK - ](https://github.com/modelcontextprotocol/ruby-sdk)[Rust MCP SDK - ](https://github.com/modelcontextprotocol/rust-sdk)[Swift MCP SDK - ](https://github.com/modelcontextprotocol/swift-sdk)[TypeScript MCP SDK These servers aim to demonstrate MCP features and the official SDKs. - **](https://github.com/modelcontextprotocol/typescript-sdk)[Everything**- Reference / test server with prompts, resources, and tools. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/everything)[Fetch**- Web content fetching and conversion for efficient LLM usage. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/fetch)[Filesystem**- Secure file operations with configurable access controls. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/filesystem)[Git**- Tools to read, search, and manipulate Git repositories. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/git)[Memory**- Knowledge graph-based persistent memory system. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/memory)[Sequential Thinking**- Dynamic and reflective problem-solving through thought sequences. - **](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/sequentialthinking)[Time**- Time and timezone conversion capabilities. The following reference servers are now archived and can be found at](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/time)[servers-archived. - **](https://github.com/modelcontextprotocol/servers-archived)[AWS KB Retrieval**- Retrieval from AWS Knowledge Base using Bedrock Agent Runtime. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/aws-kb-retrieval-server)[Brave Search**- Web and local search using Brave's Search API. Has been replaced by the](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/brave-search)[official server. - **](https://github.com/brave/brave-search-mcp-server)[EverArt**- AI image generation using various models. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/everart)[GitHub**- Repository management, file operations, and GitHub API integration. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/github)[GitLab**- GitLab API, enabling project management. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/gitlab)[Google Drive**- File access and search capabilities for Google Drive. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/gdrive)[Google Maps**- Location services, directions, and place details. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/google-maps)[PostgreSQL**- Read-only database access with schema inspection. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/postgres)[Puppeteer**- Browser automation and web scraping. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/puppeteer)[Redis**- Interact with Redis key-value stores. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/redis)[Sentry**- Retrieving and analyzing issues from Sentry.io. - **](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/sentry)[Slack**- Channel management and messaging capabilities. Now maintained by](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/slack)[Zencoder - **](https://github.com/zencoderai/slack-mcp-server)[SQLite**- Database interaction and business intelligence capabilities. TypeScript-based servers in this repository can be used directly with`npx`. For example, this will start the](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/sqlite)[Memoryserver: ``` `npx -y @modelcontextprotocol/server-memory` ``` Python-based servers in this repository can be used directly with](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/memory)[`uvx`or](https://docs.astral.sh/uv/concepts/tools/)[`pip`.`uvx`is recommended for ease of use and setup. For example, this will start the](https://pypi.org/project/pip/)[Gitserver: ``` `# With uvx uvx mcp-server-git # With pip pip install mcp-server-git python -m mcp_server_git` ``` Follow](https://github.com/modelcontextprotocol/servers/blob/HEAD/src/git)[theseinstructions to install`uv`/`uvx`and](https://docs.astral.sh/uv/getting-started/installation/)[theseto install`pip`. However, running a server on its own isn't very useful, and should instead be configured into an MCP client. For example, here's the Claude Desktop configuration to use the above server: ``` `{ "mcpServers": { "memory": { "command": "npx", "args": ](https://pip.pypa.io/en/stable/installation/)["-y", "@modelcontextprotocol/server-memory"] } } }` ``` ``` `{ "mcpServers": { "memory": { "command": "cmd", "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-memory"] } } }` ``` Additional examples of using the Claude Desktop as an MCP client might look like: ``` `{ "mcpServers": { "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"] }, "git": { "command": "uvx", "args": ["mcp-server-git", "--repository", "path/to/git/repo"] }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>" } }, "postgres": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"] } } }` ``` On Windows, apply the same wrapper to each`npx`-based entry above by changing`"command"`to`"cmd"`and prepending`"/c", "npx"`to the existing`args`. Leave`uvx`entries unchanged. Interested in creating your own MCP server? Visit the official documentation at[modelcontextprotocol.iofor comprehensive guides, best practices, and technical details on implementing MCP servers. See](https://modelcontextprotocol.io/introduction)[ADDITIONAL.mdfor a curated list of frameworks and resources that simplify building MCP servers and clients. See](https://github.com/modelcontextprotocol/servers/blob/HEAD/ADDITIONAL.md)[CONTRIBUTING.mdfor information about contributing to this repository. See](https://github.com/modelcontextprotocol/servers/blob/HEAD/CONTRIBUTING.md)[RELEASING.mdfor how packages are published (OIDC trusted publishing from CI — no registry tokens) and how to retry a failed publish. See](https://github.com/modelcontextprotocol/servers/blob/HEAD/RELEASING.md)[SECURITY.mdfor reporting security vulnerabilities. This project is licensed under the Apache License, Version 2.0 for new contributions, with existing code under MIT - see the](https://github.com/modelcontextprotocol/servers/blob/HEAD/SECURITY.md)[LICENSEfile for details. If you find MCP servers useful, please consider starring the repository and contributing new servers or improvements! Managed by Anthropic, but built together with the community. The Model Context Protocol is open source and we encourage everyone to contribute their own servers and improvements! This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases. Create crafted UI components inspired by the best 21st.dev design engineers. Bring agent evaluations, observability, and synthetic test set generation directly into your IDE for free with Galileo's new MCP server An MCP server to help AI assistants to answer questions and generate AccelByte Extend SDK code more effectively . MCP server for AI Diagram Maker — generate beautiful software engineering diagrams directly inside Cursor, Claude Desktop, Claude Code, or any MCP-compatible AI agent ALAPI MCP Tools,Call hundreds of API interfaces via MCP AI-powered SVG animation generator that transforms static files into animated SVG components using the Allyson platform MCP server that gives AI assistants on-demand access to 1,500+ amCharts docs, ~300 code examples, and 1000+ class API references. APIMatic MCP Server is used to validate OpenAPI specifications using APIMatic. The server processes OpenAPI files and returns validation summaries by leveraging APIMatic’s API. One shared context layer for AI agents and humans — live API specs, DB schemas, and versioned contracts across repos so every agent and teammate works from the same source of truth. Build and deploy full-stack Next.js apps with 98 tools for React, AWS, and MongoDB](https://github.com/modelcontextprotocol/servers/blob/HEAD/LICENSE)
No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Install

Add to Claude Desktop or Cursor

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

More like this

Similar MCP servers you might find useful

Browse category

Git

A Model Context Protocol (MCP) server that provides tools for LLMs to read, search, and manipulate Git repositories. It enables automated repository…

88.1k
Developer Tools

Context 7

Official Context7 MCP server that brings up-to-date, version-specific library documentation and code examples into AI coding prompts.

58.7k
Developer Tools