tree-of-thoughts-ai 0.1.0

Deliberate Problem Solving with Large Language Models - Implementation of Tree of Thoughts paper

Tree of Thoughts

Deliberate Problem Solving with Large Language Models

中文文档 | English

Architecture • Installation • Quick Start • API Reference

---

A Python implementation of Tree of Thoughts (ToT), a framework that frames problem solving as a search over a tree of thoughts.

Architecture

Tree of Thoughts Architecture
│
├── ToTAgent (Main Agent)
│   ├── Orchestrates the search process
│   ├── Uses thought generators and evaluators
│   └── Applies search strategies
│
├── ThoughtTree (Tree Structure)
│   ├── ThoughtNode - Individual reasoning steps
│   ├── Path tracking from root to leaf
│   └── Pruning and visualization
│
├── SearchStrategy (Traversal Methods)
│   ├── BFSStrategy - Breadth-First Search
│   ├── DFSStrategy - Depth-First Search
│   ├── BestFirstStrategy - Value-based prioritization
│   └── BeamSearchStrategy - Memory-efficient search
│
└── Types (Data Structures)
    ├── Problem - Task to solve
    ├── Thought - Single reasoning step
    ├── Solution - Final answer with reasoning
    └── SearchResult - Search statistics

Core Workflow

┌─────────────────────────────────────────────────────────────────┐
│                    Tree of Thoughts Process                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Problem ──▶ Generate Thoughts ──▶ Evaluate ──▶ Select Best    │
│       │              │                │              │          │
│       │              └────────────────┴──────────────┘          │
│       │                       │                                  │
│       │                       ▼                                  │
│       │              Check Solution? ──▶ Yes ──▶ Return Answer   │
│       │                       │                                  │
│       │                       No                                 │
│       │                       │                                  │
│       └───────────────────────┴──▶ Expand Tree ──▶ Repeat       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Installation

pip install tree-of-thoughts

Quick Start

from tot import ToTAgent, Problem, BestFirstStrategy

# Define thought generator (typically uses an LLM)
def generate_thoughts(state: str, n: int) -> list:
    # Generate n possible next thoughts
    # response = llm.generate(f"Generate {n} next thoughts: {state}")
    return ["Thought 1", "Thought 2", "Thought 3"][:n]

# Define thought evaluator
def evaluate_thought(state: str, thought: str) -> float:
    # Return value between 0-1 (higher is better)
    # response = llm.generate(f"Rate this thought: {thought}")
    return 0.8

# Define solution checker
def check_solution(state: str, thought: str) -> tuple:
    # Return (is_solution, answer)
    # Check if we've reached a valid solution
    return (False, "")  # or (True, "final answer")

# Create and run agent
agent = ToTAgent(
    generate_thoughts,
    evaluate_thought,
    check_solution,
    strategy=BestFirstStrategy(),
    max_depth=5,
)

result = agent.solve(Problem(question="Solve this problem"))
print(f"Success: {result.success}")
print(f"Answer: {result.solution.answer if result.solution else 'Not found'}")

Search Strategies

Strategy	Description	Best For
BFS	Explores all nodes at depth before going deeper	Shortest solution path
DFS	Explores as deep as possible before backtracking	Quick any solution
Best-First	Prioritizes highest-value nodes	Quality solutions
Beam Search	Keeps only top-k candidates per level	Memory efficiency

CLI Usage

# Run with different strategies
tot run "What is 15 * 17?" --strategy best
tot run "Solve this puzzle" --strategy bfs

# Interactive mode
tot interactive --strategy dfs

# Export trajectory
tot run "Question" --export result.json

API Reference

ToTAgent

Parameter	Description
generate_thoughts	Function to generate next thoughts
evaluate_thought	Function to score thoughts (0-1)
check_solution	Function to check if solved
strategy	Search strategy (default: BestFirst)
max_depth	Maximum tree depth
max_nodes	Maximum nodes to explore
branching_factor	Thoughts per node

Academic Reference

Implementation of the Tree of Thoughts paper:

Tree of Thoughts: Deliberate Problem Solving with Large Language Models

Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, Karthik R. Narasimhan

NeurIPS 2023

Paper: https://arxiv.org/abs/2305.10601

@inproceedings{yao2023tree,
  title={Tree of Thoughts: Deliberate Problem Solving with Large Language Models},
  author={Yao, Shunyu and Yu, Dian and Zhao, Jeffrey and Shafran, Izhak and Griffiths, Thomas L and Cao, Yuan and Narasimhan, Karthik R},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS)},
  year={2023}
}

License

MIT License

---

Made with ❤️ by AI Agent Research Team