AI Agent的主流设计模式之反射模式

反射模式（Reflection pattern）：这个模式的核心运作机制是构建自检-纠错迭代环，AI Agent会审查其工作以发现错误并迭代，直到生成最终输出结果。

import os
from openai import OpenAI
from typing import List, Dict, Any
import json

ALI_TONGYI_API_KEY_OS_VAR_NAME = "DASHSCOPE_API_KEY"
ALI_TONGYI_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"


class ReflectiveAgent:
    """
    接入阿里云 Qwen 的反射式 AI 代理
    """

    def __init__(self, api_key: str = None):
        # 初始化阿里云 Qwen 客户端
        self.client = OpenAI(
            api_key=api_key or os.getenv(ALI_TONGYI_API_KEY_OS_VAR_NAME),
            base_url=ALI_TONGYI_URL  # 阿里云兼容接口 [citation:2]
        )
        self.model = "qwen-plus"  # 可选: qwen-turbo, qwen-plus, qwen-max
        self.memory = []  # 任务历史记忆
        self.strategies = {}  # 反思更新的策略
        self.conversation_history = []  # 多轮对话历史

    def act(self, task: str) -> str:
        """执行任务，包含执行-反思-优化闭环"""
        # 1. 执行任务（调用大模型）
        result = self._execute(task)

        # 2. 记录执行历史
        self.memory.append({"task": task, "result": result})

        # 3. 反思：让 Qwen 评估自己的回答
        reflection = self._reflect(task, result)

        # 4. 根据反思更新策略
        if reflection.get("needs_improvement"):
            self._update_strategy(reflection)

        return result

    def _execute(self, task: str) -> str:
        """
        调用 Qwen API 执行任务
        """
        try:
            # 构建消息，如果有历史策略，在 system prompt 中加入
            system_prompt = self._build_system_prompt()
            messages = [{"role": "system", "content": system_prompt}]

            # 添加上下文记忆（最近2轮）
            for item in self.memory[-2:]:
                messages.append({"role": "user", "content": item["task"]})
                messages.append({"role": "assistant", "content": item["result"]})

            # 添加当前任务
            messages.append({"role": "user", "content": task})

            # 调用 Qwen API [citation:2]
            completion = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=0.7
            )

            return completion.choices[0].message.content

        except Exception as e:
            return f"调用大模型失败：{str(e)}"

    def _build_system_prompt(self) -> str:
        """根据历史策略构建 system prompt"""
        base_prompt = "你是一个有帮助的 AI 助手。"

        if self.strategies:
            strategies_desc = "根据历史经验，请记住以下优化建议：\n"
            for task_type, advice in self.strategies.items():
                strategies_desc += f"- 当处理{task_type}类任务时：{advice}\n"
            return base_prompt + "\n" + strategies_desc

        return base_prompt

    def _reflect(self, task: str, result: str) -> Dict[str, Any]:
        """
        让 Qwen 反思自己的回答质量
        """
        reflection_prompt = f"""
        请以批判性思维评估你刚才的回答。

        用户任务：{task}
        你的回答：{result}

        请从以下维度分析：
        1. 回答是否准确解决了用户问题？（是/否/部分）
        2. 如果不够好，问题出在哪里？
        3. 如何改进这个回答？
        4. 这个任务属于什么类型？（如：编程、写作、问答、计算等）

        请以 JSON 格式返回评估结果。
        """

        try:
            completion = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "你是一个严格的自我评估者，请客观分析回答质量。"},
                    {"role": "user", "content": reflection_prompt}
                ],
                temperature=0.3  # 评估时保持稳定
            )

            reflection_text = completion.choices[0].message.content

            # 尝试解析 JSON
            try:
                # 提取 JSON 部分
                json_str = reflection_text[reflection_text.find("{"):reflection_text.rfind("}") + 1]
                reflection = json.loads(json_str)
            except:
                # 如果解析失败，使用默认评估
                reflection = {
                    "accuracy": "unknown",
                    "issues": "无法解析反思结果",
                    "improvement": "继续学习",
                    "task_type": "general",
                    "needs_improvement": True
                }

            print(f"\n🤔 反思结果：{json.dumps(reflection, ensure_ascii=False, indent=2)}")
            return reflection

        except Exception as e:
            print(f"反思过程出错：{e}")
            return {"needs_improvement": False}

    def _update_strategy(self, reflection: Dict[str, Any]):
        """
        根据反思更新策略
        """
        if "task_type" in reflection and "improvement" in reflection:
            task_type = reflection["task_type"]
            advice = reflection["improvement"]
            self.strategies[task_type] = advice
            print(f"📝 策略已更新：{task_type}类任务将优化 → {advice[:50]}...")


# ------------------ 测试用例 ------------------
def test_reflective_agent():
    """测试反射模式的 Agent"""

    # 初始化 Agent（确保环境变量 QWEN_API_KEY 已设置）
    agent = ReflectiveAgent()

    print("=" * 50)
    print("🚀 开始测试反射模式 Agent")
    print("=" * 50)

    # 测试用例 1：代码生成任务
    task1 = "写一个 Python 函数，计算斐波那契数列的第 n 项"
    print(f"\n📌 任务 1：{task1}")
    result1 = agent.act(task1)
    print(f"✅ 回答：\n{result1}\n")

    # 测试用例 2：复杂一点的代码任务（可能触发反思优化）
    task2 = "用 Python 实现一个装饰器，用于计算函数执行时间"
    print(f"\n📌 任务 2：{task2}")
    result2 = agent.act(task2)
    print(f"✅ 回答：\n{result2}\n")

    # 查看策略更新情况
    print("\n📊 当前策略库：")
    for task_type, advice in agent.strategies.items():
        print(f"  - {task_type}: {advice}")

    # 测试用例 3：相同类型任务，看策略是否生效
    task3 = "写一个 Python 装饰器，实现重试机制"
    print(f"\n📌 任务 3（同类型任务，策略应生效）：{task3}")
    result3 = agent.act(task3)
    print(f"✅ 回答：\n{result3}\n")


if __name__ == "__main__":
    # 方式1：直接设置 API Key（不推荐用于生产）
    # agent = ReflectiveAgent(api_key="sk-xxx")

    # 方式2：通过环境变量（推荐）
    # 在终端执行：export QWEN_API_KEY="你的API-KEY" [citation:2]
    test_reflective_agent()