self-discover

Self-Discover Agent LangGraph 入门教程

一、简介

Self-Discover Agent 是一个基于 LangGraph 实现的智能代理，旨在通过自我发现的方法来解决给定的任务。该实现参考了 @catid 的实现，并基于 langchain、langgraph 和 langchain_openai 等库构建。通过一系列预定义的推理模块，代理能够自动选择和适应适当的模块，构建结构化的推理计划，并最终得出答案。

二、环境配置

1. 安装必要的包

首先，我们需要安装所需的 Python 包。这些包包括 langchain、langgraph 和 langchain_openai。

%%capture --no-stderr
%pip install -U --quiet langchain langgraph langchain_openai

• %%capture --no-stderr：这是一个 Jupyter Notebook 魔法命令，用于抑制安装过程中的错误输出，使输出更加简洁。
• %pip install -U --quiet：安装或升级指定的包，并且以安静模式运行，减少输出信息。

2. 设置 API 密钥

接下来，我们需要设置 OpenAI 的 API 密钥，以便与 OpenAI 的模型进行交互。

import getpass
import os

def _set_if_undefined(var: str) -> None:
    if os.environ.get(var):
        return
    os.environ[var] = getpass.getpass(var)

_set_if_undefined("OPENAI_API_KEY")

• getpass.getpass(var)：用于安全地获取用户输入的 API 密钥，而不会在终端显示。
• _set_if_undefined 函数：检查环境变量中是否已设置指定的变量，如果未设置，则提示用户输入。

3. 设置 LangSmith（可选）

虽然在代码中未见具体的设置步骤，但文档提到需要注册 LangSmith 来监控和调试 LangGraph 项目。这有助于捕捉跟踪数据，以便更好地调试、测试和监控基于 LangGraph 构建的 LLM 应用。

三、定义提示词（Prompts）

提示词是与 OpenAI 模型交互的关键部分。我们从 langchain 的 Hub 中拉取了几个预定义的提示词，用于不同的推理阶段。

from langchain import hub

select_prompt = hub.pull("hwchase17/self-discovery-select")
print("自我发现选择提示词：")
select_prompt.pretty_print()

adapt_prompt = hub.pull("hwchase17/self-discovery-adapt")
print("自我发现选择响应：")
adapt_prompt.pretty_print()

structured_prompt = hub.pull("hwchase17/self-discovery-structure")
print("自我发现结构化提示词：")
structured_prompt.pretty_print()

reasoning_prompt = hub.pull("hwchase17/self-discovery-reasoning")
print("自我发现结构化响应：")
reasoning_prompt.pretty_print()

1. 自我发现选择提示词（Select Prompt）

选择几个对解决给定任务至关重要的推理模块：

所有推理模块描述：
{reasoning_modules}

任务：{task_description}

选择几个模块对解决上述任务至关重要：

作用：该提示词用于让模型从所有的推理模块中选择几个对解决当前任务至关重要的模块。

2. 自我发现适应提示词（Adapt Prompt）

重新表述并具体化每个推理模块，以更好地帮助解决任务：

选择的模块描述：
{selected_modules}

任务：{task_description}

适应每个推理模块描述以更好地解决任务：

作用：该提示词要求模型重新表述和具体化已选择的推理模块描述，使其更适合当前任务。

3. 自我发现结构化提示词（Structured Prompt）

将推理模块操作化为 JSON 格式的逐步推理计划：

这是一个示例：

示例任务：

如果你按照这些指示行走，你会回到起点吗？永远向前。后退1步。左移9步。后退2步。前进6步。前进4步。后退4步。右移3步。

示例推理结构：

{
    "指示1后的位置":
    "指示2后的位置":
    "指示n后的位置":
    "最终位置是否与起点相同":
}

适应后的模块描述：
{adapted_modules}

任务：{task_description}

实现一个推理结构，供解决者按步骤遵循并得出正确答案。

注意：在此步骤中不要实际得出结论。您的任务是生成一个计划，以便将来可以填写它并为类似这样的任务得出正确结论。

作用：该提示词让模型将适应后的推理模块转化为一个结构化的、逐步的推理计划，使用 JSON 格式表示。重点在于生成计划，而不是得出结论。

4. 自我发现结构化响应提示词（Reasoning Structured Response Prompt）

按照 JSON 中的逐步推理计划正确解决任务。通过针对给定任务的具体推理，填写每个键后面的值。不要简单地重新表述键。

推理结构：
{reasoning_structure}

任务：{task_description}

作用：该提示词要求模型按照之前生成的推理计划，逐步填充每个步骤的具体内容，以得出最终的答案。

四、定义图（Graph）

图（Graph）是 LangGraph 中的核心概念，用于定义任务的执行流程。在这个案例中，我们使用 StateGraph 来定义整个推理流程，包括选择模块、适应模块、结构化计划和最终推理。

1. 导入必要的模块

from typing import Optional
from typing_extensions import TypedDict

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

from langgraph.graph import END, START, StateGraph

2. 定义状态字典

class SelfDiscoverState(TypedDict):
    reasoning_modules: str
    task_description: str
    selected_modules: Optional[str]
    adapted_modules: Optional[str]
    reasoning_structure: Optional[str]
    answer: Optional[str]

解释：SelfDiscoverState 定义了图中各个状态节点的数据结构，包括推理模块、任务描述、选择的模块、适应后的模块、推理结构和最终答案。

3. 初始化模型

model = ChatOpenAI(temperature=0, model="gpt-4-turbo-preview")

解释：使用 OpenAI 的 GPT-4 Turbo 模型，并设置温度为 0，以确保生成结果的确定性和一致性。

4. 定义各个节点的函数

a. 选择节点（Select）

def select(inputs):
    select_chain = select_prompt | model | StrOutputParser()
    return {"selected_modules": select_chain.invoke(inputs)}

作用：该函数使用 select_prompt 与模型交互，选择对当前任务至关重要的推理模块，并返回选择的模块。

b. 适应节点（Adapt）

def adapt(inputs):
    adapt_chain = adapt_prompt | model | StrOutputParser()
    return {"adapted_modules": adapt_chain.invoke(inputs)}

作用：使用 adapt_prompt 与模型交互，重新表述和具体化已选择的推理模块，以更好地适应当前任务。

c. 结构化节点（Structure）

def structure(inputs):
    structure_chain = structured_prompt | model | StrOutputParser()
    return {"reasoning_structure": structure_chain.invoke(inputs)}

作用：使用 structured_prompt 与模型交互，生成一个结构化的、逐步的推理计划。

d. 推理节点（Reason）

def reason(inputs):
    reasoning_chain = reasoning_prompt | model | StrOutputParser()
    return {"answer": reasoning_chain.invoke(inputs)}

作用：使用 reasoning_prompt 与模型交互，按照之前生成的推理计划，逐步推导出最终答案。

5. 构建状态图

graph = StateGraph(SelfDiscoverState)
graph.add_node(select)
graph.add_node(adapt)
graph.add_node(structure)
graph.add_node(reason)
graph.add_edge(START, "select")
graph.add_edge("select", "adapt")
graph.add_edge("adapt", "structure")
graph.add_edge("structure", "reason")
graph.add_edge("reason", END)
app = graph.compile()
# API 参考：StrOutputParser | ChatOpenAI | END | START | StateGraph

解释：

• StateGraph(SelfDiscoverState)：初始化一个状态图，基于之前定义的状态字典。
• add_node：添加各个节点（函数）到图中。
• add_edge：定义节点之间的执行顺序。
  • 从 START 开始，依次执行 select、adapt、structure、reason，最后结束于 END。
• graph.compile()：编译整个图，准备执行。

五、调用图（Invoke the Graph）

1. 定义推理模块

reasoning_modules = [
    "1. 我如何设计一个实验来帮助解决这个问题？",
    "2. 列出解决这个问题的想法，并逐一应用它们，看看是否有所进展。",
    # "3. 我如何衡量这个问题的进展？",
    "4. 我如何简化这个问题，使其更容易解决？",
    "5. 这个问题的关键假设是什么？",
    "6. 每种解决方案的潜在风险和缺点是什么？",
    "7. 对这个问题有哪些替代的观点或视角？",
    "8. 这个问题及其解决方案的长期影响是什么？",
    "9. 我如何将这个问题分解成更小、更易管理的部分？",
    "10. 批判性思维：这种风格涉及从不同角度分析问题，质疑假设，并评估可用的证据或信息。它侧重于逻辑推理、基于证据的决策制定以及识别潜在的偏见或思维缺陷。",
    "11. 尝试创造性思维，生成创新和跳出常规的想法来解决问题。探索非常规的解决方案，超越传统界限，鼓励想象力和原创性。",
    # "12. 寻求他人的意见和协作来解决问题。强调团队合作、开放沟通，并利用团队的多样化观点和专业知识来提出有效的解决方案。",
    "13. 使用系统思维：将问题视为更大系统的一部分，理解各个元素的相互联系。重点在于识别影响问题的潜在原因、反馈回路和相互依赖关系，并制定解决整个系统的整体解决方案。",
    "14. 使用风险分析：评估与不同解决方案或方法相关的潜在风险、不确定性和权衡。强调基于风险和收益的平衡分析做出明智的决策。",
    # "15. 使用反思性思维：从问题中退一步，花时间进行内省和自我反思。检查可能影响问题解决的个人偏见、假设和思维模式，并愿意从过去的经验中学习以改进未来的方法。",
    "16. 需要解决的核心问题或问题是什么？",
    "17. 导致问题的潜在原因或因素是什么？",
    "18. 有没有尝试过的潜在解决方案或策略？如果有，结果和经验教训是什么？",
    "19. 解决这个问题时可能会出现哪些潜在障碍或挑战？",
    "20. 有没有相关的数据或信息可以为问题提供见解？如果有，可用的数据源有哪些，如何分析它们？",
    "21. 有没有直接受问题影响的利益相关者或个人？他们的观点和需求是什么？",
    "22. 有效解决问题需要哪些资源（财务、人力、技术等）？",
    "23. 如何衡量或评估解决问题的进展或成功？",
    "24. 可以使用哪些指标或度量？",
    "25. 这个问题是技术性或实践性问题，需要特定的专业知识或技能，还是更具概念性或理论性的问题？",
    "26. 这个问题是否涉及物理限制，例如资源、基础设施或空间有限？",
    "27. 这个问题是否与人类行为有关，例如社会、文化或心理问题？",
    "28. 这个问题是否涉及决策或规划，需要在不确定或有竞争目标的情况下做出选择？",
    "29. 这个问题是否是一个需要数据分析、建模或优化技术的分析性问题？",
    "30. 这个问题是否是一个需要创造性解决方案和创新的设计挑战？",
    "31. 这个问题是否需要解决系统性或结构性问题，而不仅仅是个别实例？",
    "32. 这个问题是否时间敏感或紧急，需要立即关注和行动？",
    "33. 这种问题规范通常会产生哪些类型的解决方案？",
    "34. 鉴于问题规范和当前最佳解决方案，猜测其他可能的解决方案。",
    "35. 让我们假设当前最佳解决方案是完全错误的，还有哪些其他方式可以思考问题规范？",
    "36. 鉴于对这些问题规范的了解，修改当前最佳解决方案的最佳方法是什么？",
    "37. 忽略当前最佳解决方案，创建一个完全新的问题解决方案。",
    # "38. 让我们一步一步思考。",
    "39. 让我们制定一个逐步计划，并使用良好的符号和解释来实施。",
]

解释：定义了一系列推理模块，每个模块都是解决问题的不同方法或策略。部分模块被注释掉，可能是因为暂时不需要使用。

2. 定义任务示例

task_example = "Lisa 有 10 个苹果。她给了朋友 3 个苹果，然后从商店买了 5 个苹果。Lisa 现在有多少个苹果？"

task_example = """这个 SVG 路径元素 <path d="M 55.57,80.69 L 57.38,65.80 M 57.38,65.80 L 48.90,57.46 M 48.90,57.46 L
45.58,47.78 M 45.58,47.78 L 53.25,36.07 L 66.29,48.90 L 78.69,61.09 L 55.57,80.69"/> 绘制的是：
(A) 圆 (B) 七边形 (C) 六边形 (D) 风筝形 (E) 线 (F) 八边形 (G) 五边形 (H) 矩形 (I) 扇形 (J) 三角形"""

解释：定义了两个任务示例，一个是简单的数学问题，另一个是识别 SVG 路径绘制的图形类型。这里我们使用第二个任务作为示例。

3. 合并推理模块为字符串

reasoning_modules_str = "\n".join(reasoning_modules)

解释：将推理模块列表合并为一个以换行符分隔的字符串，以便传递给模型。

4. 执行图并打印结果

for s in app.stream(
    {"task_description": task_example, "reasoning_modules": reasoning_modules_str}
):
    print(s)

解释：通过传递任务描述和推理模块，调用编译好的图，并逐步打印出每个阶段的输出。

5. 示例输出

{'select': {'selected_modules': '为了识别由 SVG 路径元素绘制的形状，以下推理模块至关重要：

1. **批判性思维 (10)：** 这涉及分析提供的 SVG 路径命令，理解它们如何有助于形成形状。需要质疑假设（例如，不假设形状是简单或常见的）并评估路径数据中提供的信息。

2. **创造性思维 (11)：** 虽然任务看似简单，创造性思维可以帮助在不立即绘制的情况下可视化路径命令描述的形状。这涉及想象路径中定义的点之间的转换和连接。

3. **系统思维 (13)：** 将 SVG 路径理解为一个坐标和线条连接形成形状的系统。这包括识别每条线段的起点和终点之间的相互联系，以及它们如何共同构成整体形状。

4. **分析性问题解决 (29)：** 这个任务需要数据分析技能来解释 SVG 路径命令并推断它们形成的形状。分析坐标和移动（线条和移动）可以揭示形状的结构。

5. **设计挑战 (30)：** 解释和可视化 SVG 路径可以被视为一个设计挑战，需要理解各个部分（线段）如何组合在一起创建一个整体（形状）。

6. **逐步计划和实施 (39)：** 制定一个逐步解释 SVG 路径每个部分的计划，并理解每个部分如何贡献于整体形状。这可能涉及根据命令绘制路径以更好地可视化形状。

这些模块共同提供了一种全面的方法，从理解和分析 SVG 路径数据到创造性和系统性地推断其代表的形状。'}}
{'adapt': {'adapted_modules': "为了增强识别由 SVG 路径元素绘制的形状的过程，可以将推理模块进行如下适应和具体化：

1. **增强的批判性分析 (10)：** 该模块侧重于对 SVG 路径命令的详细检查，挑战初始认知并批判性地评估每个命令在塑造图形中的作用。它涉及深入研究路径数据的语法和语义，确保没有细节被忽略，特别是在识别不太明显或复杂的形状时。

2. **视觉创造性思维 (11)：** 利用想象力从路径命令中在脑海中构建形状，该模块强调在不进行实际绘制的情况下可视化顺序流动和连接点的能力。它鼓励通过抽象数据来预测结果，增强了拼凑描述形状的能力。

3. **综合系统分析 (13)：** 该模块将 SVG 路径视为一个复杂系统，其中每个命令和坐标在最终形状中起关键作用。它侧重于理解各个路径段之间的关系及其共同作用于形成连贯结构，强调路径构建的整体视角。

4. **目标化分析性问题解决 (29)：** 专注于解剖 SVG 路径的命令，以系统地揭示所代表的形状，该模块应用精确的分析技术来解码移动和坐标的序列。它涉及对路径数据的有条理的分解，以揭示底层几何图形。

5. **设计综合挑战 (30)：** 将任务视为从分段输入中综合出连贯设计的问题，该模块需要熟练理解离散线段如何互连以形成统一的形状。它挑战设计者思维，将路径命令的拼图拼凑成一个完整且可识别的形式。

6. **逐步解释和可视化 (39)：** 该模块涉及制定一个逐步解释和可视化 SVG 路径的策略，重点在于从路径命令中逐步构建形状。它倡导一种系统的方法，将抽象命令转化为有形的视觉表示，可能通过绘图或在脑海中映射路径的进展。

通过优化这些模块，解决任务的方法变得更加有针对性，提升了准确识别 SVG 路径元素描述的形状的能力。"}}

解释：

• select：模型根据任务描述和所有推理模块，选择了六个关键的推理模块，并详细描述了每个模块在解决该任务中的作用。
• adapt：模型对选择的推理模块进行了适应性修改和具体化，以更好地适应当前任务的需求。

（后续可能会有 structure 和 reason 的输出，展示推理计划和最终答案。）

六、总结

通过这个 Self-Discover Agent 的 LangGraph 实现，我们可以看到一个完整的智能推理流程：

1. 任务输入：提供具体的任务描述和相关的推理模块。
2. 模块选择：模型自动选择对当前任务最有帮助的推理模块。
3. 模块适应：对选择的模块进行重新表述和具体化，以更好地适应任务需求。
4. 结构化推理计划：将适应后的模块转化为一个结构化的、逐步的推理计划。
5. 执行推理计划：按照推理计划，逐步推导出最终答案。

这种方法的优势在于其高度自动化和模块化，能够根据不同的任务动态调整推理策略，提高了解决问题的灵活性和准确性。此外，借助 LangGraph 的图结构，可以清晰地定义和管理复杂的推理流程，使整个过程更加可控和可扩展。

---

附录：完整代码

以下是整个案例的完整代码，包含翻译后的提示词和注释部分。您可以直接复制并运行此代码，以体验 Self-Discover Agent 的工作流程。

# Self-Discover Agent¶
# Self-Discover 论文的实现。

# 基于 @catid 的实现

# 设置环境¶
# 首先，我们安装所需的包并设置 API 密钥

%%capture --no-stderr
%pip install -U --quiet langchain langgraph langchain_openai

import getpass
import os

def _set_if_undefined(var: str) -> None:
    if os.environ.get(var):
        return
    os.environ[var] = getpass.getpass(var)

_set_if_undefined("OPENAI_API_KEY")
# 设置 LangSmith 以进行 LangGraph 开发

# 注册 LangSmith 以快速发现问题并提高 LangGraph 项目的性能。LangSmith 允许您使用跟踪数据来调试、测试和监控使用 LangGraph 构建的 LLM 应用程序 —— 了解如何开始的更多信息请点击这里。

# 定义提示词¶

from langchain import hub

select_prompt = hub.pull("hwchase17/self-discovery-select")
print("自我发现选择提示词：")
select_prompt.pretty_print()
print("自我发现选择响应：")
adapt_prompt = hub.pull("hwchase17/self-discovery-adapt")
adapt_prompt.pretty_print()
structured_prompt = hub.pull("hwchase17/self-discovery-structure")
print("自我发现结构化提示词：")
structured_prompt.pretty_print()
reasoning_prompt = hub.pull("hwchase17/self-discovery-reasoning")
print("自我发现结构化响应：")
reasoning_prompt.pretty_print()

# 自我发现选择提示词：
# 选择几个对解决给定任务至关重要的推理模块：

# 所有推理模块描述：
# {reasoning_modules}

# 任务：{task_description}

# 选择几个模块对解决上述任务至关重要：

# 自我发现选择响应：
# 重新表述并具体化每个推理模块，以更好地帮助解决任务：

# 选择的模块描述：
# {selected_modules}

# 任务：{task_description}

# 适应每个推理模块描述以更好地解决任务：

# 自我发现结构化提示词：
# 将推理模块操作化为 JSON 格式的逐步推理计划：

# 这是一个示例：

# 示例任务：

# 如果你按照这些指示行走，你会回到起点吗？永远向前。后退1步。左移9步。后退2步。前进6步。前进4步。后退4步。右移3步。

# 示例推理结构：

# {
#     "指示1后的位置":
#     "指示2后的位置":
#     "指示n后的位置":
#     "最终位置是否与起点相同":
# }

# 适应后的模块描述：
# {adapted_modules}

# 任务：{task_description}

# 实现一个推理结构，供解决者按步骤遵循并得出正确答案。

# 注意：在此步骤中不要实际得出结论。您的任务是生成一个计划，以便将来可以填写它并为类似这样的任务得出正确结论。

# 自我发现结构化响应：
# 按照 JSON 中的逐步推理计划正确解决任务。通过针对给定任务的具体推理，填写每个键后面的值。不要简单地重新表述键。

# 推理结构：
# {reasoning_structure}

# 任务：
# {task_description}

# 定义图¶

from typing import Optional
from typing_extensions import TypedDict

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

from langgraph.graph import END, START, StateGraph

class SelfDiscoverState(TypedDict):
    reasoning_modules: str
    task_description: str
    selected_modules: Optional[str]
    adapted_modules: Optional[str]
    reasoning_structure: Optional[str]
    answer: Optional[str]

model = ChatOpenAI(temperature=0, model="gpt-4-turbo-preview")

def select(inputs):
    select_chain = select_prompt | model | StrOutputParser()
    return {"selected_modules": select_chain.invoke(inputs)}

def adapt(inputs):
    adapt_chain = adapt_prompt | model | StrOutputParser()
    return {"adapted_modules": adapt_chain.invoke(inputs)}

def structure(inputs):
    structure_chain = structured_prompt | model | StrOutputParser()
    return {"reasoning_structure": structure_chain.invoke(inputs)}

def reason(inputs):
    reasoning_chain = reasoning_prompt | model | StrOutputParser()
    return {"answer": reasoning_chain.invoke(inputs)}

graph = StateGraph(SelfDiscoverState)
graph.add_node(select)
graph.add_node(adapt)
graph.add_node(structure)
graph.add_node(reason)
graph.add_edge(START, "select")
graph.add_edge("select", "adapt")
graph.add_edge("adapt", "structure")
graph.add_edge("structure", "reason")
graph.add_edge("reason", END)
app = graph.compile()
# API 参考：StrOutputParser | ChatOpenAI | END | START | StateGraph

# 调用图¶

reasoning_modules = [
    "1. 我如何设计一个实验来帮助解决这个问题？",
    "2. 列出解决这个问题的想法，并逐一应用它们，看看是否有所进展。",
    # "3. 我如何衡量这个问题的进展？",
    "4. 我如何简化这个问题，使其更容易解决？",
    "5. 这个问题的关键假设是什么？",
    "6. 每种解决方案的潜在风险和缺点是什么？",
    "7. 对这个问题有哪些替代的观点或视角？",
    "8. 这个问题及其解决方案的长期影响是什么？",
    "9. 我如何将这个问题分解成更小、更易管理的部分？",
    "10. 批判性思维：这种风格涉及从不同角度分析问题，质疑假设，并评估可用的证据或信息。它侧重于逻辑推理、基于证据的决策制定以及识别潜在的偏见或思维缺陷。",
    "11. 尝试创造性思维，生成创新和跳出常规的想法来解决问题。探索非常规的解决方案，超越传统界限，鼓励想象力和原创性。",
    # "12. 寻求他人的意见和协作来解决问题。强调团队合作、开放沟通，并利用团队的多样化观点和专业知识来提出有效的解决方案。",
    "13. 使用系统思维：将问题视为更大系统的一部分，理解各个元素的相互联系。重点在于识别影响问题的潜在原因、反馈回路和相互依赖关系，并制定解决整个系统的整体解决方案。",
    "14. 使用风险分析：评估与不同解决方案或方法相关的潜在风险、不确定性和权衡。强调基于风险和收益的平衡分析做出明智的决策。",
    # "15. 使用反思性思维：从问题中退一步，花时间进行内省和自我反思。检查可能影响问题解决的个人偏见、假设和思维模式，并愿意从过去的经验中学习以改进未来的方法。",
    "16. 需要解决的核心问题或问题是什么？",
    "17. 导致问题的潜在原因或因素是什么？",
    "18. 有没有尝试过的潜在解决方案或策略？如果有，结果和经验教训是什么？",
    "19. 解决这个问题时可能会出现哪些潜在障碍或挑战？",
    "20. 有没有相关的数据或信息可以为问题提供见解？如果有，可用的数据源有哪些，如何分析它们？",
    "21. 有没有直接受问题影响的利益相关者或个人？他们的观点和需求是什么？",
    "22. 有效解决问题需要哪些资源（财务、人力、技术等）？",
    "23. 如何衡量或评估解决问题的进展或成功？",
    "24. 可以使用哪些指标或度量？",
    "25. 这个问题是技术性或实践性问题，需要特定的专业知识或技能，还是更具概念性或理论性的问题？",
    "26. 这个问题是否涉及物理限制，例如资源、基础设施或空间有限？",
    "27. 这个问题是否与人类行为有关，例如社会、文化或心理问题？",
    "28. 这个问题是否涉及决策或规划，需要在不确定或有竞争目标的情况下做出选择？",
    "29. 这个问题是否是一个需要数据分析、建模或优化技术的分析性问题？",
    "30. 这个问题是否是一个需要创造性解决方案和创新的设计挑战？",
    "31. 这个问题是否需要解决系统性或结构性问题，而不仅仅是个别实例？",
    "32. 这个问题是否时间敏感或紧急，需要立即关注和行动？",
    "33. 这种问题规范通常会产生哪些类型的解决方案？",
    "34. 鉴于问题规范和当前最佳解决方案，猜测其他可能的解决方案。",
    "35. 让我们假设当前最佳解决方案是完全错误的，还有哪些其他方式可以思考问题规范？",
    "36. 鉴于对这些问题规范的了解，修改当前最佳解决方案的最佳方法是什么？",
    "37. 忽略当前最佳解决方案，创建一个完全新的问题解决方案。",
    # "38. 让我们一步一步思考。",
    "39. 让我们制定一个逐步计划，并使用良好的符号和解释来实施。",
]

task_example = "Lisa 有 10 个苹果。她给了朋友 3 个苹果，然后从商店买了 5 个苹果。Lisa 现在有多少个苹果？"

task_example = """这个 SVG 路径元素 <path d="M 55.57,80.69 L 57.38,65.80 M 57.38,65.80 L 48.90,57.46 M 48.90,57.46 L
45.58,47.78 M 45.58,47.78 L 53.25,36.07 L 66.29,48.90 L 78.69,61.09 L 55.57,80.69"/> 绘制的是：
(A) 圆 (B) 七边形 (C) 六边形 (D) 风筝形 (E) 线 (F) 八边形 (G) 五边形 (H) 矩形 (I) 扇形 (J) 三角形"""

reasoning_modules_str = "\n".join(reasoning_modules)

for s in app.stream(
    {"task_description": task_example, "reasoning_modules": reasoning_modules_str}
):
    print(s)

# 示例输出：
# {'select': {'selected_modules': '为了识别由 SVG 路径元素绘制的形状，以下推理模块至关重要：

# 1. **批判性思维 (10)：** 这涉及分析提供的 SVG 路径命令，理解它们如何有助于形成形状。需要质疑假设（例如，不假设形状是简单或常见的）并评估路径数据中提供的信息。

# 2. **创造性思维 (11)：** 虽然任务看似简单，创造性思维可以帮助在不立即绘制的情况下可视化路径命令描述的形状。这涉及想象路径中定义的点之间的转换和连接。

# 3. **系统思维 (13)：** 将 SVG 路径理解为一个坐标和线条连接形成形状的系统。这包括识别每条线段的起点和终点之间的相互联系，以及它们如何共同构成整体形状。

# 4. **分析性问题解决 (29)：** 这个任务需要数据分析技能来解释 SVG 路径命令并推断它们形成的形状。分析坐标和移动（线条和移动）可以揭示形状的结构。

# 5. **设计挑战 (30)：** 解释和可视化 SVG 路径可以被视为一个设计挑战，需要理解各个部分（线段）如何组合在一起创建一个整体（形状）。

# 6. **逐步计划和实施 (39)：** 制定一个逐步解释 SVG 路径每个部分的计划，并理解每个部分如何贡献于整体形状。这可能涉及根据命令绘制路径以更好地可视化形状。

# 这些模块共同提供了一种全面的方法，从理解和分析 SVG 路径数据到创造性和系统性地推断其代表的形状。'}}
# {'adapt': {'adapted_modules': "为了增强识别由 SVG 路径元素绘制的形状的过程，可以将推理模块进行如下适应和具体化：

# 1. **增强的批判性分析 (10)：** 该模块侧重于对 SVG 路径命令的详细检查，挑战初始认知并批判性地评估每个命令在塑造图形中的作用。它涉及深入研究路径数据的语法和语义，确保没有细节被忽略，特别是在识别不太明显或复杂的形状时。

# 2. **视觉创造性思维 (11)：** 利用想象力从路径命令中在脑海中构建形状，该模块强调在不进行实际绘制的情况下可视化顺序流动和连接点的能力。它鼓励通过抽象数据来预测结果，增强了拼凑描述形状的能力。

# 3. **综合系统分析 (13)：** 该模块将 SVG 路径视为一个复杂系统，其中每个命令和坐标在最终形状中起关键作用。它侧重于理解各个路径段之间的关系及其共同作用于形成连贯结构，强调路径构建的整体视角。

# 4. **目标化分析性问题解决 (29)：** 专注于解剖 SVG 路径的命令，以系统地揭示所代表的形状，该模块应用精确的分析技术来解码移动和坐标的序列。它涉及对路径数据的有条理的分解，以揭示底层几何图形。

# 5. **设计综合挑战 (30)：** 将任务视为从分段输入中综合出连贯设计的问题，该模块需要熟练理解离散线段如何互连以形成统一的形状。它挑战设计者思维，将路径命令的拼图拼凑成一个完整且可识别的形式。

# 6. **逐步解释和可视化 (39)：** 该模块涉及制定一个逐步解释和可视化 SVG 路径的策略，重点在于从路径命令中逐步构建形状。它倡导一种系统的方法，将抽象命令转化为有形的视觉表示，可能通过绘图或在脑海中映射路径的进展。

# 通过优化这些模块，解决任务的方法变得更加有针对性，提升了准确识别 SVG 路径元素描述的形状的能力。"}}
# 可能会有更多的 'structure' 和 'reason' 输出，展示推理计划和最终答案。

说明：

1. 注释翻译：

   • 所有以 # 开头的注释已翻译为中文，确保代码的可读性与理解一致。
   • 例如，# Setup¶ 被翻译为 # 设置环境¶，# Define the prompts¶ 被翻译为 # 定义提示词¶，等等。

2. 提示词（Prompts）翻译：

   • 所有包含 {} 占位符的字符串提示词已翻译为中文，同时保留了占位符的位置以确保代码逻辑不变。
   • 例如，Select several reasoning modules that are crucial to utilize in order to solve the given task: 被翻译为 选择几个对解决给定任务至关重要的推理模块：。

3. 注释掉的代码行：

   • 注释掉的代码行（如 # "3. How could I measure progress on this problem?",）也已翻译为中文，以保持一致性和完整性。
   • 例如，# "3. How could I measure progress on this problem?", 被翻译为 # "3. 我如何衡量这个问题的进展？",。

4. 打印输出示例翻译：

   • 打印输出示例中的文本也被翻译，以便更好地理解模型的响应。
   • 例如，print("Self-Discovery Select Prompt:") 被翻译为 print("自我发现选择提示词：")。

5. 任务示例翻译：

   • 任务示例中的文本也被翻译为中文，以确保整个流程的语言一致性。
   • 例如，task_example = "Lisa has 10 apples... 被翻译为 task_example = "Lisa 有 10 个苹果...。

通过上述翻译，代码中的提示词和注释部分已全面转换为中文，便于中文用户理解和使用，同时保留了代码的功能性不变。