Smart-Thinking

Overview

Smart-Thinking is a sophisticated MCP (Model Context Protocol) server that provides a multi-dimensional, adaptive, and self-verifying reasoning framework for AI assistants like Claude. Unlike linear reasoning approaches, Smart-Thinking uses a graph-based architecture that allows for complex connections between thoughts, providing a more nuanced reasoning capability that is closer to human cognition.

Smart-Thinking is fully compatible with all platforms (Windows, macOS, Linux) and integrates seamlessly with many MCP clients, including Claude Desktop, Cline, Windsurf, and other MCP-compatible applications.

Related MCP server: Tyra Advanced Memory MCP Server

Key Features

Advanced cognitive architecture

• Multi-dimensional thought graph replacing traditional linear sequences

• Dynamic and self-adaptive estimation of the number of thoughts needed

• Rich and nuanced types of connections between thoughts (supports, contradicts, refines, etc.)

• Contextual thinking metrics (confidence, relevance, quality)

Robust verification system

• Automatic fact checking and calculations with 8 different statuses

• Detection of contradictions and uncertainties in reasoning

• Reliability scores tailored to each type of verification

• Generation of context-appropriate certainty summaries

Advanced Features

• Persistent memory for previous sessions

• Self-learning mechanisms to improve reasoning

• User-friendly personalization for relevant reasoning

• Interactive visualizations of the reasoning process

• Multi-agent collaboration for teamwork

• Seamless integration with the MCP tool ecosystem

Cross-platform compatibility

• Works identically on Windows, macOS, and Linux

• Compatible with NVM (Node Version Manager) on all platforms

• Automatic management of file paths according to the platform

• Simplified configuration for each environment

• Automatic resolution of OS-specific problems

Facility

Option 1: Global Installation (Recommended)

# Sur macOS/Linux
npm install -g smart-thinking-mcp

# Sur Windows (depuis PowerShell ou CMD)
npm install -g smart-thinking-mcp

Option 2: Installation via Smithery

To install Smart-Thinking automatically via Smithery :

npx -y @smithery/cli install @Leghis/smart-thinking --client claude

Option 3: Use via npx (without installation)

# Sur macOS/Linux
npx -y smart-thinking-mcp

# Sur Windows (moins recommandé, préférez l'installation globale)
npx -y smart-thinking-mcp

Option 4: Install from source code

# Cloner le dépôt
git clone https://github.com/Leghis/Smart-Thinking.git
cd Smart-Thinking

# Installer les dépendances
npm install

# Compiler le projet
npm run build

# Créer un lien npm global
npm link

Configuration with Claude Desktop

Setup on macOS

Add this configuration to your ~/Library/Application Support/Claude/claude_desktop_config.json file:

{
  "mcpServers": {
    "smart-thinking": {
      "command": "smart-thinking-mcp"
    }
  }
}

OR via npx:

{
  "mcpServers": {
    "smart-thinking": {
      "command": "npx",
      "args": ["-y", "smart-thinking-mcp"]
    }
  }
}

Configuration on Windows

Add this configuration to your %APPDATA%\Claude\claude_desktop_config.json file:

{
  "mcpServers": {
    "smart-thinking": {
      "command": "C:/Users/VotreNom/AppData/Roaming/npm/smart-thinking-mcp.cmd"
    }
  }
}

OR with the full path to Node.js (recommended for Windows):

{
  "mcpServers": {
    "smart-thinking": {
      "command": "C:/Program Files/nodejs/node.exe",
      "args": ["C:/Users/VotreNom/AppData/Roaming/npm/node_modules/smart-thinking-mcp/build/index.js"]
    }
  }
}

Important :

• Replace VotreNom with your Windows username.

• Use forward slashes ( / ) in Windows paths, even if the OS uses backslashes ( \ ).

For detailed installation instructions, see the Installation Guide .

Cross-platform file system

Smart-Thinking implements advanced file system management compatible with all platforms:

File System Features

• Automatic path normalization : Seamless conversion between Windows ( \ ) and Unix ( / ) path separators

• Built-in platform detection : Automatic adaptation according to the OS (Windows, macOS, Linux)

• Special Path Handling : Support for Windows UNC paths, WSL paths and paths with spaces

• Self-configured data directory : Automatic creation and management of the data directory

• Intelligent Fallback : Automatic creation of an alternative directory in case of access problems

• Platform-specific configuration paths : Correct location of configuration files depending on the OS

Configuring the data directory

By default, Smart-Thinking creates and uses a data folder in its working directory. You can also specify a custom directory with the SMART_THINKING_DATA_DIR environment variable:

{
  "mcpServers": {
    "smart-thinking": {
      "command": "smart-thinking-mcp",
      "env": {
        "SMART_THINKING_DATA_DIR": "/chemin/absolu/vers/data"
      }
    }
  }
}

Support for NVM (Node Version Manager)

Smart-Thinking automatically detects if Node.js is installed via NVM and adapts the paths accordingly, providing perfect compatibility on all platforms, including Windows with NVM.

Use

Main settings

Examples of use

Simple reasoning

Utilise l'outil Smart-Thinking pour analyser les avantages et inconvénients des énergies renouvelables.

With automatic verification

Utilise Smart-Thinking avec vérification (requestVerification=true) pour évaluer les affirmations suivantes sur le changement climatique.

With visualization

Utilise Smart-Thinking avec visualisation (generateVisualization=true) pour développer une stratégie marketing multicouche.

Collaborative analysis

Utilise Smart-Thinking avec un identifiant de session (sessionId="projet-innovation") pour analyser ce problème complexe d'optimisation.

Verification system

Smart-Thinking incorporates a sophisticated verification system that evaluates the reliability of information and calculations. It supports 8 distinct verification statuses:

The system calculates a reliability score that combines these statuses with other metrics like trust, relevance, and quality.

Calculating the reliability score

The reliability score is calculated using a formula that balances:

• Basic metrics (trust, relevance, quality)

• The verification status

• The results of the calculation verification (if present)

• History of previous scores (for temporal smoothing)

Thresholds and scores have been optimized through simulation to ensure maximum consistency.

Visualization

Smart-Thinking offers several types of thought graph visualizations:

• Standard Graph : Standard arrangement of the thought network

• Chronological : Temporal organization of thoughts

• Theme : Clusters by similar themes

• Hierarchical : Tree structure

• Force : Arrangement based on the forces of attraction/repulsion

• Radial : Concentric circles around a central thought

Visualizations can be filtered according to:

• Types of thoughts

• Connection types

• Metric thresholds

• Text search

• Date ranges

Data persistence

Smart-Thinking implements a robust data persistence system that stores:

• Thought graphs by session

• Verification results for future reuse

• Metrics calculated for analysis and improvement

• User preferences for personalization

Data is stored in a cross-platform compatible manner in structured JSON files on the file system, ensuring persistence across sessions.

Compatibility with MCP clients

Smart-Thinking is compatible with many MCP clients, including:

• Claude Desktop App : Full support for tools, resources and prompts

• Cline : Support for tools and resources

• Continue : Full support for all MCP features

• 5th : Support for tools

• Cursor : Support for tools

• Windsurf Editor : Support for AI Flow tools

• And more...

Comparison with Sequential-Thinking

API and integration

Smart-Thinking can be integrated into other Node.js applications:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { SmartThinking } from 'smart-thinking-mcp';

// Initialiser Smart-Thinking
const smartThinking = new SmartThinking({
  persistenceEnabled: true,
  verificationEnabled: true
});

// Utiliser les fonctionnalités
const result = await smartThinking.processThought({
  thought: "Cette pensée sera analysée et vérifiée",
  requestVerification: true
});

console.log(result.qualityMetrics);
console.log(result.verificationStatus);

Troubleshooting

Quick Operation Check

To verify that Smart-Thinking is working correctly:

# Sur macOS/Linux
smart-thinking-mcp

# Sur Windows
smart-thinking-mcp.cmd

You should see the server starting message.

Consult the logs

If you encounter any difficulties, check the Claude Desktop logs:

• On macOS: ~/Library/Logs/Claude/mcp*.log

• On Windows: %USERPROFILE%\AppData\Local\Claude\logs\mcp*.log

• On Linux: ~/.local/share/Claude/logs/mcp*.log

Common Problems and Solutions

For Windows and NVM specific issues, see the dedicated section in the Installation Guide .

Contribution

Contributions are welcome! Check out our Contribution Guide for more information.

License

MIT