Content
# Atom of Thoughts (AoT)
[](https://mseep.ai/app/kbsooo-mcp-atom-of-thoughts)
[](https://smithery.ai/server/@kbsooo/mcp_atom_of_thoughts)
[](https://mseep.ai/app/672e0733-4c20-461f-b9cf-59ec2c9dafff)
A Model Context Protocol (MCP) server implementation of Atom of Thoughts, a decomposition-based reasoning framework.
> **Note**: This implementation is based on the research paper ["Atom of Thoughts for Markov LLM Test-Time Scaling"](https://arxiv.org/abs/2502.12018) (Teng et al., 2025).
<a href="https://glama.ai/mcp/servers/@kbsooo/MCP_Atom_of_Thoughts">
<img width="380" height="200" src="https://glama.ai/mcp/servers/@kbsooo/MCP_Atom_of_Thoughts/badge" />
</a>
[MCP.so](https://mcp.so/server/atom-of-thoughts/kbsooo)
## English Documentation
This repository implements Atom of Thoughts (AoT), a decomposition-based reasoning framework, as a Model Context Protocol (MCP) server. This implementation is based on the concepts presented in the paper ["Atom of Thoughts for Markov LLM Test-Time Scaling"](https://arxiv.org/abs/2502.12018) (Teng et al., 2025).
### Available Tools
Two main tools are provided:
1. **AoT (Full Version)**: A complete Atom of Thoughts tool with full capabilities for deep analysis and complex problem solving.
2. **AoT-light (Lightweight Version)**: A streamlined version optimized for faster processing and quicker results.
### AoT-light: Lightweight Version
AoT-light is designed for faster processing in time-sensitive situations:
- **Key Features**:
- Lower maximum depth (3 instead of 5) for faster processing
- Simplified verification process
- Immediate conclusion suggestion for high-confidence hypotheses
- Reduced computational overhead and response payload
- Optimized for speed rather than exhaustive analysis
- **Use Cases**:
- Quick brainstorming sessions requiring atomic thought organization
- Time-sensitive problem solving where speed is prioritized over exhaustive analysis
- Simpler reasoning tasks that don't require deep decomposition
- Initial exploration before using the full AoT for deeper analysis
- Learning or demonstration purposes where response time is important
### Use Cases
Atom of Thoughts is effective in the following scenarios:
- Solving problems requiring complex reasoning
- Generating hypotheses that need verification from multiple perspectives
- Deriving high-confidence conclusions in scenarios where accuracy is crucial
- Minimizing logical errors in critical tasks
- Decision-making requiring multiple verification steps
### Atom Types
AoT uses five types of atoms:
1. **premise**: Basic assumptions or given information for problem solving
2. **reasoning**: Logical reasoning process based on other atoms
3. **hypothesis**: Proposed solutions or intermediate conclusions
4. **verification**: Process to evaluate the validity of other atoms (especially hypotheses)
5. **conclusion**: Verified hypotheses or final problem solutions
### Core Features
#### 1. Decomposition-Contraction Mechanism
A mechanism to decompose atoms into smaller sub-atoms and contract them back after verification.
- **Decomposition**: Breaking complex atoms into smaller sub-atoms.
- `startDecomposition(atomId)`: Start atom decomposition
- `addToDecomposition(decompositionId, atomId)`: Add sub-atom to decomposition
- `completeDecomposition(decompositionId)`: Complete decomposition process
- **Contraction**: Contract back to the original atom once all sub-atoms are verified.
- Calculate confidence of the original atom based on sub-atoms' confidence levels
- Automatically suggest conclusions for high-confidence verified hypotheses
#### 2. Automatic Termination Mechanism
- Automatically terminates when reaching maximum depth or finding a high-confidence conclusion.
- `getTerminationStatus()`: Return current termination status and reason
- `getBestConclusion()`: Return the conclusion with highest confidence
### Parameter Descriptions
- **atomId**: Unique identifier for the atom (e.g., 'A1', 'H2')
- **content**: Actual content of the atom
- **atomType**: Type of atom (one of: premise, reasoning, hypothesis, verification, conclusion)
- **dependencies**: List of IDs of other atoms this atom depends on
- **confidence**: Confidence level of this atom (value between 0-1)
- **isVerified**: Whether this atom has been verified
- **depth**: Depth level of this atom in the decomposition-contraction process
### Usage Method
1. Understand the problem and define necessary premise atoms
2. Create reasoning atoms based on premises
3. Create hypothesis atoms based on reasoning
4. Create verification atoms to verify hypotheses
5. Derive conclusion atoms based on verified hypotheses
6. Use atom decomposition to explore deeper when necessary
7. Present the high-confidence conclusion atom as the final answer
### Comparing Sequential Thinking and Atom of Thoughts (More Testing Needed)
After applying both thinking tools to the same topic, the following differences and performance characteristics were observed:
#### Structural Differences
**Sequential Thinking:**
- Linear thinking process: progresses sequentially from one thought to the next
- Predicts the total number of thoughts in advance
- Each thinking stage is built upon previous stages
**Atom of Thoughts:**
- Non-linear, network structure: multiple thought units (atoms) interconnect with dependencies
- Forms systematic structure according to atom types (premise, reasoning, hypothesis, verification, conclusion)
- Explicitly evaluates the confidence level of each atom
#### Comparative Strengths
**Sequential Thinking Strengths:**
- Intuitive flow: similar to natural human thinking processes
- Simplicity: simple structure allows quick application to straightforward problems
- Flexibility: can modify previous stages or change direction during the thinking process
**Atom of Thoughts Strengths:**
- Confidence evaluation: explicitly measures the confidence of each thought to improve conclusion validity
- Verification process: evaluates hypotheses through systematic verification stages
- Dependency tracking: clearly tracks which premises or reasoning influenced specific conclusions
- Parallel processing: can consider multiple thought atoms simultaneously
#### Efficiency and Accuracy
**Efficiency:**
- Sequential Thinking: more efficient for simple problems, with faster progression of thought
- Atom of Thoughts: more efficient for complex problems, but has initial overhead in building systematic structures
**Accuracy:**
- Sequential Thinking: possibility of error accumulation from previous stages as the thinking process deepens
- Atom of Thoughts: reduced error possibility through verification stages and confidence assessment, leading to more reliable conclusions
#### Suitability by Purpose
**Cases Suitable for Sequential Thinking:**
- Simple to moderately complex problems
- Time-constrained situations
- When natural storytelling or explanation is needed
**Cases Suitable for Atom of Thoughts:**
- Highly complex problems
- Situations where accuracy and reliability are crucial
- Hypotheses requiring verification from multiple perspectives
- Reasoning with complex dependency relationships
#### Conclusion
Both tools can contribute to improving artificial intelligence's reasoning abilities, but the appropriate tool varies depending on the nature of the problem and requirements. Sequential Thinking is useful when intuitive and quick thinking processes are needed, while Atom of Thoughts is more suitable for complex problems requiring systematic verification and high reliability.
### Command Tool (atomcommands)
A command tool to control the decomposition-contraction mechanism and automatic termination of Atom of Thoughts.
**Available Commands**:
1. **decompose**: Decompose a specified atom into smaller sub-atoms
- Required parameter: `atomId`
2. **complete_decomposition**: Complete an ongoing decomposition process
- Required parameter: `decompositionId`
3. **termination_status**: Check the termination status of the current AoT process
4. **best_conclusion**: Get the verified conclusion with the highest confidence
5. **set_max_depth**: Change the maximum depth limit
- Required parameter: `maxDepth`
### Installing via Smithery
To install Atom of Thoughts for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@kbsooo/mcp_atom_of_thoughts):
```bash
npx -y @smithery/cli install @kbsooo/mcp_atom_of_thoughts --client claude
```
### MCP Server Configuration
To use the Atom of Thoughts MCP server, you need to register it in your Claude Desktop or Cline MCP settings. Here is an example configuration:
```json
{
"mcpServers": {
"atom-of-thoughts": {
"command": "node",
"args": ["/ABSOLUTE/PATH/TO/PARENT/FOLDER/atom-of-thoughts/build/index.js"],
"disabled": false,
"autoApprove": []
}
}
}
```
Replace `/ABSOLUTE/PATH/TO/PARENT/FOLDER` with the actual absolute path to the project on your system. After saving the configuration, restart Claude Desktop or Cline to use the Atom of Thoughts MCP server.
For detailed implementation and code-level documentation, please refer to the source code in this repository.
## Tool List
### Atom of Thoughts
Atom of Thoughts(AoT) is a tool that solves problems by breaking them down into independent, reusable atomic units of thought. This tool, unlike traditional sequential thinking, allows for a more powerful problem-solving approach by having these 'atoms' depend on each other. This implementation is based on the concepts from the paper "Atom of Thoughts for Markov LLM Test-Time Scaling" (Teng et al., 2025).
### Tools Provided
Currently, two main tools are provided:
1. **AoT (Full Version)**: A fully-featured Atom of Thoughts tool for in-depth analysis and complex problem-solving.
2. **AoT-light (Lightweight Version)**: A lightweight version optimized for faster processing and quick results.
### AoT-light: Lightweight Version
AoT-light is designed for faster processing in situations where time is of the essence:
- **Key Features**:
- Lower maximum depth setting (3 instead of 5) for quicker processing
- Simplified verification process
- Immediate conclusion suggestions for high-confidence hypotheses
- Reduced computational overhead and response data
- Optimized for speed over thorough analysis
- **Usage Scenarios**:
- Fast brainstorming sessions requiring atomic thought composition
- Time-sensitive problem-solving where speed is more critical than thorough analysis
- Simple reasoning tasks not requiring deep decomposition
- Initial exploration before in-depth analysis with full AoT
- Learning or demonstration purposes where response time is crucial
### Usage Scenarios
Atom of Thoughts is effective in the following scenarios:
- Problem-solving requiring complex reasoning
- Hypothesis generation requiring verification from multiple perspectives
- Deriving reliable conclusions in accuracy-critical problems
- Tasks requiring minimization of logical errors
- Decision-making requiring multiple levels of verification
### Atom Types
Atom of Thoughts uses five types of atoms:
1. **premise**: Basic assumptions or given information for problem-solving
2. **reasoning**: Logical reasoning processes based on other atoms
3. **hypothesis**: Proposals for possible solutions or intermediate conclusions
4. **verification**: The process of evaluating the validity of other atoms (especially hypotheses)
5. **conclusion**: Verified hypotheses or final problem-solving solutions
### Key Features
#### 1. Decomposition-Contraction Mechanism
A mechanism that decomposes atoms into smaller sub-atoms and contracts them back after verification.
- **Decomposition**: Decomposes complex atoms into smaller sub-atoms.
- `startDecomposition(atomId)`: Starts atom decomposition
- `addToDecomposition(decompositionId, atomId)`: Adds a sub-atom to the decomposition
- `completeDecomposition(decompositionId)`: Completes the decomposition process
- **Contraction**: Contracts back into the original atom when sub-atoms are all verified.
- Calculates the reliability of the original atom based on the reliability of sub-atoms
- Automatically suggests conclusions for high-confidence hypotheses
#### 2. Automatic Termination Mechanism
- Automatically terminates when the maximum depth is reached or a high-confidence conclusion is found.
- `getTerminationStatus()`: Returns the current termination status and reason
- `getBestConclusion()`: Returns the most reliable conclusion
### Parameter Descriptions
- **atomId**: Unique identifier for an atom (e.g., 'A1', 'H2')
- **content**: Actual content of the atom
- **atomType**: Type of atom (premise, reasoning, hypothesis, verification, conclusion)
- **dependencies**: List of IDs of other atoms this atom depends on
- **confidence**: Reliability of this atom (value between 0 and 1)
- **isVerified**: Whether this atom has been verified
- **depth**: Depth of this atom (level in the decomposition-contraction process)
### Usage
1. Understand the problem and define necessary premise atoms
2. Generate reasoning atoms based on premises
3. Generate hypothesis atoms based on reasoning
4. Generate verification atoms for hypotheses
5. Derive conclusion atoms based on verified hypotheses
6. Use decomposition as needed for deeper exploration
7. Present high-confidence conclusion atoms as final answers
### Comparison with Sequential Thinking (More Testing Needed)
Observed differences and performance characteristics when applying both thinking tools to the same subject:
#### Structural Differences
**Sequential Thinking:**
- Linear thinking process: Proceeds sequentially from one thought to the next
- Predicts the total number of thoughts in advance
- Each thought stage is built on the previous one
**Atom of Thoughts:**
- Non-linear, network structure: Multiple thought units (atoms) connected with dependencies
- Systematic structure based on atom types (premise, reasoning, hypothesis, verification, conclusion)
- Explicit evaluation of reliability for each atom
#### Comparison of Strengths
**Sequential Thinking Strengths:**
- Intuitive flow: Similar to natural human thinking process
- Simplicity: Simple structure for quick application to straightforward problems
- Flexibility: Can modify previous stages or change direction during the process
**Atom of Thoughts Strengths:**
- Reliability evaluation: Explicitly measures reliability for each thought
- Verification process: Systematic verification stages for hypothesis evaluation
- Dependency tracking: Clearly tracks which premises or reasoning affect specific conclusions
- Parallel processing: Can consider multiple thought atoms simultaneously
#### Efficiency and Accuracy
**Efficiency:**
- Sequential Thinking: More efficient for simple problems, thoughts progress quickly
- Atom of Thoughts: More efficient for complex problems but has initial overhead for systematic structure
**Accuracy:**
- Sequential Thinking: Potential for error accumulation as thoughts deepen
- Atom of Thoughts: Reduces error potential with verification stages and reliability evaluation, leading to more reliable conclusions
#### Suitability by Purpose
**Suitable for Sequential Thinking:**
- Simple or moderately complex problems
- Time-constrained situations
- Situations requiring natural storytelling or explanation
**Suitable for Atom of Thoughts:**
- Highly complex problems
- Situations requiring accuracy and reliability
- Hypotheses requiring verification from multiple perspectives
- Complex dependencies in reasoning
#### Conclusion
Both tools can enhance AI reasoning capabilities but are suited for different scenarios. Sequential Thinking is useful for intuitive and quick thinking processes, while Atom of Thoughts is more suitable for complex problems requiring systematic verification and high reliability.
### Command Tools (atomcommands)
Command tools for controlling the decomposition-contraction mechanism and automatic termination of Atom of Thoughts.
**Available Commands**:
1. **decompose**: Decomposes a specified atom into smaller sub-atoms.
- Required parameters: `atomId`
2. **complete_decomposition**: Completes an ongoing decomposition process.
- Required parameters: `decompositionId`
3. **termination_status**: Checks the current termination status of the AoT process.
4. **best_conclusion**: Retrieves the most reliable verified conclusion.
5. **set_max_depth**: Changes the maximum depth limit.
- Required parameters: `maxDepth`
### Installing via Smithery
To install Atom of Thoughts for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@kbsooo/mcp_atom_of_thoughts):
```bash
npx -y @smithery/cli install @kbsooo/mcp_atom_of_thoughts --client claude
```
