Think MCP Server

🚀 Think-MCP-Server

A minimal MCP (Message Control Protocol) server implemented based on Anthropic's "Think" tool research. By adding instructions to the prompt, Claude can handle complex tasks more effectively.

🚀 Quick Start

This is a minimal MCP (Message Control Protocol) server implemented based on Anthropic's "Think" tool research. By adding instructions to the prompt, Claude can handle complex tasks more effectively.

📦 Installation

System Requirements

• Node.js (Recommended version: 18.0.0 or higher)
• npm (Recommended version: 8.0.0 or higher)

Installation Steps

1. Clone the project repository:

git clone https://github.com/your-repository/think-mcp-server.git
cd think-mcp-server

2. Install dependencies:

npm install

🚀 Server Startup

Startup Command

node src/server.js

Port Configuration

The server listens on port 3000 by default. You can modify it in server.js:

const PORT = process.env.PORT || 3000;

✨ Features

• Think Tool Support: Use the think command to make Claude pause and perform internal reasoning when handling complex tasks.
• Type-Safe Development: Provide specific prompt examples to guide effective TypeScript development using this tool.

📈 Performance Advantages

According to Anthropic's research results:

• Improved by 54% in the aviation domain τ-Bench test (pass^1 metric: 0.570 vs baseline 0.370)
• Average performance improvement of 1.6% in SWE-bench
• Significantly enhanced experimental consistency

📚 Documentation

Based on the research article "Think Tool: Making Claude Pause and Reason in Complex Tasks" published by Anthropic on March 20, 2025.

🔧 Technical Details

Project Structure

├── README.md          # Project documentation
├── package.json      # Dependency management file
├── src/             # Source code directory
│   ├── index.js     # Entry file
│   └── server.js    # Server implementation
└── Dockerfile       # Docker build configuration

Prompt Example (TypeScript Development)

Use Case

Analyze user requirements to determine whether to use the think command:

## Application of the Think Tool in TypeScript Development

Before implementing any TypeScript code or answering technical questions, use the `think` command to perform the following analysis:
- Check relevant type definitions and interfaces
- Look for potential type errors or boundary cases
- Reason about generics and type constraints
- Verify the correct use of TypeScript features

#### Example: Implementation of a React TypeScript State Management Hook

User goal: Develop a generic React state management hook with type-safe update methods.

**Thinking Steps**:
1. Analyze requirements:
   - Handle arbitrary data types (generics)
   - Maintain type information throughout the state lifecycle
   - Provide type-safe update methods
   - Comply with React rules
2. Consider type constraints:
   - Are basic types allowed?
   - Is `Partial<T>` applicable?
   - Use `Record<string, unknown>` as a fallback?
3. Implementation steps:
   1. Define a generic interface
   2. Implement state management based on `useState<T>`
   3. Create typed update methods
   4. Add JSDoc comments

**Final Code Example**:
```typescript
interface StateHook<S> {
  state: S;
  setState: ( updater: ( prevState: S ) => S ) => void;
}

function useStateWithCallbacks<T>(initialState: T): StateHook<T> {
  const [state, setState] = useState(initialState);
  
  // Type-safe update method
  const updateStateWithCallback = <U extends (prevState: T) => T>(
    updater: U,
    callback?: (newState: T) => void
  ): void => {
    setState(updater);
    if (callback) {
      callback(state);
    }
  };

  return { state, setState };
}

Steps for Using the Think Tool:

1. Analyze the type system: Check type definitions and constraints.
2. Handle boundary cases: Verify the atomicity and consistency of the update logic.
3. Maintain type safety: Ensure that all operations comply with TypeScript specifications.

By using this systematic thinking approach, you can significantly improve code quality and development efficiency.