智能体架构 -- 思维树架构，让AI学会多路探索

你有没有遇到过这种AI助手：当你问一个逻辑谜题，它要么直接给出正确答案，要么就彻底卡住，甚至给你一个荒谬的结论？就像问你“狼、山羊和卷心菜怎么过河”，它要么完美复述答案，要么就让你陷入“狼吃了羊，羊吃了菜”的死循环，毫无补救余地。

问题出在哪里？因为大多数AI的推理方式就像思维链（Chain of Thought），只有一条直线，一旦选错方向，就再也回不了头。而今天我们要介绍的思维树（Tree of Thoughts）架构，让AI学会“条条大路通罗马”——它会同时探索多条推理路径，评估每条路的可行性，砍掉死胡同，专注于最有希望的方向，直到找到真正的解决方案。

我们将通过一个经典谜题来实战演示：狼、山羊和卷心菜过河问题。你会看到，为什么思维链会偶尔“翻车”，而思维树却能有条不紊地构建出正确计划。更重要的是，我们将亲手用LangGraph实现这个智能体，让你掌握构建高可靠、强规划能力AI的秘籍。

推荐阅读：

智能体架构 -- 反思模式，让AI自己当代码审查员

智能体架构 -- 工具使用，秒变真·智能助手

智能体架构 -- ReAct，让AI学会“三思而后行”

智能体架构 -- 反思性元认知智能体，让AI学会“三省吾身”

智能体架构 -- 规划架构，让你的智能体效率翻倍！

智能体架构 -- 多智能体系统，组专家团队

智能体架构 -- 黑板系统，让专家团队动态协作

智能体架构 -- 情景记忆与语义记忆栈，让智能体真正“长脑子”

什么是思维树？

想象一下，你站在一个迷宫入口。思维链的做法是：闭上眼睛，凭直觉一条路走到底，撞墙了就认输。而思维树的做法是：每到岔路口，就停下来，探索所有可能的方向，标记哪些是死路，哪些看起来有希望，然后重点推进最有希望的那几条，必要时还可以回头重新选择。

技术定义：思维树是一种将问题解决建模为搜索树的推理框架。在每个决策点，智能体生成多个候选“想法”或下一步行动，通过一个“评判者”评估每个想法的可行性、进展和潜力，然后剪除无效或前景不佳的分支，扩展最有希望的路径。这个过程持续进行，直到找到目标状态。

工作流程

1. 分解：将复杂问题分解为一系列可管理的步骤或想法。
2. 想法生成：针对当前状态，同时生成多个潜在的下一步想法，在搜索树中创建分支。
3. 状态评估：每个新想法导向一个新状态，由评估函数判断：
• 有效性：这一步是否符合问题规则？（比如过河时狼和羊不能单独留下）
• 进展：这一步是否让我们更接近目标？
• 启发式：这条路径成功的可能性有多大？
4. 剪枝与扩展：无效或无前景的分支被剪除，然后从最有希望的活跃分支出发，重复想法生成过程。
5. 解决方案：重复直到达到目标状态，从根节点到目标节点的想法路径即为解决方案。

什么时候该用它？

思维树特别适合以下场景：

• 逻辑谜题与数学问题：如数独、过河谜题、旅行商问题等，规则明确，需要多步骤、非线性推理。
• 复杂规划：当任务涉及顺序操作、必须遵守约束条件时，例如规划一个包含多段行程、预算限制的旅行。
• 创意写作或代码生成：在确定最终方案前，先探索多个故事分支或实现策略，再择优录用。

优势与局限

• 优势：
• 鲁棒性强：系统性地探索问题空间，不容易卡在局部死胡同，相比单次推理更可靠。
• 处理组合爆炸：非常适合可能路径数量庞大、传统方法难以穷举的问题。
• 局限：
• 计算开销大：需要大量LLM调用和状态管理，速度和成本都比简单思维链高。
• 评估器依赖：搜索效果很大程度上取决于状态评估逻辑的质量。如果评估不准，可能误剪优质分支。

动手实战：用思维树解决“狼、山羊和卷心菜”谜题

让我们亲手搭建一个思维树智能体。我们将使用LangGraph来管理状态和流程，并用一个LLM来生成“有希望的下一步”，同时用环境规则来自动验证和剪枝。

阶段 0：准备工作

安装依赖，配置API密钥。这里我们使用Nebius提供的LLM服务，也可以用任何兼容OpenAI API的服务。

# !pip install -q -U langchain-nebius langchain langgraph rich python-dotenv

import os
import re
from typing import List, Dict, Any, Optional
from dotenv import load_dotenv
from collections import defaultdict

# Pydantic 用于数据建模
from pydantic import BaseModel, Field

# LangChain 组件
from langchain_nebius import ChatNebius
from langchain_core.prompts import ChatPromptTemplate

# LangGraph 组件
from langgraph.graph import StateGraph, END
from typing_extensions import TypedDict

# 美化打印
from rich.console import Console
from rich.markdown import Markdown
from rich.tree import Tree

# --- API 密钥和追踪设置 ---
load_dotenv()
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = "Agentic Architecture - Tree-of-Thoughts (Nebius)"

# 检查所需环境变量
required_vars = ["NEBIUS_API_KEY", "LANGCHAIN_API_KEY"]
for var in required_vars:
if var notin os.environ:
        print(f"⚠️ 环境变量 {var} 未设置。")

console = Console()
print("✅ 环境变量加载完成，追踪已启用。")

阶段 1：定义谜题环境

思维树需要一个定义良好的环境来运行。我们为狼、山羊和卷心菜问题定义：

• 状态表示：左岸和右岸有哪些物品，船在哪边。
• 验证规则：检查是否有物品被吃掉（即狼和羊单独在一起，或羊和菜单独在一起）。
• 目标状态：所有物品都到了右岸。
• 可能移动：从当前状态生成所有合法移动。

classPuzzleState(BaseModel):
"""狼、山羊和卷心菜谜题的状态表示。"""
    left_bank: set[str] = Field(default_factory=lambda: {"wolf", "goat", "cabbage"})
    right_bank: set[str] = Field(default_factory=set)
    boat_location: str = "left"
    move_description: str = "初始状态。"

defis_valid(self) -> bool:
"""检查当前状态是否有效（没有物品被吃掉）。"""
# 检查左岸
if self.boat_location == "right":
if"wolf"in self.left_bank and"goat"in self.left_bank:
returnFalse
if"goat"in self.left_bank and"cabbage"in self.left_bank:
returnFalse
# 检查右岸
if self.boat_location == "left":
if"wolf"in self.right_bank and"goat"in self.right_bank:
returnFalse
if"goat"in self.right_bank and"cabbage"in self.right_bank:
returnFalse
returnTrue

defis_goal(self) -> bool:
"""检查是否达到目标状态。"""
return self.right_bank == {"wolf", "goat", "cabbage"}

def__hash__(self):
# 使状态可哈希，用于检测循环
return hash((frozenset(self.left_bank), frozenset(self.right_bank), self.boat_location))

def__eq__(self, other):
return self.__hash__() == other.__hash__()

defget_possible_moves(state: PuzzleState) -> list[PuzzleState]:
"""从当前状态生成所有可能且有效的下一步状态。"""
    moves = []
    current_bank = state.left_bank if state.boat_location == "left"else state.right_bank

# 选项1：带一个物品过河
for item in current_bank:
        new_state = state.model_copy(deep=True)
if state.boat_location == "left":
            new_state.left_bank.remove(item)
            new_state.right_bank.add(item)
            new_state.boat_location = "right"
            new_state.move_description = f"带{item}到右岸。"
else:
            new_state.right_bank.remove(item)
            new_state.left_bank.add(item)
            new_state.boat_location = "left"
            new_state.move_description = f"带{item}回左岸。"
if new_state.is_valid():
            moves.append(new_state)

# 选项2：空船过河
    empty_move_state = state.model_copy(deep=True)
if state.boat_location == "left":
        empty_move_state.boat_location = "right"
        empty_move_state.move_description = "空船划到右岸。"
else:
        empty_move_state.boat_location = "left"
        empty_move_state.move_description = "空船划回左岸。"
if empty_move_state.is_valid():
        moves.append(empty_move_state)

return moves

print("✅ 谜题环境定义完成。")

阶段 2：用 LangGraph 实现思维树智能体

现在构建智能体本身。图的状态将跟踪所有活动路径（分支）。节点执行关键的思维树操作：

• 扩展路径：由LLM驱动的想法生成器。它查看每个活动路径的最后一个状态，并从所有合法移动中选择所有可能性（这里我们选择全部扩展，展示树结构）。
• 剪枝路径：状态评估器。移除进入无效状态或形成循环的路径。
• 检查解决方案：条件节点，判断是否有路径达到目标，若达到则终止。

llm = ChatNebius(model="mistralai/Mixtral-8x22B-Instruct-v0.1", temperature=0.4)

# LLM 移动选择的 Pydantic 模型（这里只作演示，实际我们扩展所有分支）
classMoveChoice(BaseModel):
    best_move_index: int = Field(description="从提供的可能移动列表中选择最佳移动的索引。")
    reasoning: str = Field(description="简要说明为什么这是最有希望的移动。")

# LangGraph 状态
classToTState(TypedDict):
    problem_description: str
    active_paths: List[List[PuzzleState]]  # 每条路径是 PuzzleState 对象的列表
    solution: Optional[List[PuzzleState]]   # 最终解决方案

# 图节点
definitialize_search(state: ToTState) -> Dict[str, Any]:
"""节点：设置搜索的初始状态。"""
    initial_puzzle_state = PuzzleState()
return {"active_paths": [[initial_puzzle_state]]}

defexpand_paths(state: ToTState) -> Dict[str, Any]:
"""想法生成器：为每个活动路径扩展所有可能的下一步。"""
    console.print("--- 🌱 正在扩展路径 ---")
    new_paths = []

for path in state['active_paths']:
        last_state = path[-1]
        possible_next_states = get_possible_moves(last_state)

ifnot possible_next_states:
continue# 此路径是死胡同

# 为每个合法移动生成新路径
for next_state in possible_next_states:
            new_paths.append(path + [next_state])

    console.print(f"[cyan]扩展至 {len(new_paths)} 条潜在路径。[/cyan]")
return {"active_paths": new_paths}

defprune_paths(state: ToTState) -> Dict[str, Any]:
"""状态评估器：剪除无效或包含循环的路径。"""
    console.print("--- ✂️ 正在剪枝路径 ---")
    pruned_paths = []
for path in state['active_paths']:
# 检查循环：如果最后一个状态在路径中先前出现过
if path[-1] in path[:-1]:
continue# 发现循环，剪除此路径

# get_possible_moves 已经确保有效性，这里额外检查循环即可
        pruned_paths.append(path)

    console.print(f"[green]剪枝至 {len(pruned_paths)} 条有效、无循环的路径。[/green]")
return {"active_paths": pruned_paths}

# 条件节点
defcheck_for_solution(state: ToTState) -> str:
"""检查是否有任何路径已达到目标。"""
for path in state['active_paths']:
if path[-1].is_goal():
            console.print("[bold green]🎉 找到解决方案！[/bold green]")
            state['solution'] = path  # 在状态中记录解决方案
return"solution_found"
return"continue_search"

# 构建图
workflow = StateGraph(ToTState)
workflow.add_node("initialize", initialize_search)
workflow.add_node("expand", expand_paths)
workflow.add_node("prune", prune_paths)

workflow.set_entry_point("initialize")
workflow.add_edge("initialize", "expand")
workflow.add_edge("expand", "prune")

workflow.add_conditional_edges(
"prune",
    check_for_solution,
    {
"solution_found": END,
"continue_search": "expand"
    }
)

tot_agent = workflow.compile()
print("✅ 思维树智能体图编译完成。")

阶段 3：对比测试

现在，我们让思维树智能体去解决谜题，并与简单的思维链（CoT）提示进行对比。

problem = """一个农夫想用一条船带着一只狼、一只山羊和一棵卷心菜过河。船一次只能载农夫和另外一件物品。农夫不在时，狼不能和山羊单独在一起，山羊不能和卷心菜单独在一起。农夫怎样才能把所有东西都安全地运到对岸？"""

console.print("--- 🌳 正在运行思维树智能体 ---")
# 递归限制防止图陷入无限循环
config = {"recursion_limit": 15}
final_state = tot_agent.invoke({"problem_description": problem}, config=config)

console.print("\n--- ✅ 思维树智能体解决方案 ---")
if final_state.get('solution'):
    solution_path = final_state['solution']
# 用 rich.Tree 可视化解决路径
    tree = Tree("[bold magenta]🐺 狼、山羊和卷心菜问题解决路径[/bold magenta]")
for i, state in enumerate(solution_path):
        tree.add(f"[green]{i+1}.[/green] {state.move_description}")
    console.print(tree)
else:
    console.print("[bold red]在步骤限制内未找到解决方案。[/bold red]")

console.print("\n--- 🤔 正在运行简单思维链智能体 ---")
cot_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位世界级的逻辑谜题解决者。请为用户谜题提供逐步解决方案。"),
    ("human", "{problem}")
])
cot_chain = cot_prompt | llm
cot_result = cot_chain.invoke({"problem": problem}).content
console.print(Markdown(cot_result))

结果分析：

• 思维链（CoT）：对于这个经典问题，一个足够强大的LLM通常能直接给出正确答案，因为它可能已经“背”过答案。但如果你稍作修改（比如物品名称换一下），它就可能犯逻辑错误，而且没有自我纠错机制。它的正确性依赖于记忆和模式匹配，而非真正的可验证推理。
• 思维树（ToT）：我们的智能体通过系统性、可验证的搜索找到了解决方案。从日志中可以看到，它不断扩展路径、剪除死胡同和循环，最终收敛到唯一可行的路径。即使LLM在某些分支上做出次优选择（比如把羊带回左岸看似倒退），智能体仍会保留这个分支，因为它在规则内是合法的，并且可能在后续步骤中变得必要。最终，它构建的路径保证符合问题规则，因为每一步都经过了环境验证。

思维树智能体的成功不靠运气或记忆，而是靠搜索算法的可靠性。这使得它成为处理高可靠性、强规划要求任务的理想选择。

写在最后

通过这次实战，我们看到了思维树架构如何让AI从“单线推理”升级为“多路探索”。它像一位优秀的棋手，不只考虑一步，而是推演多种可能，再择优落子。

核心回顾

1. 原理：思维树将问题转化为状态空间树，通过生成、评估、剪枝、扩展的循环，系统性地搜索解决方案。
2. 实践：我们利用LangGraph构建了针对“狼、山羊和卷心菜”谜题的思维树智能体，并亲眼见证了它如何有条不紊地找到答案。
3. 避坑：思维树虽然强大，但计算成本高，且依赖高质量的状态评估器。对于简单、路径唯一的问题，思维链可能更经济高效。

对于AI系统设计者而言，思维树是应对复杂规划任务的“重型武器”。它赋予了AI“试错”和“回溯”的能力，让可靠推理成为可能。

如果你要设计一个AI来帮你规划复杂的旅行（比如多城市、多交通方式、有预算和时间限制），你会选择思维树还是其他架构？为什么？或者，你遇到过哪些AI“死脑筋”的场景，让你觉得它需要“多想想”再回答？欢迎在评论区分享你的观察和思考！