11-Prompt Engineering完全指南

# 简单prompt
prompt = "翻译成英文：你好"

# 复杂prompt
prompt = """
任务：将中文翻译成英文
要求：
- 保持原意
- 使用正式语气
- 如果有多种翻译，选择最常用的

输入：你好
输出：
"""

# Zero-shot示例
prompt = """
将以下句子分类为积极、消极或中性：

句子：这部电影真不错！
分类：
"""

# 使用OpenAI API
import openai

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": prompt}
    ]
)

print(response.choices[0].message.content)
# 输出：积极

# One-shot示例
prompt = """
将句子分类为积极、消极或中性。

示例：
句子：这部电影真精彩！
分类：积极

现在分类这个：
句子：这部电影一般般。
分类：
"""

# Few-shot示例
prompt = """
将句子分类为积极、消极或中性。

句子：这部电影真精彩！
分类：积极

句子：这部电影太无聊了。
分类：消极

句子：这部电影还可以。
分类：中性

句子：这是我看过最好的电影！
分类：
"""

def compare_shot_types():
    """对比不同shot类型的效果"""

    # 测试任务：实体识别
    test_text = "苹果公司的CEO蒂姆·库克昨天访问了中国。"

    # Zero-shot
    zero_shot = f"""
    从文本中提取所有实体（人名、地名、组织名）。

    文本：{test_text}
    实体：
    """

    # Few-shot
    few_shot = f"""
    从文本中提取所有实体（人名、地名、组织名）。

    示例1：
    文本：微软的创始人比尔·盖茨访问了印度。
    实体：微软（组织）、比尔·盖茨（人名）、印度（地名）

    示例2：
    文本：特斯拉在上海建立了新工厂。
    实体：特斯拉（组织）、上海（地名）

    现在提取：
    文本：{test_text}
    实体：
    """

    # 测试（这里只是演示，实际需要调用API）
    prompts = {
        'Zero-shot': zero_shot,
        'Few-shot': few_shot,
    }

    return prompts

# 示例
prompts = compare_shot_types()
for name, prompt in prompts.items():
    print(f"=== {name} ===")
    print(prompt)
    print()

def create_structured_prompt(
    task_description,
    context=None,
    examples=None,
    input_data=None,
    output_format=None,
    constraints=None,
):
    """
    创建结构化prompt

    Args:
        task_description: 任务描述
        context: 背景信息
        examples: 示例列表
        input_data: 输入数据
        output_format: 输出格式说明
        constraints: 约束条件

    Returns:
        完整的prompt
    """
    parts = []

    # 1. 任务描述
    parts.append(f"任务：{task_description}")

    # 2. 背景信息
    if context:
        parts.append(f"\n背景：\n{context}")

    # 3. 约束条件
    if constraints:
        parts.append("\n要求：")
        for constraint in constraints:
            parts.append(f"- {constraint}")

    # 4. 示例
    if examples:
        parts.append("\n示例：")
        for i, example in enumerate(examples, 1):
            parts.append(f"\n示例{i}：")
            parts.append(f"输入：{example['input']}")
            parts.append(f"输出：{example['output']}")

    # 5. 输出格式
    if output_format:
        parts.append(f"\n输出格式：\n{output_format}")

    # 6. 实际输入
    if input_data:
        parts.append(f"\n输入：\n{input_data}")
        parts.append("\n输出：")

    return '\n'.join(parts)

# 使用示例
prompt = create_structured_prompt(
    task_description="文本摘要",
    context="为新闻文章生成简洁的摘要",
    constraints=[
        "摘要长度不超过50字",
        "保留关键信息",
        "使用客观语气",
    ],
    examples=[
        {
            'input': "北京时间今天上午，美国宇航局宣布发现了一颗类地行星...",
            'output': "美国宇航局发现类地行星，位于宜居带内。"
        }
    ],
    output_format="一句话摘要",
    input_data="今天，OpenAI发布了最新的GPT-5模型，该模型在多个基准测试中创造了新纪录..."
)

print(prompt)

# 模糊不清
prompt = "分析这段文本"

# 清晰明确
prompt = """
分析以下产品评论的情感倾向（积极/消极/中性），
并提取关键优点和缺点。

评论：{review_text}

输出格式：
情感：[积极/消极/中性]
优点：[列出要点]
缺点：[列出要点]
"""

def make_prompt_clear(vague_prompt, specifics):
    """
    将模糊prompt改进为清晰prompt

    Args:
        vague_prompt: 模糊的prompt
        specifics: 具体化要素

    Returns:
        清晰的prompt
    """
    clear_prompt = vague_prompt

    # 添加具体任务
    if 'task' in specifics:
        clear_prompt += f"\n\n具体任务：{specifics['task']}"

    # 添加输出格式
    if 'format' in specifics:
        clear_prompt += f"\n\n输出格式：{specifics['format']}"

    # 添加约束
    if 'constraints' in specifics:
        clear_prompt += "\n\n要求："
        for c in specifics['constraints']:
            clear_prompt += f"\n- {c}"

    return clear_prompt

# 示例
vague = "总结这篇文章"

clear = make_prompt_clear(vague, {
    'task': '为文章生成3个要点的摘要',
    'format': '使用项目符号列表',
    'constraints': [
        '每个要点不超过20字',
        '保持客观中立',
        '突出主要论点',
    ]
})

print("模糊prompt:", vague)
print("\n清晰prompt:", clear)

# 不具体
prompt = "写一篇关于AI的文章"

# 具体
prompt = """
写一篇800字的文章，介绍AI在医疗领域的应用。

要求：
1. 结构：引言、应用场景（3个）、挑战、展望
2. 应用场景：诊断辅助、药物发现、个性化治疗
3. 包含具体案例
4. 目标读者：医疗从业者
5. 语气：专业但易懂
"""

def check_prompt_specificity(prompt):
    """
    检查prompt的具体性

    Returns:
        检查结果和建议
    """
    checks = {
        '是否指定任务类型': False,
        '是否说明输出长度': False,
        '是否定义输出格式': False,
        '是否提供示例': False,
        '是否说明目标受众': False,
        '是否指定语气/风格': False,
    }

    suggestions = []

    # 检查任务类型
    task_keywords = ['翻译', '摘要', '分类', '生成', '分析', '提取']
    if any(kw in prompt for kw in task_keywords):
        checks['是否指定任务类型'] = True
    else:
        suggestions.append("添加明确的任务类型（如：翻译、摘要等）")

    # 检查输出长度
    length_keywords = ['字', '词', '句', '段落', '行']
    if any(kw in prompt for kw in length_keywords):
        checks['是否说明输出长度'] = True
    else:
        suggestions.append("指定期望的输出长度")

    # 检查输出格式
    format_keywords = ['格式', 'JSON', 'Markdown', '列表', '表格']
    if any(kw in prompt for kw in format_keywords):
        checks['是否定义输出格式'] = True
    else:
        suggestions.append("定义输出格式（如：列表、JSON等）")

    # 检查示例
    if '示例' in prompt or '例如' in prompt:
        checks['是否提供示例'] = True
    else:
        suggestions.append("提供具体示例")

    # 检查目标受众
    audience_keywords = ['读者', '用户', '受众', '专业人士', '初学者']
    if any(kw in prompt for kw in audience_keywords):
        checks['是否说明目标受众'] = True
    else:
        suggestions.append("说明目标受众")

    # 检查语气
    tone_keywords = ['语气', '风格', '正式', '专业', '友好', '简洁']
    if any(kw in prompt for kw in tone_keywords):
        checks['是否指定语气/风格'] = True
    else:
        suggestions.append("指定期望的语气或风格")

    return {
        'checks': checks,
        'score': sum(checks.values()) / len(checks),
        'suggestions': suggestions,
    }

# 测试
test_prompts = [
    "总结这篇文章",
    "为以下文章生成200字的摘要，使用客观语气，面向普通读者",
]

for prompt in test_prompts:
    result = check_prompt_specificity(prompt)
    print(f"Prompt: {prompt}")
    print(f"具体性评分: {result['score']:.0%}")
    print(f"建议: {', '.join(result['suggestions'])}")
    print()

# 缺乏上下文
prompt = "这个决定好吗？"

# 提供上下文
prompt = """
背景：
你是一位职业咨询顾问。客户是一名有5年经验的软件工程师，
目前年薪50万，收到两个offer：
- A公司：创业公司，年薪80万，股票期权，工作强度大
- B公司：大厂，年薪65万，稳定，朝九晚五

客户个人情况：
- 已婚，有一个2岁的孩子
- 希望职业发展，但也重视家庭
- 风险承受能力中等

问题：客户应该选择哪个offer？

请分析利弊并给出建议。
"""

class ContextBuilder:
    """上下文构建器"""

    def __init__(self):
        self.context = {}

    def set_role(self, role):
        """设置AI角色"""
        self.context['role'] = role
        return self

    def set_background(self, background):
        """设置背景信息"""
        self.context['background'] = background
        return self

    def set_constraints(self, constraints):
        """设置约束条件"""
        self.context['constraints'] = constraints
        return self

    def set_goal(self, goal):
        """设置目标"""
        self.context['goal'] = goal
        return self

    def build(self, task):
        """构建完整prompt"""
        parts = []

        if 'role' in self.context:
            parts.append(f"角色：{self.context['role']}")

        if 'background' in self.context:
            parts.append(f"\n背景：\n{self.context['background']}")

        if 'goal' in self.context:
            parts.append(f"\n目标：{self.context['goal']}")

        if 'constraints' in self.context:
            parts.append("\n约束：")
            for c in self.context['constraints']:
                parts.append(f"- {c}")

        parts.append(f"\n任务：\n{task}")

        return '\n'.join(parts)

# 使用示例
builder = ContextBuilder()

prompt = builder \
    .set_role("专业的财务顾问") \
    .set_background("客户是一名30岁的工程师，月收入3万，有20万存款") \
    .set_goal("帮助客户规划投资，实现财务自由") \
    .set_constraints([
        "风险偏好：保守",
        "投资期限：10年",
        "不投资加密货币",
    ]) \
    .build("制定一个投资组合方案")

print(prompt)

# JSON输出
json_prompt = """
从文本中提取人名、地名和组织名。

文本：{text}

输出格式（JSON）：
{{
  "persons": ["人名1", "人名2"],
  "locations": ["地名1", "地名2"],
  "organizations": ["组织名1", "组织名2"]
}}
"""

# 使用
import json

def extract_entities(text, model="gpt-4"):
    """提取实体（JSON格式）"""
    prompt = json_prompt.format(text=text)

    # 调用API（示例）
    # response = call_llm(prompt, model)
    # entities = json.loads(response)

    # 模拟返回
    return {
        "persons": ["张三", "李四"],
        "locations": ["北京", "上海"],
        "organizations": ["阿里巴巴", "腾讯"]
    }

# 测试
text = "张三在北京的阿里巴巴工作，李四在上海的腾讯。"
entities = extract_entities(text)
print(json.dumps(entities, ensure_ascii=False, indent=2))

# Markdown输出
markdown_prompt = """
为产品写一篇评测文章。

产品：{product_name}

输出格式（Markdown）：
# 产品名称

## 概述
[简短介绍]

## 优点
- 优点1
- 优点2

## 缺点
- 缺点1
- 缺点2

## 评分
[1-10分]
"""

# 表格格式
table_prompt = """
比较以下编程语言的特点。

语言：Python, Java, JavaScript

输出格式（Markdown表格）：
| 语言 | 类型 | 主要用途 | 难度 | 性能 |
|------|------|----------|------|------|
| ... | ... | ... | ... | ... |
"""

def validate_output_format(output, expected_format):
    """
    验证输出格式

    Args:
        output: 模型输出
        expected_format: 期望格式（'json', 'markdown', 'csv'）

    Returns:
        是否符合格式
    """
    try:
        if expected_format == 'json':
            json.loads(output)
            return True

        elif expected_format == 'markdown':
            # 检查Markdown标记
            has_headers = '#' in output
            return has_headers

        elif expected_format == 'csv':
            # 检查CSV格式
            lines = output.strip().split('\n')
            if len(lines) < 2:
                return False

            # 检查列数一致
            n_cols = len(lines[0].split(','))
            return all(len(line.split(',')) == n_cols for line in lines)

        else:
            return False

    except Exception:
        return False

# 测试
outputs = {
    'json': '{"name": "test", "value": 123}',
    'markdown': '# Title\n## Section\nContent',
    'csv': 'name,age\nAlice,30\nBob,25',
}

for format_type, output in outputs.items():
    is_valid = validate_output_format(output, format_type)
    print(f"{format_type}: {'' if is_valid else '✗'}")

class PromptOptimizer:
    """Prompt优化器"""

    def __init__(self):
        self.history = []

    def test_prompt(self, prompt, test_cases, llm_func):
        """
        测试prompt

        Args:
            prompt: 要测试的prompt
            test_cases: 测试用例列表
            llm_func: LLM调用函数

        Returns:
            测试结果
        """
        results = []

        for case in test_cases:
            # 填充prompt
            filled_prompt = prompt.format(**case['input'])

            # 调用LLM
            output = llm_func(filled_prompt)

            # 评估
            is_correct = output.strip() == case['expected'].strip()

            results.append({
                'input': case['input'],
                'expected': case['expected'],
                'actual': output,
                'correct': is_correct,
            })

        # 计算准确率
        accuracy = sum(r['correct'] for r in results) / len(results)

        # 记录历史
        self.history.append({
            'prompt': prompt,
            'accuracy': accuracy,
            'results': results,
        })

        return {
            'accuracy': accuracy,
            'results': results,
        }

    def suggest_improvements(self, results):
        """根据结果建议改进"""
        suggestions = []

        # 分析失败案例
        failed_cases = [r for r in results if not r['correct']]

        if not failed_cases:
            return ["Prompt表现完美！"]

        # 常见问题模式
        if len(failed_cases) > len(results) / 2:
            suggestions.append("准确率过低，考虑添加更多示例（few-shot）")

        # 检查是否格式问题
        format_issues = sum(
            1 for r in failed_cases
            if type(r['actual']) != type(r['expected'])
        )
        if format_issues > 0:
            suggestions.append("添加明确的输出格式说明")

        # 检查是否理解问题
        suggestions.append("为失败案例添加针对性的示例")

        return suggestions

    def get_best_prompt(self):
        """获取历史最佳prompt"""
        if not self.history:
            return None

        return max(self.history, key=lambda h: h['accuracy'])

# 使用示例
def mock_llm(prompt):
    """模拟LLM调用"""
    # 简单的规则模拟
    if '积极' in prompt or '好' in prompt or '棒' in prompt:
        return "积极"
    elif '消极' in prompt or '差' in prompt or '糟' in prompt:
        return "消极"
    else:
        return "中性"

optimizer = PromptOptimizer()

# 测试用例
test_cases = [
    {
        'input': {'text': '这部电影真好看！'},
        'expected': '积极'
    },
    {
        'input': {'text': '太糟糕了。'},
        'expected': '消极'
    },
    {
        'input': {'text': '还可以吧。'},
        'expected': '中性'
    },
]

# 版本1：简单prompt
prompt_v1 = "文本：{text}\n情感："

results_v1 = optimizer.test_prompt(prompt_v1, test_cases, mock_llm)
print(f"版本1准确率: {results_v1['accuracy']:.0%}")

suggestions = optimizer.suggest_improvements(results_v1['results'])
print("改进建议：")
for s in suggestions:
    print(f"- {s}")

# 版本2：改进后的prompt
prompt_v2 = """
分类文本的情感为：积极、消极或中性。

文本：{text}
情感：
"""

results_v2 = optimizer.test_prompt(prompt_v2, test_cases, mock_llm)
print(f"\n版本2准确率: {results_v2['accuracy']:.0%}")

# 获取最佳prompt
best = optimizer.get_best_prompt()
print(f"\n最佳prompt (准确率{best['accuracy']:.0%}):")
print(best['prompt'])

# 不使用CoT
simple_prompt = """
问题：一个数字是12的倍数，也是15的倍数，这个数字最小是多少？
答案：
"""

# 使用CoT
cot_prompt = """
问题：一个数字是12的倍数，也是15的倍数，这个数字最小是多少？

让我们一步步思考：
1. 首先，找出12和15的质因数分解
2. 然后，找出它们的最小公倍数
3. 最后，给出答案

解答：
"""

# CoT with examples (Few-shot CoT)
few_shot_cot = """
问题：一个数字是6的倍数，也是8的倍数，这个数字最小是多少？

解答：
让我们一步步思考：
1. 6 = 2 × 3
2. 8 = 2³
3. 最小公倍数 = 2³ × 3 = 24
答案：24

问题：一个数字是12的倍数，也是15的倍数，这个数字最小是多少？

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

def add_chain_of_thought(problem, domain='math'):
    """
    为问题添加思维链提示

    Args:
        problem: 问题描述
        domain: 领域（math, logic, coding等）

    Returns:
        添加CoT的prompt
    """
    cot_templates = {
        'math': "让我们一步步解决这个数学问题：\n1. 理解问题\n2. 列出已知条件\n3. 选择合适的方法\n4. 计算\n5. 验证答案",

        'logic': "让我们逻辑地分析这个问题：\n1. 列出所有前提\n2. 识别逻辑关系\n3. 推导结论\n4. 检查推理是否有效",

        'coding': "让我们一步步设计这个程序：\n1. 理解需求\n2. 分解问题\n3. 设计算法\n4. 编写代码\n5. 测试验证",

        'general': "让我们系统地思考这个问题：\n1. 分析问题\n2. 收集信息\n3. 制定方案\n4. 执行\n5. 总结",
    }

    template = cot_templates.get(domain, cot_templates['general'])

    return f"{problem}\n\n{template}\n\n解答："

# 使用示例
problems = [
    ("计算 15 + 28 × 3", "math"),
    ("如果所有A是B，所有B是C，那么所有A是C吗？", "logic"),
    ("写一个函数判断回文字符串", "coding"),
]

for problem, domain in problems:
    prompt = add_chain_of_thought(problem, domain)
    print(f"=== {domain.upper()} ===")
    print(prompt)
    print()

def self_consistency(
    prompt,
    llm_func,
    n_samples=5,
    temperature=0.7,
):
    """
    Self-Consistency采样

    Args:
        prompt: 输入prompt
        llm_func: LLM调用函数
        n_samples: 采样次数
        temperature: 温度参数

    Returns:
        最一致的答案
    """
    from collections import Counter

    # 多次采样
    responses = []
    for _ in range(n_samples):
        response = llm_func(prompt, temperature=temperature)
        responses.append(response.strip())

    # 统计频率
    counter = Counter(responses)

    # 返回最常见的答案
    most_common = counter.most_common(1)[0]

    return {
        'answer': most_common[0],
        'confidence': most_common[1] / n_samples,
        'all_responses': responses,
        'distribution': dict(counter),
    }

# 模拟示例
def mock_llm_with_variance(prompt, temperature=0.7):
    """模拟有方差的LLM输出"""
    import random

    # 模拟：80%概率正确答案，20%其他答案
    if random.random() < 0.8:
        return "60"
    else:
        return random.choice(["61", "59", "62"])

# 使用
prompt = """
问题：一个数字是12的倍数，也是15的倍数，这个数字最小是多少？

让我们一步步思考：
1. 12 = 2² × 3
2. 15 = 3 × 5
3. LCM = 2² × 3 × 5 = 60

答案：
"""

result = self_consistency(prompt, mock_llm_with_variance, n_samples=10)

print(f"最终答案: {result['answer']}")
print(f"置信度: {result['confidence']:.0%}")
print(f"所有答案: {result['all_responses']}")
print(f"分布: {result['distribution']}")

class TreeOfThoughts:
    """思维树"""

    def __init__(self, llm_func):
        self.llm_func = llm_func
        self.tree = {}

    def generate_thoughts(self, problem, parent_id=None, n_thoughts=3):
        """
        生成思路

        Args:
            problem: 问题
            parent_id: 父节点ID
            n_thoughts: 生成思路数量

        Returns:
            思路列表
        """
        prompt = f"""
        问题：{problem}

        请生成{n_thoughts}个不同的解题思路（仅列出思路，不需要完整解答）：

        思路1：
        思路2：
        思路3：
        """

        response = self.llm_func(prompt)

        # 解析思路
        thoughts = []
        lines = response.strip().split('\n')

        for line in lines:
            if line.strip().startswith('思路'):
                thought = line.split('：', 1)[1].strip()
                thoughts.append(thought)

        return thoughts

    def evaluate_thought(self, thought, problem):
        """
        评估思路质量

        Args:
            thought: 思路
            problem: 原问题

        Returns:
            评分（0-10）
        """
        prompt = f"""
        问题：{problem}

        思路：{thought}

        请评估这个思路的质量（0-10分），考虑：
        - 是否正确
        - 是否高效
        - 是否完整

        仅输出分数（0-10）：
        """

        response = self.llm_func(prompt)

        try:
            score = float(response.strip())
            return min(max(score, 0), 10)
        except:
            return 5.0  # 默认中等分数

    def solve_with_thought(self, thought, problem):
        """
        使用特定思路解决问题

        Args:
            thought: 选定的思路
            problem: 问题

        Returns:
            完整解答
        """
        prompt = f"""
        问题：{problem}

        采用以下思路解决：
        {thought}

        请给出完整的解答过程和最终答案：
        """

        return self.llm_func(prompt)

    def solve(self, problem, max_depth=2):
        """
        使用ToT解决问题

        Args:
            problem: 问题
            max_depth: 最大深度

        Returns:
            最佳解答
        """
        # 生成初始思路
        thoughts = self.generate_thoughts(problem)

        # 评估每个思路
        evaluated = []
        for thought in thoughts:
            score = self.evaluate_thought(thought, problem)
            evaluated.append({
                'thought': thought,
                'score': score,
            })

        # 选择最佳思路
        best_thought = max(evaluated, key=lambda x: x['score'])

        print(f"选择的思路（评分{best_thought['score']}）:")
        print(best_thought['thought'])
        print()

        # 使用最佳思路求解
        solution = self.solve_with_thought(best_thought['thought'], problem)

        return {
            'solution': solution,
            'best_thought': best_thought,
            'all_thoughts': evaluated,
        }

# 模拟使用
def mock_llm_tot(prompt):
    """模拟ToT的LLM"""
    if '生成' in prompt and '思路' in prompt:
        return """
        思路1：直接暴力枚举所有可能
        思路2：使用动态规划优化
        思路3：数学公式直接计算
        """
    elif '评估' in prompt:
        # 给数学公式最高分
        if '数学公式' in prompt:
            return "9"
        elif '动态规划' in prompt:
            return "7"
        else:
            return "5"
    else:
        return "使用数学公式：LCM(12, 15) = 60"

# 使用ToT
tot = TreeOfThoughts(mock_llm_tot)

problem = "一个数字是12的倍数，也是15的倍数，这个数字最小是多少？"
result = tot.solve(problem)

print("最终解答:")
print(result['solution'])

class ReActAgent:
    """ReAct智能体"""

    def __init__(self, llm_func, tools):
        """
        Args:
            llm_func: LLM调用函数
            tools: 可用工具字典
        """
        self.llm_func = llm_func
        self.tools = tools
        self.history = []

    def think(self, question, max_steps=5):
        """
        使用ReAct模式思考

        Args:
            question: 问题
            max_steps: 最大步数

        Returns:
            最终答案
        """
        prompt_template = """
问题：{question}

你可以使用以下工具：
{tools_desc}

请使用以下格式：

思考：[你的推理]
行动：[工具名称]
行动输入：[工具输入]
观察：[工具输出]
... (重复思考/行动/观察)
思考：我现在知道最终答案了
最终答案：[答案]

开始！

问题：{question}
{history}
"""

        tools_desc = '\n'.join([
            f"- {name}: {tool['description']}"
            for name, tool in self.tools.items()
        ])

        for step in range(max_steps):
            # 构建提示
            history_text = '\n'.join(self.history)
            prompt = prompt_template.format(
                question=question,
                tools_desc=tools_desc,
                history=history_text,
            )

            # LLM推理
            response = self.llm_func(prompt)

            # 解析响应
            if '最终答案：' in response:
                # 找到答案
                answer = response.split('最终答案：')[1].strip()
                return {
                    'answer': answer,
                    'steps': self.history,
                }

            # 解析行动
            if '行动：' in response and '行动输入：' in response:
                action = response.split('行动：')[1].split('\n')[0].strip()
                action_input = response.split('行动输入：')[1].split('\n')[0].strip()

                # 执行工具
                if action in self.tools:
                    observation = self.tools[action]['func'](action_input)

                    # 记录历史
                    self.history.append(f"思考：{response.split('思考：')[1].split('行动：')[0].strip()}")
                    self.history.append(f"行动：{action}")
                    self.history.append(f"行动输入：{action_input}")
                    self.history.append(f"观察：{observation}")
                else:
                    self.history.append(f"错误：工具 {action} 不存在")

        return {
            'answer': "无法在限定步数内找到答案",
            'steps': self.history,
        }

# 定义工具
def calculator(expression):
    """计算器工具"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"计算错误：{e}"

def search(query):
    """搜索工具（模拟）"""
    # 模拟搜索结果
    mock_db = {
        "中国人口": "14.1亿（2021年）",
        "美国人口": "3.3亿（2021年）",
        "印度人口": "13.8亿（2021年）",
    }

    for key, value in mock_db.items():
        if key in query:
            return value

    return "未找到相关信息"

# 工具配置
tools = {
    'Calculator': {
        'description': '执行数学计算，输入为Python表达式',
        'func': calculator,
    },
    'Search': {
        'description': '搜索信息，输入为查询关键词',
        'func': search,
    },
}

# 模拟LLM
def mock_llm_react(prompt):
    """模拟ReAct的LLM"""
    if '中国和美国的人口' in prompt:
        if '观察' not in prompt:
            return """
思考：我需要分别查询中国和美国的人口数据
行动：Search
行动输入：中国人口
"""
        elif prompt.count('观察') == 1:
            return """
思考：我已经知道了中国的人口，现在需要查询美国的人口
行动：Search
行动输入：美国人口
"""
        elif prompt.count('观察') == 2:
            return """
思考：我已经有了两国的人口数据，现在可以计算差值
行动：Calculator
行动输入：14.1 - 3.3
"""
        else:
            return """
思考：我现在知道最终答案了
最终答案：中国人口约14.1亿，美国人口约3.3亿，相差约10.8亿。
"""

    return "思考：无法回答这个问题"

# 使用ReAct
agent = ReActAgent(mock_llm_react, tools)

question = "中国和美国的人口相差多少？"
result = agent.think(question)

print("问题:", question)
print("\n推理过程:")
for step in result['steps']:
    print(step)
print("\n最终答案:", result['answer'])

class PromptChain:
    """Prompt链"""

    def __init__(self, llm_func):
        self.llm_func = llm_func
        self.steps = []

    def add_step(self, name, prompt_template, output_key):
        """
        添加步骤

        Args:
            name: 步骤名称
            prompt_template: Prompt模板（可以使用前序步骤的输出）
            output_key: 输出变量名
        """
        self.steps.append({
            'name': name,
            'prompt_template': prompt_template,
            'output_key': output_key,
        })
        return self

    def run(self, initial_input):
        """
        运行链

        Args:
            initial_input: 初始输入

        Returns:
            所有步骤的输出
        """
        context = {'input': initial_input}

        for step in self.steps:
            print(f"执行步骤: {step['name']}")

            # 填充模板
            prompt = step['prompt_template'].format(**context)

            # 调用LLM
            output = self.llm_func(prompt)

            # 保存输出
            context[step['output_key']] = output.strip()

            print(f"输出: {output[:100]}...\n")

        return context文章生成链
def create_article_chain(llm_func):
    """创建文章生成链"""
    chain = PromptChain(llm_func)

    # 步骤1：生成大纲
    chain.add_step(
        name="生成大纲",
        prompt_template="""
        为以下主题生成文章大纲：

        主题：{input}

        要求：
        - 3-5个主要章节
        - 每个章节2-3个子要点

        大纲：
        """,
        output_key="outline"
    )

    # 步骤2：扩展第一章节
    chain.add_step(
        name="写第一章节",
        prompt_template="""
        根据以下大纲，详细写第一章节的内容：

        大纲：
        {outline}

        第一章节内容（300字）：
        """,
        output_key="section1"
    )

    # 步骤3：写引言
    chain.add_step(
        name="写引言",
        prompt_template="""
        为文章写一个引人入胜的引言：

        主题：{input}
        大纲：{outline}
        第一章节：{section1}

        引言（100字）：
        """,
        output_key="intro"
    )

    # 步骤4：写总结
    chain.add_step(
        name="写总结",
        prompt_template="""
        为文章写总结：

        主题：{input}
        大纲：{outline}

        总结（100字）：
        """,
        output_key="conclusion"
    )

    return chain

# 模拟LLM
def mock_llm_chain(prompt):
    """模拟链式LLM"""
    if '生成文章大纲' in prompt or '生成大纲' in prompt:
        return """
1. AI的定义和历史
   - 什么是AI
   - AI的发展历程
   - 重要里程碑

2. AI的主要技术
   - 机器学习
   - 深度学习
   - 自然语言处理

3. AI的应用
   - 医疗健康
   - 金融科技
   - 自动驾驶
        """

    elif '第一章节' in prompt:
        return """
人工智能（AI）是指由机器展现出的智能行为。自1950年代诞生以来，AI经历了多次起伏。
图灵测试的提出标志着AI研究的开始，随后专家系统、机器学习、深度学习相继出现。
近年来，深度学习的突破使AI在图像识别、语音识别等领域超越人类水平。
        """

    elif '引言' in prompt:
        return """
人工智能正在改变世界。从智能手机到自动驾驶，AI技术已经渗透到我们生活的方方面面。
本文将全面介绍AI的发展历史、核心技术和实际应用，帮助读者理解这个正在塑造未来的技术。
        """

    elif '总结' in prompt:
        return """
AI技术正处于快速发展阶段，它带来了巨大机遇也伴随着挑战。
理解AI的原理和应用，对于把握未来发展方向至关重要。
让我们拥抱AI，共同创造更美好的未来。
        """

    return "生成的内容..."

# 使用链
chain = create_article_chain(mock_llm_chain)

result = chain.run("人工智能的发展和应用")

print("=" * 50)
print("最终结果：")
print("\n引言：")
print(result['intro'])
print("\n第一章节：")
print(result['section1'])
print("\n总结：")
print(result['conclusion'])

ARTICLE_TEMPLATE = """
写一篇关于【{topic}】的文章。

要求：
- 字数：{word_count}字
- 目标读者：{audience}
- 语气：{tone}
- 结构：{structure}

文章：
"""

# 使用示例
prompt = ARTICLE_TEMPLATE.format(
    topic="量子计算的未来",
    word_count=1000,
    audience="科技爱好者",
    tone="专业但通俗易懂",
    structure="引言、现状、挑战、展望、总结"
)

BLOG_POST_TEMPLATE = """
写一篇博客文章：

标题：{title}
关键词：{keywords}
目标：{goal}

要求：
- SEO优化（包含关键词）
- 吸引眼球的开头
- 结构清晰（使用小标题）
- 包含实用建议
- 以号召行动结尾

博客内容：
"""

SOCIAL_MEDIA_TEMPLATE = """
为【{platform}】平台创作一条帖子：

主题：{topic}
目标：{goal}
字数限制：{max_chars}字符
语气：{tone}

要求：
- 吸引注意力
- 包含话题标签
- 鼓励互动
- {platform_specific}

文案：
"""Twitter
twitter_prompt = SOCIAL_MEDIA_TEMPLATE.format(
    platform="Twitter",
    topic="新产品发布",
    goal="增加关注和转发",
    max_chars=280,
    tone="兴奋、友好",
    platform_specific="使用emoji，创建话题标签"
)

PRODUCT_DESCRIPTION_TEMPLATE = """
为以下产品撰写吸引人的描述：

产品名称：{product_name}
产品类型：{product_type}
目标客户：{target_audience}
主要特点：
{features}

要求：
- 突出独特卖点
- 强调客户利益
- 包含规格参数
- 以购买号召结尾

产品描述：
"""

EMAIL_TEMPLATE = """
撰写一封【{email_type}】邮件：

收件人：{recipient}
目的：{purpose}
语气：{tone}
关键信息：
{key_points}

要求：
- 主题行醒目
- 开头有礼貌
- 正文简洁明了
- 结尾得体
- 包含明确的行动呼吁

邮件：
"""商务邮件
business_email = EMAIL_TEMPLATE.format(
    email_type="商务合作提案",
    recipient="潜在客户",
    purpose="提出合作方案",
    tone="专业、友好",
    key_points="- 介绍我们的服务\n- 说明合作价值\n- 提议会面讨论"
)

SENTIMENT_ANALYSIS_TEMPLATE = """
分析以下文本的情感倾向：

文本：{text}

请提供：
1. 总体情感：积极/消极/中性
2. 情感强度：1-10分
3. 情感词汇：列出关键的情感表达词
4. 细粒度情感：喜悦/悲伤/愤怒/恐惧/惊讶等

输出格式（JSON）：
{{
  "overall": "积极/消极/中性",
  "intensity": 0-10,
  "keywords": ["词1", "词2"],
  "emotions": {{"喜悦": 0.8, "悲伤": 0.1}}
}}
"""

SUMMARIZATION_TEMPLATE = """
为以下文本生成摘要：

文本：
{text}

要求：
- 长度：{summary_length}字
- 类型：{summary_type}
- 保留：{key_points}

摘要：
"""

# 类型：
# - extractive: 抽取式（从原文选句子）
# - abstractive: 生成式（重新组织）
# - bullet_points: 要点列表

KEYWORD_EXTRACTION_TEMPLATE = """
从以下文本中提取关键词：

文本：{text}

要求：
- 提取{num_keywords}个关键词
- 按重要性排序
- 包含词性标注
- 给出相关性分数（0-1）

输出格式（JSON）：
{{
  "keywords": [
    {{"word": "关键词1", "pos": "名词", "score": 0.95}},
    {{"word": "关键词2", "pos": "动词", "score": 0.88}}
  ]
}}
"""

NER_TEMPLATE = """
从文本中识别并提取所有命名实体：

文本：{text}

实体类型：
- PERSON: 人名
- ORG: 组织/公司名
- LOC: 地名
- DATE: 日期
- MONEY: 金额
- PRODUCT: 产品名

输出格式（JSON）：
{{
  "entities": [
    {{"text": "实体文本", "type": "类型", "start": 0, "end": 5}}
  ]
}}
"""

TEXT_CLASSIFICATION_TEMPLATE = """
将以下文本分类到最合适的类别：

文本：{text}

可选类别：
{categories}

输出：
- 主要类别：[类别名]
- 置信度：[0-1]
- 理由：[简短说明]

{examples}

分类：
"""

CODE_GENERATION_TEMPLATE = """
编写一个{language}程序：

功能：{functionality}

要求：
{requirements}

请提供：
1. 完整代码
2. 代码注释
3. 使用示例
4. 时间复杂度分析

代码：
```{language}
"""

CODE_EXPLANATION_TEMPLATE = """
解释以下代码的功能和原理：

```{language}
{code}

DEBUG_HELPER_TEMPLATE = """
帮助调试以下代码：

代码：
```{language}
{code}

SQL_GENERATION_TEMPLATE = """
根据需求生成SQL查询：

数据库结构：
{schema}

需求：{requirement}

要求：
- 查询高效
- 包含必要的索引提示
- 添加注释
- 考虑边界情况

SQL：
```sql
"""

DATA_CLEANING_TEMPLATE = """
分析数据质量并提供清洗建议：

数据样本：
{data_sample}

数据问题：
{issues}

请提供：
1. 问题诊断：识别数据质量问题
2. 清洗方案：具体的处理步骤
3. Python代码：实现数据清洗
4. 验证方法：如何验证清洗效果

建议：
"""

CONCEPT_EXPLANATION_TEMPLATE = """
解释【{concept}】的概念：

目标受众：{audience}
深度级别：{level}

请包含：
1. 简单定义（一句话）
2. 详细解释（200字）
3. 类比或示例（帮助理解）
4. 实际应用（在哪里会用到）
5. 相关概念（延伸阅读）

解释：
"""

# level: 初学者/中级/高级/专家

LEARNING_PATH_TEMPLATE = """
为学习【{topic}】创建学习路径：

当前水平：{current_level}
目标：{goal}
可用时间：{time_available}

请提供：
1. 学习阶段（分为3-5个阶段）
2. 每个阶段的学习内容
3. 推荐资源（书籍、课程、项目）
4. 里程碑和检查点
5. 预计时间分配

学习路径：
"""

EXERCISE_GENERATION_TEMPLATE = """
为【{topic}】生成练习题：

难度：{difficulty}
数量：{num_exercises}
类型：{exercise_types}

对每道题提供：
1. 题目描述
2. 难度标记
3. 参考答案
4. 解题思路
5. 常见错误

练习题：
"""

# exercise_types: 选择题/填空题/编程题/问答题

STORY_CREATION_TEMPLATE = """
创作一个故事：

类型：{genre}
主题：{theme}
长度：{word_count}字
要素：
- 主角：{protagonist}
- 背景：{setting}
- 冲突：{conflict}

要求：
- 情节引人入胜
- 人物性格鲜明
- 有起承转合
- 结局{ending_type}

故事：
"""

# genre: 科幻/奇幻/悬疑/爱情/历史
# ending_type: 圆满/开放/悲剧/反转

POETRY_TEMPLATE = """
创作一首诗：

主题：{theme}
风格：{style}
形式：{form}
情感：{emotion}

要求：
- 意境优美
- 韵律和谐
- 意象生动
- {special_requirement}

诗歌：
"""

# style: 古典/现代/自由诗
# form: 五言/七言/十四行诗/俳句

SLOGAN_TEMPLATE = """
为产品创作广告语：

产品：{product}
目标客户：{target_audience}
产品特点：{features}
品牌定位：{brand_positioning}

要求：
- 简短有力（不超过{max_words}字）
- 朗朗上口
- 突出卖点
- 易于记忆
- 创意独特

请生成5个备选广告语，并说明每个的创意点。

广告语：
"""

SWOT_ANALYSIS_TEMPLATE = """
对【{company}】进行SWOT分析：

背景信息：
{context}

请分析：

## 优势（Strengths）
- 内部优势1
- 内部优势2
...

## 劣势（Weaknesses）
- 内部劣势1
- 内部劣势2
...

## 机会（Opportunities）
- 外部机会1
- 外部机会2
...

## 威胁（Threats）
- 外部威胁1
- 外部威胁2
...

## 战略建议
基于SWOT分析的3-5条战略建议

分析：
"""

MARKET_ANALYSIS_TEMPLATE = """
分析【{market}】市场：

维度：
1. 市场规模：当前规模和增长趋势
2. 市场细分：主要细分市场
3. 竞争格局：主要玩家和市场份额
4. 客户画像：目标客户特征
5. 趋势预测：未来3-5年趋势

数据来源：{data_sources}

输出格式：
- 执行摘要（200字）
- 详细分析（各维度）
- 可视化建议
- 结论和建议

分析报告：
"""

COMPETITOR_ANALYSIS_TEMPLATE = """
对比分析以下竞品：

我方产品：{our_product}
竞品：{competitors}

对比维度：
- 功能对比
- 定价策略
- 目标客户
- 营销策略
- 优势劣势
- 市场定位

输出格式（Markdown表格）：
| 维度 | 我方 | 竞品A | 竞品B |
|------|------|-------|-------|
| ... | ... | ... | ... |

结论：
- 我方差异化优势
- 需要改进的地方
- 应对策略建议

分析：
"""

TRANSLATION_TEMPLATE = """
将以下{source_lang}文本翻译成{target_lang}：

原文：
{text}

领域：{domain}

要求：
- 保持专业术语准确
- 符合目标语言习惯
- 保持原文语气和风格
- 如有歧义，提供多个翻译选项

译文：
"""

# domain: 技术/医学/法律/商务/文学

LOCALIZATION_TEMPLATE = """
将内容本地化为{target_market}市场：

原内容：
{content}

本地化要求：
- 文化适配：避免文化冲突
- 单位换算：{unit_conversions}
- 日期格式：{date_format}
- 俚语替换：使用本地表达
- 法律合规：符合当地法规

本地化内容：
"""

FAQ_GENERATION_TEMPLATE = """
为【{topic}】生成常见问题解答（FAQ）：

背景：{context}

请生成{num_questions}个常见问题，每个包含：
- 问题（用户的角度）
- 详细答案（50-100字）
- 相关链接或参考

格式：
## 问题1：[问题]
**答案：**[答案]
**参考：**[链接]

FAQ：
"""

CUSTOMER_SERVICE_TEMPLATE = """
你是一位专业的客服代表。

公司：{company}
产品/服务：{product}
客户问题：{customer_message}

回复要求：
- 友好、专业的语气
- 先表示理解和同情
- 提供清晰的解决方案
- 如无法立即解决，说明后续步骤
- 以积极的方式结束

客服回复：
"""

BRAINSTORMING_TEMPLATE = """
为【{problem}】进行头脑风暴：

背景：{context}
目标：{goal}
约束：{constraints}

请使用以下创意方法：
1. SCAMPER法（替代、组合、调整、修改、用途、消除、重排）
2. 六顶思考帽
3. 反向思考

生成{num_ideas}个创意想法，每个包含：
- 创意描述
- 创新点
- 可行性（1-10分）
- 潜在影响

创意：
"""

PROBLEM_REFRAMING_TEMPLATE = """
重新定义问题：

原始问题：{problem}

请从以下角度重新描述问题：
1. 用户视角：用户真正想解决什么？
2. 系统视角：系统层面的根本原因？
3. 未来视角：5年后这个问题是什么样？
4. 反向视角：如果我们想让问题更严重，会怎么做？

每个视角的重构：
1. [视角]
   问题重述：[...]
   新洞察：[...]

重构后，建议：
- 优先解决的核心问题
- 新的解决思路

重构：
"""

MATH_PROBLEM_TEMPLATE = """
解决以下数学问题：

问题：{problem}

要求：
1. 理解问题：用自己的话重述问题
2. 制定策略：选择合适的解题方法
3. 执行计算：详细的计算过程
4. 验证答案：检查答案是否合理

解答：

### 理解问题
[重述问题]

### 解题策略
[选择的方法和原因]

### 计算过程
[步骤1]
[步骤2]
...

### 最终答案
[答案]

### 验证
[验证过程]
"""

SCIENCE_EXPLANATION_TEMPLATE = """
解释科学概念/现象：

主题：{topic}
受众：{audience_level}

请按以下结构解释：

## 简单定义
[用最简单的语言定义]

## 工作原理
[解释基本原理]

## 日常例子
[举3个生活中的例子]

## 深入理解
[稍微专业的解释，包含关键术语]

## 常见误解
[澄清常见的错误理解]

## 延伸阅读
[推荐资源]

解释：
"""

REWRITING_TEMPLATE = """
改写以下文本：

原文：
{text}

目标：{goal}
风格：{style}
长度：{length_instruction}

要求：
- {specific_requirements}
- 保持核心意思不变
- 提升可读性
- 修正语法错误

改写后：
"""

# goal: 简化/专业化/口语化/书面化
# style: 正式/非正式/学术/商务/创意
# length_instruction: 保持不变/缩短50%/扩展2倍

GRAMMAR_CORRECTION_TEMPLATE = """
纠正以下文本的语法错误：

原文：
{text}

请：
1. 标出所有错误
2. 提供修正后的文本
3. 解释每个错误的类型和修正原因

输出格式：

## 错误列表
1. 原文："[错误片段]"
   错误类型：[语法/拼写/标点/用词]
   修正："[正确版本]"
   原因：[简短解释]

## 修正后全文
[完整的正确文本]

修正：
"""

FORMAT_CONVERSION_TEMPLATE = """
将内容从{source_format}转换为{target_format}：

原内容：
{content}

转换要求：
- 保持信息完整
- 符合目标格式规范
- 优化可读性
- {special_requirements}

转换后：
"""

# 示例格式：
# Markdown <-> HTML
# JSON <-> XML
# 表格 <-> 列表
# 代码 <-> 伪代码

PROS_CONS_TEMPLATE = """
分析【{decision}】的利弊：

背景：
{context}

考虑因素：
{factors}

请提供：

## 优点（Pros）
1. [优点1]
   - 详细说明
   - 影响程度：[高/中/低]
2. [优点2]
   ...

## 缺点（Cons）
1. [缺点1]
   - 详细说明
   - 风险程度：[高/中/低]
2. [缺点2]
   ...

## 量化评分
- 总体评分：[1-10]
- 推荐指数：[1-10]

## 建议
[综合建议]

分析：
"""

OPTION_COMPARISON_TEMPLATE = """
对比以下方案：

方案A：{option_a}
方案B：{option_b}
方案C：{option_c}

对比维度：
{comparison_dimensions}

输出格式：

## 对比表格
| 维度 | 方案A | 方案B | 方案C |
|------|-------|-------|-------|
| ... | ... | ... | ... |

## 详细分析
### 方案A
优势：[...]
劣势：[...]
适用场景：[...]

### 方案B
[同上结构]

### 方案C
[同上结构]

## 推荐
情况1：[推荐方案X，原因]
情况2：[推荐方案Y，原因]

对比：
"""

RECOMMENDATION_TEMPLATE = """
基于用户画像提供个性化推荐：

用户信息：
{user_profile}

需求：{need}

候选项：
{candidates}

请为每个候选项评分（0-100）并说明：
1. 推荐理由
2. 匹配度分析
3. 注意事项

输出格式：

## 推荐排名
1. [候选项1]（评分：95）
   - 推荐理由：[...]
   - 匹配分析：[...]
   - 注意：[...]

2. [候选项2]（评分：88）
   ...

推荐：
"""

INTEREST_DISCOVERY_TEMPLATE = """
基于用户行为发现潜在兴趣：

用户历史行为：
{behavior_history}

已知兴趣：
{known_interests}

请分析：
1. 潜在兴趣点（5-10个）
2. 每个兴趣的置信度（0-1）
3. 推荐理由
4. 可以尝试的相关活动/内容

输出格式（JSON）：
{{
  "interests": [
    {{
      "interest": "兴趣名称",
      "confidence": 0.85,
      "reason": "基于用户行为X推断",
      "recommendations": ["推荐1", "推荐2"]
    }}
  ]
}}

分析：
"""

MEETING_MINUTES_TEMPLATE = """
根据会议记录生成会议纪要：

会议记录：
{meeting_transcript}

会议信息：
- 日期：{date}
- 参与者：{participants}
- 主题：{topic}

纪要格式：

# 会议纪要

## 基本信息
- 时间：{date}
- 参与人：{participants}
- 主题：{topic}

## 讨论要点
1. [要点1]
2. [要点2]
...

## 决议事项
1. [决议1]
2. [决议2]
...

## 行动计划
| 任务 | 负责人 | 截止日期 | 状态 |
|------|--------|----------|------|
| ... | ... | ... | ... |

## 下次会议
- 时间：[...]
- 议题：[...]

纪要：
"""