Thought (思考)： 这是智能体的“内心独白”。它会分析当前情况、分解任务、制定下一步计划，或者反思上一步的结果。
Action (行动)： 这是智能体决定采取的具体动作，通常是调用一个外部工具，例如 Search['华为最新款手机']。
Observation (观察)： 这是执行Action后从外部工具返回的结果，例如搜索结果的摘要或API的返回值。

（1）ReAct 的主要特点
1.1 高可解释性：ReAct 最大的优点之一就是透明。
通过 Thought 链，我们可以清晰地看到智能体每一步的“心路历程”——它为什么会选择这个工具，下一步又打算做什么。
这对于理解、信任和调试智能体的行为至关重要。

1.2 动态规划与纠错能力：与一次性生成完整计划的范式不同，ReAct 是“走一步，看一步”。
它根据每一步从外部世界获得的 Observation 来动态调整后续的 Thought 和 Action。
如果上一步的搜索结果不理想，它可以在下一步中修正搜索词，重新尝试。

1.3 工具协同能力：ReAct 范式天然地将大语言模型的推理能力与外部工具的执行能力结合起来。
LLM 负责运筹帷幄（规划和推理），工具负责解决具体问题（搜索、计算），二者协同工作，突破了单一 LLM 在知识时效性、计算准确性等方面的固有局限。


（2）ReAct 的固有局限性
2.1 对LLM自身能力的强依赖：ReAct 流程的成功与否，高度依赖于底层 LLM 的综合能力。
如果 LLM 的逻辑推理能力、指令遵循能力或格式化输出能力不足，就很容易在 Thought 环节产生错误的规划，或者在 Action 环节生成不符合格式的指令，导致整个流程中断。

2.2 执行效率问题：由于其循序渐进的特性，完成一个任务通常需要多次调用 LLM。
每一次调用都伴随着网络延迟和计算成本。
对于需要很多步骤的复杂任务，这种串行的“思考-行动”循环可能会导致较高的总耗时和费用。

2.3 提示词的脆弱性：整个机制的稳定运行建立在一个精心设计的提示词模板之上。
模板中的任何微小变动，甚至是用词的差异，都可能影响 LLM 的行为。
此外，并非所有模型都能持续稳定地遵循预设的格式，这增加了在实际应用中的不确定性。

2.4 可能陷入局部最优：步进式的决策模式意味着智能体缺乏一个全局的、长远的规划。
它可能会因为眼前的 Observation 而选择一个看似正确但长远来看并非最优的路径，甚至在某些情况下陷入“原地打转”的循环中。

1. 检查完整的提示词：
在每次调用 LLM 之前，将最终格式化好的、包含所有历史记录的完整提示词打印出来。这是追溯 LLM 决策源头的最直接方式。

2. 分析原始输出：
当输出解析失败时（例如，正则表达式没有匹配到 Action），务必将 LLM 返回的原始、未经处理的文本打印出来。这能帮助你判断是 LLM 没有遵循格式，还是你的解析逻辑有误。

3. 验证工具的输入与输出：
检查智能体生成的 tool_input 是否是工具函数所期望的格式，同时也要确保工具返回的 observation 格式是智能体可以理解和处理的。

4. 调整提示词中的示例 (Few-shot Prompting)：
如果模型频繁出错，可以在提示词中加入一两个完整的“Thought-Action-Observation”成功案例，通过示例来引导模型更好地遵循你的指令。

5. 尝试不同的模型或参数：
更换一个能力更强的模型，或者调整 temperature 参数（通常设为0以保证输出的确定性），有时能直接解决问题。

1. 规划阶段 (Planning Phase)： 首先，智能体会接收用户的完整问题。
它的第一个任务不是直接去解决问题或调用工具，而是将问题分解，并制定出一个清晰、分步骤的行动计划。这个计划本身就是一次大语言模型的调用产物。

2. 执行阶段 (Solving Phase)： 在获得完整的计划后，智能体进入执行阶段。
它会严格按照计划中的步骤，逐一执行。
每一步的执行都可能是一次独立的 LLM 调用，或者是对上一步结果的加工处理，直到计划中的所有步骤都完成，最终得出答案。

PLANNER_PROMPT_TEMPLATE = """
你是一个顶级的AI规划专家，你的任务是讲用户提出的复杂问题分解成一个由多个简单步骤组成的行动计划。
请确保计划中的每个步骤都是一个独立的、可执行的子任务，并且严格按照逻辑顺序排列。
你的输出必须是Python列表，其中每个元素都是一个描述子任务的字符串。

问题: {question}

请严格按照以下格式输出你的计划,```python与```作为前后缀是必要的：
```python
["步骤1","步骤2","步骤3", ...]
```
"""

from llm_client import HelloAgentsLLM
import ast
class Planner:
    def __init__(self,llm_client:HelloAgentsLLM):
        self.llm_client = llm_client

    def plan(self,question: str)-> list[str]:
        """
        根据用户问题生成一个行动计划
        """
        prompt = PLANNER_PROMPT_TEMPLATE.format(question=question)

        # 为了生成计划，构造一个简单的消息列表
        messages=[{"role":"user","content": prompt}]
        
        print("--- 正在生成计划 ---")
        # 使用流失输出来获取完整的计划
        response_text = self.llm_client.think(messages=messages) or ""

        print(f"✅ 计划已生成:\n{response_text}")

        # 解析LLM输出的列表字符串
        try:
            # 找到```python和```之间的内容
            plan_str = response_text.split("```python")[1].split("```")[0].strip()
            # 使用ast.literal_eval来安全地执行字符串，将其转化为python列表
            plan = ast.literal_eval(plan_str)
            return plan if isinstance(plan,list) else []
        except (ValueError,SyntaxError,IndexError) as e:
            print(f"❌ 解析计划时出错: {e}")
            print(f"原始响应: {response_text}")
            return []
        except Exception as e:
            print(f"❌ 解析计划时出错: {e}")

EXECUTOR_PROMPT_TEMPLATE = """
你是一位顶级的AI执行专家，你的任务是严格按照给定的计划，一步步地解决问题。
你将收到原始的问题、完整的计划、以及到目前为止已经完成的步骤和结果。
请你专注于解决"当前步骤"，并仅输出该步骤的最终答案，不要输出任何额外的解释或对话。

# 原始问题:
{question}

# 完整计划:
{plan}

# 历史步骤与结果:
{history}

# 当前步骤:
{current_step}

请仅输出针对"当前步骤"的回答:
"""

class Executor:
    def __init__(self,llm_client:HelloAgentsLLM):
        self.llm_client = llm_client

    def execute(self,question: str,plan: list[str])-> str:
        """
        根据计划，逐步执行并解决问题。
        """
        history = "" #用于存储历史步骤和结果的字符串
        
        print("\n--- 正在执行计划 ---")

        for i, step in enumerate(plan):
            print(f"\n-> 正在执行步骤 {i+1}/{len(plan)}: {step}")

            prompt = EXECUTOR_PROMPT_TEMPLATE.format(
                question=question,
                plan=plan,
                history=history,
                current_step=step
            )
            messages = [{"role":"user","content":prompt}]

            response_text = self.llm_client.think(messages=messages) or ""

            #更新历史记录，为下一步做准备
            history += f"步骤 {i+1}: {step}\n结果: {response_text}\n\n"

            print(f"✅ 步骤 {i+1} 已完成，结果: {response_text}")

        # 循环结束后，最后一步的响应就是最终答案
        final_answer = response_text
        return final_answer
    
class PlanAndSolveAgent:
    def __init__(self,llm_client:HelloAgentsLLM):
        """
        初始化智能体，同时创建规划器和执行器实例。
        """
        self.llm_client = llm_client
        self.planner = Planner(self.llm_client)
        self.executor = Executor(self.llm_client)

    def run(self,question: str):
        """
        运行智能体的完整流程：先规划，后执行。
        """
        print(f"\n--- 开始处理问题 ---\n 问题: {question}")

        # 1. 调用规划器生成计划
        plan = self.planner.plan(question)

        # 检查计划是否成功生成
        if not plan:
            print("\n--- 任务终止 --- \n无法生成有效的行动计划")
            return
        
        # 2. 调用执行器执行计划
        final_answer = self.executor.execute(question,plan)

        print(f"\n--- 任务完成 ---\n最终答案: {final_answer}")

if __name__ == "__main__":
    question = "一个水果店一周卖出了15个苹果。周二卖出的苹果数量是周一的两倍。周三卖出的数量比周二少了5个。请问这三天总共卖出了多少个苹果？"
    llm = HelloAgentsLLM()
    plan_and_solve_agent = PlanAndSolveAgent(llm)
    plan_and_solve_agent.run(question)

1. 执行 (Execution)：
首先，智能体使用我们熟悉的方法（如 ReAct 或 Plan-and-Solve）尝试完成任务，生成一个初步的解决方案或行动轨迹。这可以看作是“初稿”。

2. 反思 (Reflection)：
接着，智能体进入反思阶段。它会调用一个独立的、或者带有特殊提示词的大语言模型实例，来扮演一个“评审员”的角色。
这个“评审员”会审视第一步生成的“初稿”，并从多个维度进行评估，例如：
事实性错误：是否存在与常识或已知事实相悖的内容？
逻辑漏洞：推理过程是否存在不连贯或矛盾之处？
效率问题：是否有更直接、更简洁的路径来完成任务？
遗漏信息：是否忽略了问题的某些关键约束或方面？ 根据评估，它会生成一段结构化的反馈 (Feedback)，指出具体的问题所在和改进建议。

3. 优化 (Refinement)：
最后，智能体将“初稿”和“反馈”作为新的上下文，再次调用大语言模型，
要求它根据反馈内容对初稿进行修正，生成一个更完善的“修订稿”。

    from typing import List,Dict,Any,Optional

    class Memory:
        """
        一个简单的短期记忆模块，用于存储智能体的行动与反思轨迹。
        """
        def __init__(self):
            """
            初始化一个空列表来存储所有记录。
            """
            self.records: List[Dict[str,Any]] = []

        def add_record(self, record_type:str,content: str):
            """
            向记忆中添加一条新纪录。

            参数:
            - record_type (str): 记录的类型('execution'或'reflection').
            - content (str): 记录的具体内容（例如，生成的代码或反思的反馈）。
            """
            record = {"type": record_type,"content":content}
            self.records.append(record)
            print(f"📝 记忆已更新，新增一条 '{record_type}' 记录。")

        def get_trajectory(self)->str:
            """
            将所有记录格式化为一个连贯的字符串文本，用于构建提示词
            """
            trajectory_parts = []
            for record in self.records:
                if record['type'] == 'execution':
                    trajectory_parts.append(f"--- 上一轮尝试（代码）---\n{record['content']}")
                elif record['type'] == 'reflection':
                    trajectory_parts.append(f"--- 评审员反馈 ---\n{record['content']}")

            return "\n\n".join(trajectory_parts)
        
        def get_last_execution(self)-> Optional[str]:
            """
            获取最近一次的执行结果（例如，最新生成的代码）。
            如果不存在，则返回None
            """
            for record in reversed(self.records):
                if record['type'] == 'execution':
                    return record['content']
            return None

    INITIAL_PROPMPT_TEMPLATE = """
    你是一位资深的Python程序员。请根据以下要求，编写一个Python函数。
    你的代码必须包含完整的函数签名、文档字符串，并遵循PEP 8编码规范。

    要求： {task}

    请直接输出代码，不要包含任何额外的解释
    """

    REFLECT_PROMPT_TEMPLATE = """
    你是一位极其严格的代码评审专家和资深算法工程师，对代码的性能有极致的要求。
    你的任务是审查以下Python代码，并专注于找出其在<strong>算法效率</strong>上的主要瓶颈。

    # 原始任务：
    {task}

    # 待审查的代码:
    ```pythobn
    {code}
    ```

    请分析该代码的时间复杂度，并思考是否存在一种<strong>算法上更有</strong>的解决方案来显著提升性能。
    如果存在，请清晰地指出当前算法的不足，并提出具体的、可行的改进算法建议（例如，使用筛法替代试除法）。
    如果代码在算法层面已经达到最优，才能回答"无需改进"。

    请直接输出你的反馈，不要包含任何额外的解释。
    """

    REFINE_PROMPT_TEMPLATE = """
    你是一位资深的Python程序员。你正在根据一位代码评审专家的反馈来优化你的代码。

    # 原始任务：
    {task}

    # 你上一轮尝试的代码：
    {last_code_attempt}
    # 评审员反馈：
    {feedback}

    请根据评审员的反馈，生成一个优化后的新版本代码。
    你的代码必须包含完整的函数签名、文档字符串，并遵循PEP 8编码规范。
    请直接输出优化后的代码，不要包含任何额外的解释。
    """

    from llm_client import HelloAgentsLLM

    class ReflectionAgent:
        def __init__(self,llm_client:HelloAgentsLLM,max_iterations=3):
            self.llm_client = llm_client
            self.memory = Memory()
            self.max_iterations = max_iterations

        def _get_llm_response(self,prompt:str)-> str:
            """一个辅助方法，用于调用LLM并获取完整的流失响应。"""
            messages = [{"role":"user","content": prompt}]
            response_text = self.llm_client.think(messages=messages) or ""
            return response_text

        def run(self,task: str):
            print(f"\n--- 开始处理任务 ---\n任务：{task}")

            # --- 1. 初始执行 ---
            print("\n--- 正在进行初始尝试 ---")
            initial_prompt = INITIAL_PROPMPT_TEMPLATE.format(task=task)
            initial_code = self._get_llm_response(initial_prompt)
            self.memory.add_record("execution",initial_code)

            # --- 2. 迭代循环：反思与优化 ---
            for i in range(self.max_iterations):
                print(f"\n--- 第 {i+1}/{self.max_iterations} 轮迭代 ---")

                # a. 反思
                print("\n-> 正在进行反思...")
                last_code = self.memory.get_last_execution()
                reflect_prompt = REFLECT_PROMPT_TEMPLATE.format(task=task,code=last_code)
                feedback = self._get_llm_response(reflect_prompt)
                self.memory.add_record("reflection",feedback)

                # b. 检查是否需要停止:
                if "无需改进" in feedback:
                    print("\n✅ 反思认为代码已无需改进，任务完成。")
                    break

                # c. 优化
                print("\n-> 正在进行优化...")
                refine_prompt = REFINE_PROMPT_TEMPLATE.format(
                    task=task,
                    last_code_attempt = last_code,
                    feedback = feedback
                )
                refine_code = self._get_llm_response(refine_prompt)
                self.memory.add_record("execution",refine_code)

            final_code = self.memory.get_last_execution()
            print(f"\n--- 任务完成 ---\n最终生成的代码:\n```python\n{final_code}\n```")
            return final_code

    if __name__ == '__main__':
        # 1. 初始化LLM客户端 (请确保你的 .env 和 llm_client.py 文件配置正确)
        try:
            llm_client = HelloAgentsLLM()
        except Exception as e:
            print(f"初始化LLM客户端时出错: {e}")
            exit()

        # 2. 初始化 Reflection 智能体，设置最多迭代2轮
        agent = ReflectionAgent(llm_client, max_iterations=2)

        # 3. 定义任务并运行智能体
        task = "编写一个Python函数，找出1到n之间所有的素数 (prime numbers)。"
        agent.run(task)

缺点:
1. 开销大，每轮迭代调用2次大模型
2. 延迟大，反思和优化必须串行
3. 提示词工程复杂度大，要写多个提示词，且提示词质量很重要。


优点：
1. 解决方案质量跃迁
2. 鲁棒性和可靠性增强。

1. coze
2. dify
3. n8n

1、AutoGen：AutoGen 的核心思想是通过对话实现协作。
它将多智能体系统抽象为一个由多个“可对话”智能体组成的群聊。
开发者可以定义不同角色（如 Coder, ProductManager, Tester），并设定它们之间的交互规则（例如，Coder 写完代码后由 Tester 自动接管）。
任务的解决过程，就是这些智能体在群聊中通过自动化消息传递，不断对话、协作、迭代直至最终目标达成的过程。

2、AgentScope：AgentScope 是一个专为多智能体应用设计的、功能全面的开发平台。
它的核心特点是易用性和工程化。它提供了一套非常友好的编程接口，让开发者可以轻松定义智能体、构建通信网络，并管理整个应用的生命周期。
其内置的消息传递机制和对分布式部署的支持，使其非常适合构建和运维复杂、大规模的多智能体系统。

3、CAMEL：CAMEL 提供了一种新颖的、名为角色扮演 (Role-Playing) 的协作方法。
其核心理念是，我们只需要为两个智能体（例如，AI研究员 和 Python程序员）设定好各自的角色和共同的任务目标，它们就能在“初始提示 (Inception Prompting)”的引导下，自主地进行多轮对话，相互启发、相互配合，共同完成任务。它极大地降低了设计多智能体对话流程的复杂度。

4、LangGraph：作为 LangChain 生态的扩展，LangGraph 另辟蹊径，将智能体的执行流程建模为图 (Graph)。
在传统的链式结构中，信息只能单向流动。
而 LangGraph 将每一步操作（如调用LLM、执行工具）定义为图中的一个节点 (Node)，并用边 (Edge) 来定义节点之间的跳转逻辑。
这种设计天然支持循环 (Cycles)，使得实现如 Reflection 这样的迭代、修正、自我反思的复杂工作流变得异常简单和直观。