首页 | 论文（COLM2024） | 博客 | Discord | @Maitrix.org

---

LLM Reasoners 是一个旨在利用先进算法提升大语言模型复杂推理能力的库。它提供以下功能：

• 前沿的推理算法

  该库提供了当前最先进的用于大语言模型推理的搜索算法，例如：

  • Reasoner Agent (Deng 等, 2025)
  • 推理时缩放与 PRM (Snell 等, 2024)
  • 规划式推理，MCTS (Hao 等, 2023)
  • 思维树，BFS (Yao 等, 2023)
  (显示更多支持的算法)

  • StructChem (Ouyang 等, 2023)
  • 思维链 (Wei 等, 2022)
  • 由简入繁提示 (Zhou 等, 2022)
  • 思维树，DFS (Yao 等, 2023)
  • 自评引导解码，束搜索 (Xie 等, 2023)
  • Grace 解码 (Khalifa 等, 2023)
  • Eurus (Yuan 等, 2024)
  • PromptAgent (Wang 等, 2023)
  • DRPO (Singla 等, 2024)

• 直观的可视化与解释：我们的库提供了一个可视化工具，帮助用户理解推理过程。即使是像蒙特卡洛树搜索这样复杂的推理算法，用户也只需一行 Python 代码就能轻松诊断并理解整个流程。示例请参见教程笔记本。

• 高效的 LLM 推理：通过集成高性能 LLM 推理框架SGLang，该库优化了高级推理技术的性能，其特点是结构化生成（请参阅此推文和示例）。我们还支持其他 LLM 后端，如 huggingface transformers、OpenAI API、Exllama、fairscale、llama.cpp 等。

• 严谨的实现与可复现性：我们在实现中优先考虑精确性和可靠性，确保我们的算法不仅是理论概念，更是可实际使用的工具。LLM Reasoners 中实现的所有方法都经过精心设计，忠实于其原始表述和性能。这为我们发表在 COLM2024 上的推理算法分析（arxiv.org/abs/2404.05221）提供了有力支撑。

  (可复现性的示例)

  • LLM Reasoners 已成功复现了思维树、引导解码和GRACE 解码在其官方实现中的表现。我们列出了这些论文中报告的结果以及从其官方仓库复现的结果供参考（†）。部分结果基于前 100 个示例的子集（*）。

  方法	基础 LLM	GSM8k
  引导解码†	CodeX (PAL)	0.80
  引导解码	CodeX (PAL)	0.83*

  方法	基础 LLM	24点游戏
  思维树†	GPT-3.5-turbo	0.22
  思维树	GPT-3.5-turbo	0.22

  方法	基础 LLM	GSM8k
  GRACE 解码†	Flan-T5-Large（微调版）	0.34
  GRACE 解码	Flan-T5-Large（微调版）	0.33*

新闻

• 2025年2月21日：我们已集成Deepseek R1（示例）。同时，请查看我们对R1搜索模式的分析（推文）。

• 2025年2月6日：我们非常高兴地推出ReasonerAgent——一个完全开源、开箱即用的智能体，它可以在网页浏览器中进行研究并回答您的问题🧐。请查看这篇推文，并在此处探索代码！

• 2025年1月31日：LLM Reasoners已集成SGLang。只需一行代码更改，即可享受100倍的速度提升！此外，还提供了如PRM引导搜索等用于推理时扩展的新应用。更多详情请参见此帖子。

• 2024年12月20日：我们现在已在基于BrowserGym的Web环境中支持规划算法（MCTS、DFS/BFS、束搜索），请查阅README以进行尝试！

（显示更多新闻）

• 2024年11月13日：我们集成了DRPO，这是一种在EMNLP 2024上发表的无需微调的对齐方法（链接）。

• 2024年7月10日：我们关于LLM Reasoners的论文已被COLM 2024接收！

• 2024年6月24日：PromptAgent现已加入LLM Reasoners！它可以帮助您为任务编写超详细的提示词（这里）。

• 2024年5月14日：请查看Eurus，这是一系列专为推理优化的LLM。借助LLM Reasoners，Eurus-RM可以轻松将Llama-8B在GSM8k上的得分从0.49提升至0.73📈（代码）。

• 2024年5月2日：我们首次集成了用于科学推理的推理方法StructChem! 欢迎在此处查看（链接）。

• 2024年4月22日：我们集成了Llama-3，并添加了额外的实用API（例如自定义EOS标记、计算似然度等）。

• 2024年4月8日：我们介绍LLM Reasoners的新论文现已发布！

• 2024年3月29日：Grace Decoding已被纳入！

• 2023年10月25日：关于LLM Reasoners可视化工具的视频教程现已上线。

• 2023年10月23日：通过规划进行推理的方法已被EMNLP 2023接收！请查看我们的论文，其中包含更新的结果和讨论！

库简介

我们将LLM推理算法抽象为三个关键组件：奖励函数、世界模型和搜索算法（详见我们的论文中的公式），分别对应库中的三个类：SearchConfig、WorldModel和SearchAlgorithm。此外，还有用于驱动其他模块的LLM API、用于评估或调试推理算法的Benchmark和Visualization（中间）。要实现针对特定领域的推理算法（一个Reasoner对象），用户可以继承SearchConfig和WorldModel类，并导入一个预实现的SearchAlgorithm。我们还在底部展示了一个使用LLM Reasoners通过RAP解决Blocksworld问题的具体示例。

快速导览

让我们来过一遍针对 Blocksworld 问题的推理代码。请注意，这段代码为了演示目的进行了简化（可在这里找到可运行的笔记本）。

第一步是定义世界模型：你需要在 init_state 中根据问题设置初始状态，在 is_terminal 中判断一个状态是否为终止状态，而最重要的是用 step 定义世界动力学：

from typing import NamedTuple
import utils
from reasoners import WorldModel, LanguageModel
import copy

BWState = str
BWAction = str

class BlocksWorldModel(WorldModel[BWState, BWAction]):
    def __init__(self,
                 base_model: LanguageModel,
                 prompt: dict) -> None:
        super().__init__()
        self.base_model = base_model
        self.prompt = prompt

    def init_state(self) -> BWState:
        # 从给定的问题中提取陈述
        # 例如：“红色方块是干净的，蓝色方块是干净的……”
        return BWState(utils.extract_init_state(self.example)) 

    def step(self, state: BWState, action: BWAction) -> tuple[BWState, dict]:
        # 调用 LLM 预测状态转移
        state = copy.deepcopy(state)
        # 加载 LLM 预测下一个状态的提示
        # 例如：“……我有 <state>, 如果我 <action>, 那么……”
        world_update_prompt = self.prompt["update"].replace("<state>", state).replace("<action>", action)
        world_output = self.base_model.generate([world_update_prompt],
                                    eos_token_id="\n", hide_input=True, temperature=0).text[0].strip()
        new_state = utils.process_new_state(world_output)
        # 到目前为止，我们已经得到了执行动作后的新的状态
        # 接下来的部分是为了加快奖励计算

        # 我们希望检查已满足子目标的比例，并将其作为奖励的一部分
        # 由于我们已经预测了新状态，因此可以在这里方便地进行检查
        goal_reached = utils.goal_check(utils.extract_goals(self.example, new_state))
        # 返回新的状态和附加字典（将传递给奖励函数）
        return new_state, {"goal_reached": goal_reached}

    def is_terminal(self, state: BWState) -> bool:
        # 定义终止状态的条件以停止搜索
        # 例如，所有子目标都已达成
        if utils.goal_check(utils.extract_goals(self.example), state.blocks_state) == 1:
            return True
        return False

然后，我们需要考虑如何搜索最优的推理链。这涉及到在给定状态时使用 get_actions 获取动作空间，以及最重要的作为推理指导的 reward 函数。对于蒙特卡洛树搜索，我们还可以额外定义一个 fast_reward 来加速展开阶段。

import utils
from world_model import BWState, BWAction
from reasoners import SearchConfig, LanguageModel
class BWConfig(SearchConfig):
    def __init__(self,
                 base_model: LanguageModel,
                 prompt: dict,
                 reward_alpha=0.5,
                 goal_reward_default=0.,
                 goal_reached_reward=100) -> None:
        super().__init__()
        self.base_model = base_model
        self.example = None
        self.prompt = prompt
        # 一些用于计算快速奖励或奖励的参数（如下文解释）
        self.reward_alpha = reward_alpha
        self.goal_reward_default = goal_reward_default
        self.goal_reached_reward = goal_reached_reward

    def get_actions(self, state: BWState) -> list[BWAction]:
        # 使用基于规则的函数提取所有合法动作
        return utils.generate_all_actions(state)

    def fast_reward(self, state: BWState, action: BWAction) -> tuple[float, dict]:
        # 构建上下文学习提示（类似于思维链推理中使用的提示）
        inputs = self.prompt["icl"].replace("<init_state>", state)\
            .replace("<goals>", utils.extract_goals(self.example))
        # 将候选动作连接到提示之后，并测试其对数似然
        intuition = self.base_model.get_loglikelihood(inputs, [inputs + action])[0]
        # 奖励是直觉与目标达成度的结合
        # 在快速奖励中，我们跳过目标达成度的计算，直接使用默认值
        fast_reward = intuition * self.reward_alpha + self.goal_reward_default * (1 - self.reward_alpha)
        # 缓存一些信息以便后续奖励计算（将传递到 `reward` 函数）
        details = {'intuition': intuition}
        return fast_reward, details

    def reward(self, state: BWState, action: BWAction,
               intuition: float = None,
               goal_reached: tuple[bool, float] = None) -> float:
        # 注意，`intuition`（在 `fast_reward` 中缓存）和 `goal_reached`（在 `step` 中缓存）会自动作为参数传递给这个奖励函数
        if goal_reached == 1:
            # 如果达到目标状态，我们将给予高额奖励
            goal_reward = self.goal_reached_reward
        else:
            # 否则，根据已满足子目标的比例分配奖励
            goal_reward = goal_reached
        #  Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielvereinbarung.
        Beliebtigkeit ist eine Kombination aus Intuition und Zielverein......## 快速导览
让我们来过一遍针对 Blocksworld 问题的推理代码。请注意，这段代码为了演示目的进行了简化（可在 [这里](demo.ipynb) 查看可运行的笔记本）。

第一步是定义世界模型：你需要在 `init_state` 中根据问题设置初始状态，在 `is_terminal` 中判断一个状态是否为终止状态，而最重要的是用 `step` 定义世界动力学：
```python
from typing import NamedTuple
import utils
from reasoners import WorldModel, LanguageModel
import copy

BWState = str
BWAction = str

class BlocksWorldModel(WorldModel[BWState, BWAction]):
    def __init__(self,
                 base_model: LanguageModel,
                 prompt: dict) -> None:
        super().__init__()
        self.base_model = base_model
        self.prompt = prompt

    def init_state(self) -> BWState:
        # 从给定的问题中提取陈述
        # 例如：“红色方块是干净的，蓝色方块是干净的……”
        return BWState(utils.extract_init_state(self.example)) 

    def step(self, state: BWState, action: BWAction) -> tuple[BWState, dict]:
        # 调用 LLM 预测状态转移
        state = copy.deepcopy(state)
        # 加载 LLM 预测下一个状态的提示
        # 例如：“……我有 <state>, 如果我 <action>, 那么……”
        world_update_prompt = self.prompt["update"].replace("<state>", state).replace("<action>", action)
        world_output = self.base_model.generate([world_update_prompt],
                                    eos_token_id="\n", hide_input=True, temperature=0).text[0].strip()
        new_state = utils.process_new_state(world_output)
        # 到目前为止，我们已经得到了执行动作后的新状态
        # 接下来的部分是为了加快奖励计算

        # 我们想检查已满足的子目标的比例，并将其作为奖励的一部分
        # 由于我们已经预测了新状态，因此可以在这里方便地进行检查
        goal_reached = utils.goal_check(utils.extract_goals(self.example, new_state))
        # 返回新的状态和附加字典（将传递给奖励函数）
        return new_state, {"goal_reached": goal_reached}

    def is_terminal(self, state: BWState) -> bool:
        # 定义终止状态的条件以停止搜索
        # 例如，所有子目标都已达成
        if utils.goal_check(utils.extract_goals(self.example), state.blocks_state) == 1:
            return True
        return False

然后，该考虑如何搜索最优的推理链了。这涉及到 get_actions 来获取给定状态下的动作空间，以及最重要的 reward 作为推理的指导。对于蒙特卡洛树搜索，我们还可以额外定义一个 fast_reward 来加速展开阶段。

import utils
from world_model import BWState, BWAction
from reasoners import SearchConfig, LanguageModel
class BWConfig(SearchConfig):
    def __init__(self,
                 base_model: LanguageModel,
                 prompt: dict,
                 reward_alpha=0.5,
                 goal_reward_default=0.,
                 goal_reached_reward=100) -> None:
        super().__init__()
        self.base_model = base_model
        self.example = None
        self.prompt = prompt
        # 一些用于计算快速奖励或奖励的参数（如下解释）
        self.reward_alpha = reward_alpha
        self.goal_reward_default = goal_reward_default
        self.goal_reached_reward = goal_reached_reward

    def get_actions(self, state: BWState) -> list[BWAction]:
        # 使用基于规则的函数提取所有合法动作
        return utils.generate_all_actions(state)

    def fast_reward(self, state: BWState, action: BWAction) -> tuple[float, dict]:
        # 构建上下文学习提示（类似于思维链推理中使用的提示）
        inputs = self.prompt["icl"].replace("<init_state>", state)\
            .replace("<goals>", utils.extract_goals(self.example))
        # 将候选动作连接到提示之后，并测试其对数似然
        intuition = self.base_model.get_loglikelihood(inputs, [inputs + action])[0]
        # 奖励是直觉与目标达成度的结合
        # 在快速奖励中，我们跳过目标达成度的计算，直接使用默认值
        fast_reward = intuition * self.reward_alpha + self.goal_reward_default * (1 - self.reward_alpha)
        # 缓存一些信息以便稍后计算奖励（将传递到 `reward` 函数）
        details = {'intuition': intuition}
        return fast_reward, details

    def reward(self, state: BWState, action: BWAction,
               intuition: float = None,
               goal_reached: tuple[bool, float] = None) -> float:
        # 注意，`intuition`（在 `fast_reward` 中缓存）和 `goal_reached`（在 `step` 中缓存）会自动作为参数传递给这个奖励函数
        if goal_reached == 1:
            # 如果达到目标状态，我们将给予高额奖励
            goal_reward = self.goal_reached_reward
        else:
            # 否则，根据已满足的子目标比例分配奖励
            goal_reward = goal_reached
        # 奖励是直觉与目标达成度的组合
        reward = intuition * self.reward_alpha + goal_reward * (1 - self.reward_alpha)
        # 返回奖励和附加字典（将在日志中保存以便后续可视化）
        return reward, {'intuition': intuition, 'goal_reached': goal_reached}

现在，我们已经准备好应用推理算法来解决问题了：

from reasoners.algorithm import MCTS
from reasoners.lm import LLaMAModel
from world_model import BlocksWorldModel
from search_config import BWConfig

llama_model = LLaMAModel(llama_ckpts, llama_size, max_batch_size=1)
with open(prompt_path) as f:
    prompt = json.load(f)
world_model = BlocksWorldModel(base_model=base_model, prompt=prompt)
config = BWConfig(base_model=llama_model, prompt=prompt)
# 保存每次迭代的历史以便可视化
search_algo = MCTS(output_trace_in_each_iter=True)
reasoner = Reasoner(world_model=world_model, search_config=config, search_algo=search_algo)
for i, example in enumerate(dataset):
    algo_output = reasoner(example)
    # 将 MCTS 结果保存为 pickle 文件
    with open(os.path.join(log_dir, 'algo_output', f'{resume + i + 1}.pkl'), 'wb') as f:
        pickle.dump(algo_output, f)

最后，我们可以轻松地可视化推理过程：

import pickle
from reasoners.visualization import visualize
with open("logs/bw_MCTS/xxx/algo_output/1.pkl", 'rb') as f:
    mcts_result = pickle.load(f)

from reasoners.visualization.tree_snapshot import NodeData
from reasoners.algorithm.mcts import MCTSNode

# 默认情况下，状态会与节点一起展示，而`SearchConfig.reward`中保存的奖励字典中的奖励则会与边一起展示。
# 我们也可以定义一个辅助函数来自定义可视化工具中显示的内容。
def blocksworld_node_data_factory(n: MCTSNode) -> NodeData:
    return NodeData({"积木状态": n.state.blocks_state if n.state else None,
                     "满足情况": n.fast_reward_details if n.fast_reward_details else "未展开"})
def blocksworld_edge_data_factory(n: MCTSNode) -> EdgeData:
    return EdgeData({"奖励": n.reward, "直觉": n.fast_reward_details["intuition"]})
visualize(mcts_result, node_data_factory=blocksworld_node_data_factory,
                       edge_data_factory=blocksworld_edge_data_factory)

随后会弹出一个可视化结果的URL链接。该图像是交互式的，外观类似于我们在演示网站上展示的示例。

安装

请确保使用 Python 3.10 或更高版本。

conda create -n reasoners python=3.10
conda activate reasoners

通过 pip 安装

pip install llm-reasoners

从 GitHub 安装

（如果您想运行 GitHub 仓库中的示例，推荐此方法）

git clone https://github.com/Ber666/llm-reasoners --recursive
cd llm-reasoners
pip install -e .

添加 --recursive 参数将帮助您自动克隆 exllama 和 LLM-Planning。请注意，其他一些可选模块可能需要额外的依赖项，请根据错误信息进行处理。

引用

本项目是以下论文的扩展：

@inproceedings{hao2023reasoning,
  title={利用语言模型进行推理即为基于世界模型的规划},
  author={Hao, Shibo and Gu, Yi and Ma, Haodi and Hong, Joshua and Wang, Zhen and Wang, Daisy and Hu, Zhiting},
  booktitle={2023年自然语言处理经验方法会议论文集},
  pages={8154--8173},
  year={2023}
}
@article{hao2024llm,
  title={LLM Reasoners：大型语言模型逐步推理的新评估、库及分析},
  author={Hao, Shibo and Gu, Yi and Luo, Haotian and Liu, Tianyang and Shao, Xiyan and Wang, Xinyuan and Xie, Shuhua and Ma, Haodi and Samavedhi, Adithya and Gao, Qiyue and others},
  journal={arXiv 预印本 arXiv:2404.05221},
  year={2024}
}

LLM Reasoners 快速上手指南

LLM Reasoners 是一个旨在通过先进算法增强大语言模型（LLM）复杂推理能力的开源库。它集成了思维链（CoT）、思维树（ToT）、蒙特卡洛树搜索（MCTS）等多种前沿推理算法，并提供直观的可视化调试工具和高性能的 SGLang 后端支持。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统: Linux (推荐 Ubuntu 20.04+) 或 macOS。Windows 用户建议使用 WSL2。
• Python 版本: Python 3.9 或更高版本。
• 硬件要求:
  • 若使用本地模型推理，建议配备 NVIDIA GPU (显存取决于模型大小，运行 7B 模型建议至少 16GB)。
  • 若仅调用 OpenAI API 等云端服务，对本地硬件无特殊要求。
• 前置依赖:
  • git
  • pip
  • (可选) CUDA Toolkit (如需编译特定算子或使用 SGLang 加速)

安装步骤

1. 克隆仓库

首先从 GitHub 克隆项目代码：

git clone https://github.com/maitrix-org/llm-reasoners.git
cd llm-reasoners

2. 创建虚拟环境并安装依赖

推荐使用 conda 或 venv 创建隔离环境：

# 使用 conda 创建环境
conda create -n reasoners python=3.10 -y
conda activate reasoners

# 安装核心依赖
pip install -e .

注意：如果您计划使用 SGLang 进行高性能推理加速，请参考 SGLang 官方文档 单独安装其对应版本的依赖，因为 SGLang 对环境有特定的 CUDA 要求。

3. 配置模型后端

本库支持多种后端，您可以根据需求选择：

• OpenAI API: 无需额外安装，只需设置环境变量 OPENAI_API_KEY。
• Hugging Face Transformers / Exllama / llama.cpp: 需安装对应的 Python 包（通常 pip install -e . 已包含基础支持，特定量化后端可能需要额外指令）。
• SGLang: 需独立部署 SGLang 服务。

基本使用

LLM Reasoners 将推理算法抽象为三个核心组件：WorldModel (世界模型)、SearchConfig (搜索配置) 和 SearchAlgorithm (搜索算法)。

以下是一个简化的示例，展示如何定义一个“积木世界”（Blocksworld）的推理任务并使用 MCTS 算法求解。

1. 定义世界模型 (WorldModel)

世界模型负责定义状态初始化、状态转移（Step）和终止条件。

from typing import NamedTuple
import utils
from reasoners import WorldModel, LanguageModel
import copy

# 定义状态和动作类型
BWState = str
BWAction = str

class BlocksWorldModel(WorldModel[BWState, BWAction]):
    def __init__(self, base_model: LanguageModel, prompt: dict) -> None:
        super().__init__()
        self.base_model = base_model
        self.prompt = prompt

    def init_state(self) -> BWState:
        # 从问题中提取初始状态
        return BWState(utils.extract_init_state(self.example)) 

    def step(self, state: BWState, action: BWAction) -> tuple[BWState, dict]:
        # 调用 LLM 预测状态转移
        state = copy.deepcopy(state)
        world_update_prompt = self.prompt["update"].replace("<state>", state).replace("<action>", action)
        
        # 生成新状态
        world_output = self.base_model.generate(
            [world_update_prompt],
            eos_token_id="\n", 
            hide_input=True, 
            temperature=0
        ).text[0].strip()
        
        new_state = utils.process_new_state(world_output)
        
        # 计算部分奖励所需的信息 (如子目标达成情况)
        goal_reached = utils.goal_check(utils.extract_goals(self.example, new_state))
        
        return new_state, {"goal_reached": goal_reached}

    def is_terminal(self, state: BWState) -> bool:
        # 判断是否达到终止状态 (所有子目标完成)
        if utils.goal_check(utils.extract_goals(self.example), state) == 1:
            return True
        return False

2. 定义搜索配置 (SearchConfig)

配置搜索空间（动作生成）和奖励函数（Reward），用于指导搜索方向。

from reasoners import SearchConfig

class BWConfig(SearchConfig):
    def __init__(self, base_model: LanguageModel, prompt: dict, reward_alpha=0.5) -> None:
        super().__init__()
        self.base_model = base_model
        self.prompt = prompt
        self.reward_alpha = reward_alpha

    def get_actions(self, state: BWState) -> list[BWAction]:
        # 让 LLM 生成当前状态下可能的动作列表
        prompt = self.prompt["get_actions"].replace("<state>", state)
        output = self.base_model.generate([prompt], temperature=0).text[0]
        return utils.parse_actions(output)

    def reward(self, state: BWState, **kwargs) -> float:
        # 定义奖励函数，结合最终结果和中间过程奖励
        goal_reached = kwargs.get("goal_reached", False)
        if goal_reached:
            return 100.0
        # 这里可以添加基于启发式的中间奖励
        return 0.0

3. 运行搜索算法

实例化组件并启动搜索（以 MCTS 为例）。

from reasoners.algorithm import MCTS
from reasoners.lm import OpenAIModel # 或其他后端，如 HuggingFaceModel

# 1. 初始化基座模型
llm = OpenAIModel(model="gpt-3.5-turbo") 

# 2. 准备提示词 (需根据具体任务定义)
prompts = {
    "update": "...", 
    "get_actions": "...",
    # 其他必要提示词
}

# 3. 实例化组件
world_model = BlocksWorldModel(base_model=llm, prompt=prompts)
search_config = BWConfig(base_model=llm, prompt=prompts)
search_algo = MCTS(max_depth=10, n_iterations=20)

# 4. 执行推理
# example 是你的具体任务输入数据
result = search_algo(world_model, search_config, example="your_blocksworld_problem_data")

# 5. 获取最佳推理路径
best_trajectory = result.best_trajectory
print("Best reasoning chain:", best_trajectory)

4. 可视化调试

LLM Reasoners 提供了一行代码即可生成的可视化工具，帮助理解复杂的搜索过程（如 MCTS 树结构）：

# 在 notebook 或脚本中调用
result.visualize() 
# 这将生成一个可在浏览器中打开的链接，展示完整的推理树和节点得分

更多详细示例和完整可运行代码，请参阅仓库中的 demo.ipynb 或 examples/ 目录下的具体算法实现（如 examples/RAP, examples/ToT）。