# 场景：简单分类任务
prompt = """
将以下文本分类为正面、负面或中性情感：

文本："这家餐厅的服务态度很好，菜品也很美味。"
"""

# LLM输出：
# 情感分类：正面
# 原因：文本中包含积极词汇"很好"、"美味"

# 场景：复杂业务规则
prompt = """
根据用户订单判断是否可以退款：
订单ID: 12345
"""

# LLM输出：
# 需要更多信息才能判断...

# 问题：
# 1. 缺少业务规则上下文
# 2. 模型无法知道退款政策
# 3. 需要few-shot或结构化提示

# OpenClaw Agent中的使用
class SimpleIntentClassifier:
    def classify(self, user_input: str) -> str:
        # ✅ 适合：简单意图识别
        prompt = f"""
        用户说："{user_input}"
        
        判断用户意图是以下哪一种：
        - 发送消息
        - 查询天气
        - 搜索网络
        
        只返回意图名称，不要解释。
        """
        return self.llm.generate(prompt)
    
    # ❌ 不适合：复杂的多步骤任务规划

prompt = """
从文本中提取人名、地点和事件。

示例1：
文本："张三在北京参加了人工智能大会。"
输出：{"人名": ["张三"], "地点": ["北京"], "事件": ["参加人工智能大会"]}

示例2：
文本："李四和王五在上海创建了科技公司。"
输出：{"人名": ["李四", "王五"], "地点": ["上海"], "事件": ["创建科技公司"]}

请处理：
文本："赵六在深圳发布了新产品，引起广泛关注。"
"""

# LLM输出：
# {"人名": ["赵六"], "地点": ["深圳"], "事件": ["发布新产品"]}

# 错误示例1：示例不一致
prompt = """
翻译文本到英文。

示例1：
中文：你好
English: Hello

示例2：
中文：谢谢
Answer: Thanks  # 格式不一致！

示例3：
中文：再见
Output: Goodbye  # 又变了！

翻译：
中文：早上好
"""

# LLM输出混乱，因为示例格式不统一

# 错误示例2：示例过多
prompt = """
分类电影类型。

# 提供了20个示例...
# 示例1到示例20...

分类：复仇者联盟
"""

# 问题：
# 1. Token浪费（20个示例可能只需要3-5个）
# 2. 上下文窗口占用过多
# 3. 可能引入噪声

# OpenClaw技能路由示例
class SkillRouter:
    def route_skill(self, user_request: str) -> str:
        # ✅ 使用Few-Shot进行技能匹配
        prompt = f"""
        根据用户请求选择最合适的技能。

        示例1：
        请求："帮我发送邮件给张三"
        技能：send-email

        示例2：
        请求："读取飞书文档"
        技能：feishu-doc

        示例3：
        请求："发布博客文章"
        技能：blog-publisher

        用户请求："{user_request}"
        技能：
        """
        return self.llm.generate(prompt).strip()

# 优化：使用动态Few-Shot
class DynamicFewShotRouter:
    def __init__(self):
        self.examples = self.load_examples_from_memory()
    
    def route_skill(self, user_request: str):
        # 1. 从记忆中检索最相似的示例
        similar_examples = self.retrieve_top_k(user_request, k=3)
        
        # 2. 构建Few-Shot提示
        prompt = self.build_prompt(user_request, similar_examples)
        
        return self.llm.generate(prompt)

prompt = """
你是一位资深的前端工程师，有10年React开发经验。
请用简洁、专业的语言回答以下问题：

问题：如何优化React组件的渲染性能？

请提供：
1. 核心优化策略
2. 代码示例
3. 最佳实践建议
"""

# LLM输出（专业、技术性强）：
# 
# 核心优化策略：
# 1. **React.memo()** - 浅比较props
# 2. **useMemo/useCallback** - 缓存计算和函数
# 3. **代码分割** - React.lazy + Suspense
# 
# 代码示例：
# const OptimizedComponent = React.memo(({ data }) => {
#   const processedData = useMemo(() => 
#     heavyComputation(data), [data]
#   );
#   return <div>{processedData}</div>;
# });
# 
# 最佳实践：
# - 避免不必要的re-render
# - 使用key属性优化列表渲染
# - 虚拟化长列表

# 错误示例1：角色过于宽泛
prompt = """
你是一个专家。
解释量子计算。
"""

# 问题：什么领域的专家？缺乏针对性

# 错误示例2：角色与任务不匹配
prompt = """
你是一位著名的历史学家。
请帮我写一段Python代码实现快速排序。
"""

# 问题：角色与任务领域不符，可能限制模型能力

# 错误示例3：角色定义矛盾
prompt = """
你是一位保守的理财顾问，但同时也喜欢推荐高风险高收益的投资。
请推荐一些投资产品。
"""

# 问题：角色特征矛盾，导致输出不稳定

# 多角色Agent系统
class MultiPersonaAgent:
    def __init__(self):
        self.personas = {
            "technical": """
                你是技术专家，专注于：
                - 技术可行性分析
                - 架构设计建议
                - 性能优化方案
                语言风格：专业、精确、数据驱动
            """,
            "product": """
                你是产品经理，关注：
                - 用户需求和价值
                - 产品体验优化
                - 商业可行性
                语言风格：简洁、商业导向、用户为中心
            """,
            "qa": """
                你是质量保证工程师，负责：
                - 风险识别
                - 测试策略
                - 边界情况分析
                语言风格：严谨、细致、怀疑态度
            """
        }
    
    def analyze_feature(self, feature_desc: str) -> dict:
        """从多个角色视角分析功能"""
        analyses = {}
        
        for role_name, persona in self.personas.items():
            prompt = f"""
            {persona}
            
            功能描述：{feature_desc}
            
            请从你的角色视角分析这个功能，包括：
            1. 关键考虑点
            2. 潜在问题
            3. 建议
            
            限制在150字以内。
            """
            
            analyses[role_name] = self.llm.generate(prompt)
        
        return analyses

# 使用示例
agent = MultiPersonaAgent()
result = agent.analyze_feature("""
添加用户头像上传功能，支持裁剪和滤镜
""")

# 输出示例：
# {
#   "technical": "建议使用Canvas API实现裁剪...",
#   "product": "提升用户个性化体验，但需考虑审核机制...",
#   "qa": "需测试大文件上传、格式兼容性、裁剪精度..."
# }

class RolePlayConversationAgent:
    def __init__(self, character_config: dict):
        self.character = character_config
    
    def generate_response(self, user_input: str) -> str:
        prompt = f"""
        角色设定：
        - 姓名：{self.character['name']}
        - 性格：{self.character['personality']}
        - 背景：{self.character['background']}
        - 说话风格：{self.character['style']}
        
        用户说："{user_input}"
        
        请以{self.character['name']}的身份回复，保持角色一致性。
        """
        return self.llm.generate(prompt)

# 示例角色配置
sherlock_config = {
    "name": "福尔摩斯",
    "personality": "理性、观察敏锐、略带傲慢",
    "background": "维多利亚时代侦探，精通推理",
    "style": "使用演绎法，常引用案例，语气自信"
}

prompt = """
问题：一个商店有125个苹果，卖出了47个，又进货了38个，最后卖出了29个。
现在商店还有多少个苹果？

让我们一步步思考：
"""

# LLM输出：
# 
# 让我们一步步思考：
# 
# 步骤1：初始有125个苹果
# 步骤2：卖出47个，剩余：125 - 47 = 78个
# 步骤3：进货38个，现在有：78 + 38 = 116个
# 步骤4：又卖出29个，剩余：116 - 29 = 87个
# 
# 答案：商店现在有87个苹果。

# 无需示例，只需添加"让我们一步步思考"
prompt = f"""
{complex_problem}

让我们一步步思考。
"""

# 适用于：
# - 没有few-shot示例
# - 任务类型多样
# - 需要通用推理能力

# 错误示例1：跳过推理
prompt = """
问题：计算 15 * 23 + 47 * 8 - 120 / 4

答案：
"""

# LLM输出：854
# 问题：没有推理过程，难以验证正确性

# 错误示例2：推理步骤混乱
prompt = """
问题：小明有50元，买了3本书，每本8元，还剩多少钱？

让我们一步步思考：
"""

# 可能的混乱输出：
# 让我们一步步思考：
# 首先，每本书8元（步骤2）
# 小明买了3本书（步骤1）
# 总共花费：8 * 3 = 24元（步骤3）
# 剩余：50 - 24 = 26元（步骤4）
# 
# 问题：步骤编号混乱，逻辑顺序不清

# OpenClaw任务规划Agent
class TaskPlanningAgent:
    def plan(self, user_request: str) -> list:
        prompt = f"""
        用户请求：{user_request}
        
        请制定执行计划。让我们一步步思考：
        1. 分析请求的核心目标
        2. 识别需要的技能和工具
        3. 确定执行顺序
        4. 考虑依赖关系
        5. 输出结构化计划
        
        输出JSON格式的任务列表：
        """
        
        plan = self.llm.generate(prompt)
        return self.parse_plan(plan)

# 使用示例
agent = TaskPlanningAgent()
plan = agent.plan("搜索2026年AI Agent最新论文，分析后发布到博客")

# 输出示例：
# 让我们一步步思考：
# 
# 1. 核心目标：研究、分析并发布AI Agent相关内容
# 
# 2. 需要的技能：
#    - web-research（搜索论文）
#    - arxiv-analyzer（分析论文）
#    - markdown-writer（撰写文章）
#    - blog-publisher（发布博客）
# 
# 3. 执行顺序：
#    步骤1：使用web-research搜索论文
#    步骤2：使用arxiv-analyzer分析核心论文
#    步骤3：使用markdown-writer生成文章
#    步骤4：使用blog-publisher发布到博客
# 
# 4. 依赖关系：
#    - 步骤2依赖步骤1的结果
#    - 步骤3依赖步骤2的分析
#    - 步骤4依赖步骤3的文章

class SelfConsistencyAgent:
    def solve_with_consistency(self, problem: str, n_samples: int = 5):
        """使用自一致性提高准确率"""
        reasoning_paths = []
        
        # 生成多条推理路径
        for i in range(n_samples):
            prompt = f"""
            {problem}
            
            让我们一步步思考（推理路径{i+1}）：
            """
            reasoning = self.llm.generate(prompt, temperature=0.7)
            reasoning_paths.append(reasoning)
        
        # 提取并投票选择最一致的答案
        return self.vote_for_answer(reasoning_paths)

prompt = """
问题：24点游戏
数字：3, 7, 8, 9
使用加减乘除，每个数字只用一次，得到24。

使用思维树方法，探索不同的组合方式：

思路1：从最大的数字9开始
  ├─ 分支1.1：9 + 8 = 17
  │   └─ 下一步：17 + 7 = 24 ❌ 但3没用上
  ├─ 分支1.2：9 - 8 = 1
  │   └─ 下一步：1 * 3 = 3
  │       └─ 下一步：3 * 7 = 21 ❌ 不是24
  └─ 分支1.3：9 * 3 = 27
      └─ 下一步：27 - 8 = 19
          └─ 下一步：19 + 7 = 26 ❌ 不是24

思路2：先考虑乘法组合
  ├─ 分支2.1：8 * 3 = 24 ✓
  │   └─ 下一步：如何用7和9得到1？
  │       ├─ 9 - 7 = 2 ❌ 
  │       └─ 9 / 7 ≈ 1.29 ❌
  └─ 分支2.2：7 * 3 = 21
      └─ 下一步：21 + 9 = 30 ❌
          └─ 下一步：30 - 8 = 22 ❌

思路3：尝试除法组合
  └─ 分支3.1：(9 - 7) = 2
      └─ (8 / 2) = 4
          └─ 4 * 3 = 12 ❌
  
  └─ 分支3.2：(8 / (9 - 7)) * 3
      = (8 / 2) * 3
      = 4 * 3
      = 12 ❌

最优解：(9 - 8 + 7) * 3 = 24
验证：(9 - 8) = 1, 1 + 7 = 8, 8 * 3 = 24 ✓
"""

# LLM输出包含完整的探索过程

# 错误示例：简单问题使用ToT（过度设计）
prompt = """
问题：1 + 1 = ?

使用思维树方法，探索所有可能的计算路径：
"""

# 问题：
# 1. 简单问题不需要复杂推理
# 2. 浪费计算资源
# 3. 增加延迟

# 决策制定Agent
class DecisionMakingAgent:
    def make_decision(self, scenario: str) -> dict:
        prompt = f"""
        场景：{scenario}
        
        请使用思维树方法分析：
        
        1. 生成3-5个可能的行动方案
        2. 对每个方案进行评估（优点/缺点/风险）
        3. 剪枝不可行的方案
        4. 深度分析剩余方案
        5. 选择最优方案并说明理由
        
        输出格式：
        {
          "options": [...],
          "evaluations": [...],
          "pruned": [...],
          "final_decision": "...",
          "reasoning": "..."
        }
        """
        
        return self.llm.generate_json(prompt)

# 使用示例
agent = DecisionMakingAgent()
decision = agent.make_decision("""
项目进度落后20%，但预算已经用完。
可以选择：
A. 申请追加预算
B. 削减功能范围
C. 延期交付
""")

# 输出示例：
# {
#   "options": [
#     "申请追加预算",
#     "削减功能范围", 
#     "延期交付",
#     "混合方案：削减非核心功能 + 申请部分预算"
#   ],
#   "evaluations": [
#     {
#       "option": "申请追加预算",
#       "pros": ["保留所有功能", "团队士气稳定"],
#       "cons": ["可能被拒", "需要重新审批流程"],
#       "risk": "high",
#       "score": 6/10
#     },
#     ...
#   ],
#   "final_decision": "混合方案",
#   "reasoning": "综合考虑风险和收益..."
# }

class CodeGenerationAgent:
    def generate_with_tot(self, requirement: str):
        prompt = f"""
        需求：{requirement}
        
        使用思维树方法设计解决方案：
        
        树结构：
        ├─ 设计思路1：[架构A]
        │   ├─ 优点：...
        │   ├─ 缺点：...
        │   └─ 可行性评估：...
        ├─ 设计思路2：[架构B]
        │   ├─ 优点：...
        │   └─ ...
        └─ 设计思路3：[架构C]
        
        最优设计：[选择并解释]
        实现代码：
        """
        
        return self.llm.generate(prompt)

prompt = """
你是一个智能助手，可以使用以下工具：
- search(query): 搜索网络
- calculator(expression): 计算数学表达式
- weather(city): 查询天气

用户问题：北京现在的温度是多少摄氏度？如果温度低于20度，建议穿什么？

请按ReAct格式思考和行动：

Thought: 我需要查询北京的当前天气
Action: weather("北京")
Observation: 北京当前温度15°C，晴天

Thought: 温度是15度，低于20度。我需要给出穿衣建议。
Answer: 北京当前温度是15°C，低于20度。建议穿着：
- 长袖衬衫或薄毛衣
- 外套（轻薄夹克或风衣）
- 长裤
- 早晚可能需要添衣保暖
"""

# LLM输出符合ReAct格式

# 错误示例1：缺少观察步骤
prompt = """
用户问题：123 * 456等于多少？

Thought: 需要计算
Action: calculator("123 * 456")
Answer: 结果是56088

问题：缺少Observation步骤，无法验证结果
"""

# 错误示例2：Thought和Action不匹配
prompt = """
用户问题：今天天气如何？

Thought: 我想知道明天天气
Action: weather("今天")

问题：Thought和Action内容不一致
"""

# OpenClaw Agent核心实现
class ReActAgent:
    def __init__(self, tools: dict):
        self.tools = tools
        self.history = []
    
    def run(self, user_request: str, max_iterations: int = 10):
        """ReAct循环"""
        iteration = 0
        
        while iteration < max_iterations:
            iteration += 1
            
            # 生成下一步行动
            prompt = self.build_react_prompt(user_request)
            response = self.llm.generate(prompt)
            
            # 解析Thought/Action/Observation
            thought = self.extract_thought(response)
            action = self.extract_action(response)
            
            if action is None:
                # 没有Action，说明已经给出最终答案
                return self.extract_answer(response)
            
            # 执行工具调用
            tool_name, tool_args = self.parse_action(action)
            observation = self.execute_tool(tool_name, tool_args)
            
            # 记录历史
            self.history.append({
                "thought": thought,
                "action": action,
                "observation": observation
            })
        
        return "达到最大迭代次数，任务未完成"
    
    def build_react_prompt(self, request: str) -> str:
        history_text = self.format_history()
        
        return f"""
        可用工具：{list(self.tools.keys())}
        
        历史：
        {history_text}
        
        用户请求：{request}
        
        请按以下格式继续：
        Thought: [你的思考]
        Action: [工具名(参数)]
        或
        Answer: [最终答案]
        """
    
    def format_history(self) -> str:
        lines = []
        for h in self.history:
            lines.append(f"Thought: {h['thought']}")
            lines.append(f"Action: {h['action']}")
            lines.append(f"Observation: {h['observation']}")
        return "\n".join(lines)

# 使用示例
tools = {
    "search": web_search,
    "read": read_file,
    "write": write_file
}

agent = ReActAgent(tools)
result = agent.run("搜索AI Agent最新论文并保存到文件")

# 执行轨迹：
# Thought: 需要搜索AI Agent论文
# Action: search("AI Agent 2026 latest papers")
# Observation: 找到10篇论文，包括Memento-Skills...
# 
# Thought: 需要将结果保存到文件
# Action: write("papers.md", content)
# Observation: 文件已保存
# 
# Answer: 已完成搜索和保存，共找到10篇论文

class ReflectiveReActAgent(ReActAgent):
    def run_with_reflection(self, request: str):
        """带反思机制的ReAct"""
        result = super().run(request)
        
        # 执行后反思
        reflection_prompt = f"""
        任务：{request}
        执行历史：{self.format_history()}
        结果：{result}
        
        请反思：
        1. 执行过程是否高效？
        2. 有没有更好的工具选择？
        3. 如何改进？
        """
        
        reflection = self.llm.generate(reflection_prompt)
        
        # 保存反思结果以供下次改进
        self.save_reflection(reflection)
        
        return {
            "result": result,
            "reflection": reflection
        }

prompt = """
分析以下产品评论，提取情感和关键信息。

评论："这款耳机音质很棒，降噪效果出色，但电池续航有点短。"

请以JSON格式输出：
{
  "sentiment": "positive" | "negative" | "neutral",
  "confidence": 0.0-1.0,
  "aspects": [
    {
      "feature": "string",
      "opinion": "positive" | "negative",
      "detail": "string"
    }
  ],
  "summary": "string"
}

输出：
"""

# LLM输出：
# {
#   "sentiment": "positive",
#   "confidence": 0.85,
#   "aspects": [
#     {
#       "feature": "音质",
#       "opinion": "positive",
#       "detail": "很棒"
#     },
#     {
#       "feature": "降噪",
#       "opinion": "positive",
#       "detail": "效果出色"
#     },
#     {
#       "feature": "电池续航",
#       "opinion": "negative",
#       "detail": "有点短"
#     }
#   ],
#   "summary": "音质和降噪优秀，但续航有待提升"
# }

# 错误示例1：格式定义模糊
prompt = """
分析评论并以JSON格式输出。

评论："这个产品很好用。"
"""

# LLM输出可能不一致：
# {"good": true}
# 或
# {"rating": 5}
# 或
# {"sentiment": "positive"}

# 问题：缺少具体的Schema定义

# 错误示例2：复杂嵌套无示例
prompt = """
分析文章结构，输出JSON：
{
  "sections": [
    {
      "title": "string",
      "paragraphs": [
        {
          "content": "string",
          "keywords": ["string"]
        }
      ]
    }
  ]
}

文章：[长篇文章]
"""

# 问题：
# 1. 嵌套结构复杂但无示例
# 2. 容易出现格式错误
# 3. 难以保证一致性

# OpenClaw配置解析Agent
class ConfigParserAgent:
    def parse_user_intent(self, user_input: str) -> dict:
        prompt = f"""
        用户输入：{user_input}
        
        解析为结构化配置：
        {{
          "action": "create" | "read" | "update" | "delete",
          "resource_type": "file" | "document" | "skill" | "task",
          "parameters": {{
            "path": "string (optional)",
            "content": "string (optional)",
            "options": {{}}
          }},
          "constraints": [
            {{
              "type": "permission" | "validation" | "limit",
              "value": "string"
            }}
          ]
        }}
        
        示例：
        输入："创建一个名为test.md的文件，内容是Hello World"
        输出：{{
          "action": "create",
          "resource_type": "file",
          "parameters": {{
            "path": "test.md",
            "content": "Hello World"
          }},
          "constraints": []
        }}
        
        现在解析：
        """
        
        response = self.llm.generate(prompt)
        return self.validate_and_parse_json(response)

# 使用示例
parser = ConfigParserAgent()
config = parser.parse_user_intent("""
读取/data/reports/目录下所有markdown文件，
找出包含"AI Agent"的段落，并生成摘要报告
""")

# 输出：
# {
#   "action": "read",
#   "resource_type": "file",
#   "parameters": {
#     "path": "/data/reports/",
#     "pattern": "*.md",
#     "filter": {
#       "contains": "AI Agent"
#     }
#   },
#   "constraints": [
#     {
#       "type": "validation",
#       "value": "must_be_directory"
#     }
#   ],
#   "post_action": {
#     "type": "summarize",
#     "output_format": "report"
#   }
# }

class DynamicSchemaAgent:
    def __init__(self):
        self.schema_registry = {}
    
    def register_schema(self, task_type: str, schema: dict):
        """注册任务类型的Schema"""
        self.schema_registry[task_type] = schema
    
    def execute_with_schema(self, task_type: str, input_data: str):
        """使用注册的Schema执行任务"""
        schema = self.schema_registry.get(task_type)
        
        if not schema:
            raise ValueError(f"Unknown task type: {task_type}")
        
        prompt = f"""
        输入数据：{input_data}
        
        请严格按照以下JSON Schema输出：
        {json.dumps(schema, indent=2)}
        
        输出：
        """
        
        response = self.llm.generate(prompt)
        return self.validate_against_schema(response, schema)

# 注册不同任务的Schema
agent = DynamicSchemaAgent()

agent.register_schema("sentiment_analysis", {
    "type": "object",
    "properties": {
        "sentiment": {"enum": ["positive", "negative", "neutral"]},
        "score": {"type": "number", "minimum": 0, "maximum": 1}
    },
    "required": ["sentiment", "score"]
})

agent.register_schema("entity_extraction", {
    "type": "object",
    "properties": {
        "entities": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "text": {"type": "string"},
                    "type": {"type": "string"},
                    "confidence": {"type": "number"}
                }
            }
        }
    }
})

prompt = """
问题：一个班级有30个学生，其中60%是女生。
如果女生的平均分是85分，男生的平均分是78分，
求全班的平均分。

请用Python代码计算，并输出结果。

```python
# 定义变量
total_students = 30
female_percentage = 0.60
female_avg = 85
male_avg = 78

# 计算
female_count = total_students * female_percentage
male_count = total_students - female_count

total_score = (female_count * female_avg + 
               male_count * male_avg)
class_avg = total_score / total_students

print(f"全班平均分：{class_avg:.2f}")

# 数据分析Agent
class DataAnalysisAgent:
    def analyze_with_code(self, data_description: str, question: str):
        prompt = f"""
        数据：{data_description}
        问题：{question}
        
        请编写Python代码进行分析：
        1. 加载和预处理数据
        2. 执行分析逻辑
        3. 生成可视化（如需要）
        4. 输出结果
        
        代码：
        ```python
        # 你的代码

# 错误示例：简单问题使用自一致性（过度）
solver.solve("1 + 1 = ?", n_samples=10)

# 问题：
# 1. 浪费计算资源
# 2. 增加延迟
# 3. 简单问题不需要

# 关键决策Agent
class CriticalDecisionAgent:
    def make_critical_decision(self, scenario: str):
        """对关键决策使用自一致性"""
        
        # 生成多个决策路径
        decisions = []
        for i in range(5):
            prompt = f"""
            场景：{scenario}
            
            请分析并给出决策建议（分析{i+1}）：
            1. 识别关键因素
            2. 评估风险
            3. 给出建议
            
            决策：
            """
            
            decision = self.llm.generate(prompt, temperature=0.8)
            decisions.append(decision)
        
        # 提取共识
        consensus = self.extract_consensus(decisions)
        
        # 如果没有明确共识，触发人工审核
        if consensus["confidence"] < 0.6:
            self.flag_for_human_review(scenario, decisions)
        
        return consensus

prompt = """
问题：量子计算机如何工作？

步骤1：生成相关知识
请先列出关于量子计算机的核心概念：
- 量子比特（qubit）
- 量子叠加
- 量子纠缠
- 量子门
- 量子退相干

步骤2：基于知识回答
现在，请使用上述概念解释量子计算机的工作原理：
"""

# LLM输出：
# 
# 相关知识：
# 1. 量子比特：量子信息的基本单位，可以同时处于0和1的叠加态
# 2. 量子叠加：允许量子比特同时表示多个状态
# 3. 量子纠缠：两个量子比特之间可以建立强关联
# 4. 量子门：对量子比特进行操作的基本单元
# 5. 量子退相干：量子态与环境相互作用导致的退化
# 
# 解释：
# 量子计算机利用量子比特的叠加和纠缠特性，
# 可以同时处理大量计算路径。通过量子门的精确操作，
# 实现特定算法（如Shor算法、Grover算法）的指数级加速。
# 但需要克服量子退相干带来的挑战...

# 错误示例：简单事实性问题
prompt = """
问题：中国的首都是哪里？

步骤1：生成相关知识
步骤2：回答

# 问题：简单问题不需要两步
# 直接回答即可
"""

# 专家系统Agent
class ExpertSystemAgent:
    def answer_with_knowledge(self, question: str, domain: str):
        prompt = f"""
        领域：{domain}
        问题：{question}
        
        第一阶段：知识生成
        请生成回答此问题所需的核心知识：
        1. 基本概念定义
        2. 关键理论
        3. 重要公式/方法
        4. 相关案例
        
        第二阶段：知识应用
        基于上述知识，详细回答问题：
        """
        
        return self.llm.generate(prompt)

# 使用示例
expert = ExpertSystemAgent()
answer = expert.answer_with_knowledge(
    question="如何设计一个高可用的分布式系统？",
    domain="分布式系统"
)

# 输出包含：
# 1. CAP理论、一致性协议、故障检测等知识
# 2. 基于这些知识的具体设计建议

prompt = """
产品功能：用户头像上传

从【安全性】角度分析这个功能：
- 文件上传漏洞
- 恶意文件检测
- 存储安全

从【性能】角度分析：
- 图片压缩
- CDN加速
- 缓存策略

从【用户体验】角度分析：
- 裁剪功能
- 预览效果
- 上传进度

综合建议：
"""

# LLM输出：
# 
# 安全性：
# 1. 限制文件类型（仅允许jpg, png）
# 2. 检查文件头，防止伪装
# 3. 重命名文件，避免路径遍历
# 4. 使用独立存储域名，防止XSS
# 
# 性能：
# 1. 客户端压缩到合理大小
# 2. 使用WebP格式
# 3. CDN分发
# 4. 多尺寸缓存
# 
# 用户体验：
# 1. 提供裁剪工具
# 2. 实时预览
# 3. 进度条显示
# 4. 失败重试机制
# 
# 综合建议：
# 实现一个安全的、高性能的、用户友好的
# 头像上传功能，需要平衡安全检查和性能...

# 错误示例：刺激词过多
prompt = """
从安全、性能、用户体验、可维护性、
可扩展性、成本、法律合规、国际化、
无障碍访问、SEO角度分析...

# 问题：
# 1. 方向太多，失去焦点
# 2. 难以深入每个方面
# 3. token消耗大
"""

# 代码审查Agent
class CodeReviewAgent:
    def review_code(self, code: str, aspects: list):
        """从多个维度审查代码"""
        
        aspect_prompts = {
            "security": "从【安全性】角度：检查SQL注入、XSS、权限控制",
            "performance": "从【性能】角度：检查算法复杂度、内存使用、I/O",
            "readability": "从【可读性】角度：检查命名、注释、代码结构",
            "maintainability": "从【可维护性】角度：检查耦合度、模块化"
        }
        
        reviews = {}
        for aspect in aspects:
            prompt = f"""
            代码：

class AutoPromptEngineer:
    def __init__(self, task_description: str, test_cases: list):
        self.task_desc = task_description
        self.test_cases = test_cases
    
    def generate_candidate_prompts(self, n: int = 5):
        """生成候选提示词"""
        prompt = f"""
        任务：{self.task_desc}
        
        请生成{n}个不同的提示词模板，
        每个模板应该：
        1. 清晰定义任务
        2. 提供输出格式
        3. 包含示例（如适用）
        
        模板1：
        ...
        
        模板2：
        ...
        """
        
        return self.llm.generate(prompt)
    
    def evaluate_prompt(self, prompt_template: str):
        """评估提示词效果"""
        correct = 0
        
        for test_case in self.test_cases:
            filled_prompt = prompt_template.format(
                input=test_case["input"]
            )
            
            response = self.llm.generate(filled_prompt)
            
            if self.check_answer(response, test_case["expected"]):
                correct += 1
        
        return correct / len(self.test_cases)
    
    def optimize(self):
        """自动优化流程"""
        # 生成候选
        candidates = self.parse_candidates(
            self.generate_candidate_prompts()
        )
        
        # 评估
        scores = []
        for candidate in candidates:
            score = self.evaluate_prompt(candidate)
            scores.append((candidate, score))
        
        # 选择最优
        best_prompt, best_score = max(scores, key=lambda x: x[1])
        
        # 迭代改进
        for iteration in range(3):
            improved = self.refine_prompt(best_prompt, best_score)
            new_score = self.evaluate_prompt(improved)
            
            if new_score > best_score:
                best_prompt = improved
                best_score = new_score
        
        return {
            "best_prompt": best_prompt,
            "score": best_score,
            "iterations": iteration + 1
        }

# 使用示例
ape = AutoPromptEngineer(
    task_description="情感分析：判断文本是正面、负面还是中性",
    test_cases=[
        {"input": "这个产品很好用", "expected": "positive"},
        {"input": "质量太差了", "expected": "negative"},
        {"input": "还可以", "expected": "neutral"},
        # ...更多测试用例
    ]
)

result = ape.optimize()
print(f"最优提示词：{result['best_prompt']}")
print(f"准确率：{result['score']:.2%}")

# Agent技能提示词优化器
class SkillPromptOptimizer:
    def optimize_skill_prompt(self, skill_name: str, examples: list):
        """优化特定技能的提示词"""
        
        # 提取任务特征
        task_features = self.analyze_examples(examples)
        
        # 生成候选提示词
        candidates = self.generate_prompts(task_features)
        
        # 在真实场景中测试
        best_prompt = None
        best_score = 0
        
        for candidate in candidates:
            # 在实际使用中评估
            score = self.evaluate_in_production(
                skill_name,
                candidate,
                test_period="1h"
            )
            
            if score > best_score:
                best_prompt = candidate
                best_score = score
        
        # 更新技能提示词
        self.update_skill(skill_name, best_prompt)
        
        return {
            "skill": skill_name,
            "new_prompt": best_prompt,
            "improvement": best_score
        }