Chain of Thought MCP server

This MCP server allows you to leverage Qwen's qwq model via Groq's API to access raw chain-of-thought tokens, similar to Anthropic's "think" tool functionality. It improves LLM performance by enabling more deliberate reasoning processes for complex tasks.

Installation

To set up the Chain of Thought MCP Server:

1. Clone the repository to your local machine
2. Install dependencies:

   uv sync
   

3. Obtain a Groq API key from Groq's console
4. Update your MCP configuration by adding:

   "mcpServers": {
     "chain_of_thought": {
       "command": "uv",
       "args": [
           "--directory",
           "path/to/cot-mcp-server",
           "run",
           "src/server.py"
         ],
         "env": {
           "GROQ_API_KEY": "your-groq-api-key"
         }
       }
   }
   

Note: Replace path/to/cot-mcp-server with the actual path to the repository. You can determine this by running pwd in the terminal from the repository's root directory.

Using the MCP Server

Configuration for LLM Agents

To maximize the benefits of this tool, configure your LLM agent to use the chain-of-thought functionality with every request by adding these instructions to your agent's rules:

<IMPORTANT>
<when_to_use_tool>
You should call the mcp chain_of_thought tool every time you talk to the user, which generates a chain-of-thought stream which you will use to complete the user's request.
</when_to_use_tool>

Before taking any action or responding to the user use the chain of thought tool as a scratchpad to:
- List the specific rules that apply to the current request
- Check if all required information is collected
- Verify that the planned action complies with all policies
- Iterate over tool results for correctness 

Here are some examples of what to iterate over inside the think tool:
<cot_tool_example_1>
User wants to cancel flight ABC123
- Need to verify: user ID, reservation ID, reason
- Check cancellation rules:
  * Is it within 24h of booking?
  * If not, check ticket class and insurance
- Verify no segments flown or are in the past
- Plan: collect missing info, verify rules, get confirmation
</cot_tool_example_1>

<cot_tool_example_2>
User wants to book 3 tickets to NYC with 2 checked bags each
- Need user ID to check:
  * Membership tier for baggage allowance
  * Which payments methods exist in profile
- Baggage calculation:
  * Economy class × 3 passengers
  * If regular member: 1 free bag each → 3 extra bags = $150
  * If silver member: 2 free bags each → 0 extra bags = $0
  * If gold member: 3 free bags each → 0 extra bags = $0
- Payment rules to verify:
  * Max 1 travel certificate, 1 credit card, 3 gift cards
  * All payment methods must be in profile
  * Travel certificate remainder goes to waste
- Plan:
1. Get user ID
2. Verify membership level for bag fees
3. Check which payment methods in profile and if their combination is allowed
4. Calculate total: ticket price + any bag fees
5. Get explicit confirmation for booking
</cot_tool_example_2>

</IMPORTANT>

Benefits of the Chain of Thought Approach

By invoking this tool, the LLM will:

• Work through problems methodically
• Verify necessary information is collected
• Check compliance with specific rules
• Validate results before providing responses
• Improve overall performance on complex tasks

This approach is particularly useful for tasks requiring multi-step reasoning, compliance verification, or detailed planning.

How to install this MCP server

For Claude Code

To add this MCP server to Claude Code, run this command in your terminal:

claude mcp add-json "chain_of_thought" '{"command":"uv","args":["--directory","path/to/cot-mcp-server","run","src/server.py"],"env":{"GROQ_API_KEY":"your-groq-api-key"}}'

See the official Claude Code MCP documentation for more details.

For Cursor

There are two ways to add an MCP server to Cursor. The most common way is to add the server globally in the ~/.cursor/mcp.json file so that it is available in all of your projects.

If you only need the server in a single project, you can add it to the project instead by creating or adding it to the .cursor/mcp.json file.

Adding an MCP server to Cursor globally

To add a global MCP server go to Cursor Settings > Tools & Integrations and click "New MCP Server".

When you click that button the ~/.cursor/mcp.json file will be opened and you can add your server like this:

{
    "mcpServers": {
        "chain_of_thought": {
            "command": "uv",
            "args": [
                "--directory",
                "path/to/cot-mcp-server",
                "run",
                "src/server.py"
            ],
            "env": {
                "GROQ_API_KEY": "your-groq-api-key"
            }
        }
    }
}

Adding an MCP server to a project

To add an MCP server to a project you can create a new .cursor/mcp.json file or add it to the existing one. This will look exactly the same as the global MCP server example above.

How to use the MCP server

Once the server is installed, you might need to head back to Settings > MCP and click the refresh button.

The Cursor agent will then be able to see the available tools the added MCP server has available and will call them when it needs to.

You can also explicitly ask the agent to use the tool by mentioning the tool name and describing what the function does.

For Claude Desktop

To add this MCP server to Claude Desktop:

1. Find your configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

2. Add this to your configuration file:

{
    "mcpServers": {
        "chain_of_thought": {
            "command": "uv",
            "args": [
                "--directory",
                "path/to/cot-mcp-server",
                "run",
                "src/server.py"
            ],
            "env": {
                "GROQ_API_KEY": "your-groq-api-key"
            }
        }
    }
}

3. Restart Claude Desktop for the changes to take effect