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.

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

Setting	Kind	Description
`thought`	string	Content of the thought to be analyzed (mandatory)
`thoughtType`	string	Type of thinking ('regular', 'revision', 'meta', 'hypothesis', 'conclusion')
`connections`	array	Connections to other thoughts
`requestVerification`	boolean	Enable automatic verification
`containsCalculations`	boolean	Indicate whether the thought contains calculations
`generateVisualization`	boolean	Generate a thought graph visualization
`suggestTools`	boolean	Suggest relevant MCP tools
`sessionId`	string	Session ID for persistence

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:

Status	Description
`verified`	Information verified with confidence
`partially_verified`	Information partially verified
`unverified`	Unverified information
`contradicted`	Information contradicted by other sources
`inconclusive`	Verification inconclusive
`absence_of_information`	Lack of information on the subject
`uncertain`	Uncertain information due to contradictions
`contradictory`	Inherently contradictory information

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

Functionality	Sequential Thinking	Smart-Thinking
Thought structure	Linear	Multi-dimensional (graph)
Connection types	Boundaries	Rich and nuanced (16+ types)
Adaptation	Static	Dynamic and contextual
Verification	Basic	Advanced (8 different statuses)
Visualization	Simple	Interactive and configurable
Memory	Temporary	Persistent with vectorization
Collaboration	No	Yes (multi-agent)
Personalization	Limited	User-adaptive
Self-learning	No	Yes
Metrics	Basics	Contextual and multi-factor
Platform compatibility	Limited	Complete (Windows, macOS, Linux)

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

Issue	Solution
Smart-Thinking does not appear in Claude	Check the paths in the configuration, restart Claude Desktop
File access errors	Check the permissions of the data directory
Connection problems on Windows	Use full and absolute paths with forward slashes
Errors with NVM on Windows	Use the full path to the active version of Node.js

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

Integrations