-
security-
license-
qualityAn MCP server that analyzes codebases and generates contextual prompts, making it easier for AI assistants to understand and work with code repositories.
Last updated -
14
MIT License
Smart-Thinking is a sophisticated MCP server designed for advanced, graph-based reasoning and verification. It offers:
Multi-dimensional thought graphs for nuanced reasoning and analysis
Robust verification system with 8 distinct statuses to verify facts and detect contradictions
Interactive visualizations in multiple layouts (standard, chronological, thematic, hierarchical, force, radial)
Persistent data storage across sessions via session IDs
Cross-platform compatibility on Windows, macOS, and Linux
Integration capabilities with various MCP clients and as a Node.js module
User personalization to adapt reasoning based on preferences and history
Collaborative multi-agent systems for team-based reasoning
Various thought types (regular, revision, meta, hypothesis, conclusion)
Auto-learning mechanisms to improve reasoning over time
Offers API integration for Node.js applications to utilize Smart-Thinking's reasoning capabilities programmatically, with functions for thought processing and verification.
Available as an npm package (smart-thinking-mcp) for easy installation and integration into JavaScript/TypeScript projects.
Built with TypeScript 5.1.6, providing type-safe integration for applications that want to incorporate Smart-Thinking's reasoning capabilities.
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
VotreNomwith 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 separatorsBuilt-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 |
| string | Content of the thought to be analyzed (mandatory) |
| string | Type of thinking ('regular', 'revision', 'meta', 'hypothesis', 'conclusion') |
| array | Connections to other thoughts |
| boolean | Enable automatic verification |
| boolean | Indicate whether the thought contains calculations |
| boolean | Generate a thought graph visualization |
| boolean | Suggest relevant MCP tools |
| 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 |
| Information verified with confidence |
| Information partially verified |
| Unverified information |
| Information contradicted by other sources |
| Verification inconclusive |
| Lack of information on the subject |
| Uncertain information due to contradictions |
| 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*.logOn Windows:
%USERPROFILE%\AppData\Local\Claude\logs\mcp*.logOn 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
local-only server
The server can only run on the client's local machine because it depends on local resources.
Tools
A sophisticated MCP server that provides a multi-dimensional, adaptive reasoning framework for AI assistants, replacing linear reasoning with a graph-based architecture for more nuanced cognitive processes.
- Overview
- Key Features
- Facility
- Configuration with Claude Desktop
- Cross-platform file system
- Use
- Verification system
- Visualization
- Data persistence
- Compatibility with MCP clients
- Comparison with Sequential-Thinking
- API and integration
- Troubleshooting
- Contribution
- License
Related Resources
Related MCP Servers
- Asecurity-licenseAqualityAn MCP server that supercharges AI assistants with powerful tools for software development, enabling research, planning, code generation, and project scaffolding through natural language interaction.Last updated -111,16780
- Asecurity-licenseAqualityAn advanced MCP server that implements sophisticated sequential thinking using a coordinated team of specialized AI agents (Planner, Researcher, Analyzer, Critic, Synthesizer) to deeply analyze problems and provide high-quality, structured reasoning.Last updated -1253
- Asecurity-licenseAqualityAn MCP server that provides a "think" tool enabling structured reasoning for AI agents, allowing them to pause and record explicit thoughts during complex tasks or multi-step tool use.Last updated -175MIT License