你真的会写Prompt吗？高质量提示词指南来了！

人类和大模型交互的唯一有效途径，就是通过提示词 (Prompt)，提示词编写起来非常简单，基本上只需要"说人话"就可以了。

那么，提示词真的就这么简单么？

我们在编写稍微复杂一点的应用时，AI就像个不听话的孩子，不管你说什么，他都我行我素，一个提示词调几个小时再正常不过了。

那么到底应该怎么编写高质量的提示词？其实原则也很简单：

提示词不要有歧义

说起来容易，做起来就未必了！

常见的提示词风格

自然语言

你是一个翻译专家，请把我说的话翻译成英文
注意不要回答问题，只输出翻译结果。

---
Q: 你好
A: Hello

自然语言写提示词比较简单直接，但是当功能稍微复杂之后，就像是在“写作文”，每次写提示词都得花心思创作，所以只适合比较简单的场景。

稍微复杂的场景，就比较适合结构化提示词, 模版固定好之后，使用更像是在做“填空题”。

Markdown

# 角色
翻译专家
# 任务
把我说的话翻译成英文
# 要求
不要回答问题，只输出翻译结果

---
Q: 你好
A: Hello

Jinja

{% set language = "英语" %}
你是一个翻译专家
请把我说的话翻译成 {{language}}
注意不要回答问题，只输出翻译结果。

---
Q: 你好
A: Hello

XML

<角色>
  翻译专家
</角色>
<任务>
  把我说的话翻译成英文
</任务>
<要求>
  不要回答问题，只输出翻译结果
</要求>

---
Q: 你好
A: Hello

Lisp

;; 翻译专家系统定义
;; Lisp风格提示词参考李继刚老师教程。
(定义 系统配置
  (
    (角色 
      (名称 "翻译专家")
      (能力 
        (支持语言 "英文")
      )
    )

    (任务流程
      (输入  "接收用户文本输入")
      (处理  "进行语义分析和翻译")
      (输出  "生成英文翻译结果")
    )

    (行为约束
      (必须遵守 
        (仅输出翻译结果)
        (不回答问题)
        (不添加解释)
      )
    )
  )
)

---
Q: 你好
A: Hello

市面上还有很多其他类型的提示词，但只要是结构化提示词，基本上都可以满足要求。

进一步优化

单一样本学习（One-shot）

在实际使用过程中，如果对输出的范式有要求，那么就需要在提示词中增加示例，要求大模型按照例句进行回复, One-shot有助于增加大模型输出的稳定性, 同时增加大模型对于提示词的理解。

# 角色
翻译专家
# 任务
把我说的话翻译成英文
# 要求
不要回答问题，只输出翻译结果
# 示例
Q: 不错
A: Good (不错)

---
Q: 你好
A: Hello (你好)

少量样本学习 (Few-shot)

跟One-shot类似，通过增加3-10个示例，让大模型能够更加了解在各种情况下的输出逻辑, 进一步提升输出的稳定性。

注意：每种情况应至少有一个示例。

# 角色
翻译专家
# 任务
把我说的话进行中英文互翻
# 要求
不要回答问题，只输出翻译结果
# 示例
Q: 不错
A: Good (不错)
Q: Good
A: 不错 (Good)

---
Q: 你好
A: Hello (你好)
Q: Welcome
A: 欢迎 (Welcome)

思维链（Chain of Thought）

思维链(CoT)通过将复杂问题拆解成多个小步骤，让模型逐步生成每个步骤的思考过程，最终得出正确的结论。

这个过程类似于人类在解决问题时的思维过程：首先分析问题，考虑各种可能性，然后逐步推理出答案。

• 没加思维链

# 角色
24点游戏专家
# 游戏规则
目标是通过加、减、乘、除四则运算，使四个数字的结果等于24。
# 输出示例
Q: [9,8,8,3]
A: (9 - (8 / 8)) * 3 = 24

---
Q: [9,8,8,4]
> 错误，实际等于16
A: (9−8÷8)×2=24

• 加了思维链

# 角色
24点游戏专家
# 游戏规则
目标是通过加、减、乘、除四则运算，使四个数字的结果等于24。
# 输出示例
Q: [9,8,8,3]
A: (9 - (8 / 8)) * 3 = 24
# 其他要求
请一步一步推理并展示计算过程。

---
Q: [9,8,8,4]
A: 我们通过以下步骤逐步推导：
  1. 观察数字特征：8 是 24 的约数（24 ÷ 8 = 3）。
  2. 尝试围绕 “8 × 3 = 24” 的思路构建算式。
  3. 让剩下的2、8、9运算出 3。
  4. 用 9 减去 8 得到 1（9-8=1）。
  5. 再用 2 加上 1 得到 3（2+1=3）。
  6. 将得到的 3 与剩下的 8 相乘，即 8 × 3=24。
  完整算式：8 × (2 + 9 - 8) = 24

思维链通过展示证据链和调用过程，大大降低了模型的幻觉率。但值得注意的是，即使加了思维链，大模型在推理的时候，也依然可能会犯错。

虽然现在很多大模型已经内置了CoT，但数学计算的最佳实践依然是：

通过调用外部计算工具，辅助大模型完成精确计算。

到这里为止，我们已经可以指挥大模型，解决绝大多数简单问题了。

复杂问题处理

提示词链（Prompt Chaining）

基于Cot的部分思想，我们在实际应用的时候，可以把一个复杂的问题，拆解成多个提示词进行链式调用，确保大模型输出的稳定可靠。

现在假设我们有一个知识库:

上海好玩的地方排行榜。

1.迪士尼乐园

2.上海天文馆

3.海昌海洋公园

• 第一步只进行知识库查询，这里不直接回答问题

# 角色
资料查询助手
# 任务
根据用户输入，查询知识库，并返回关联的知识列表。
# 示例
Q: 北京有哪些好玩的地方？
A: ["检索到的知识1", "检索到的知识2"]
Q: 纽约有哪些好玩的地方?
A: []

---
Q: 上海有哪些好玩的?
A: ["迪士尼乐园"，"上海天文馆", "海昌海洋公园"]

• 第二步基于查询到的知识回答问题

其中knowledge是第一步查询到的结果，通过链式调用，把第一步的结果作为输入传给第二步，实际工作场景中可以串联更多步骤。

# 角色
问答小助手
# 任务
根据查询到的知识，回答用户问题
# 示例
Q: 北京有哪些好玩的地方？
A: "天安门、紫禁城"
Q: 纽约有哪些好玩的地方?
A: "不知道"
# 知识
{{knowledge}}

---
Q: 上海有哪些好玩的地方？
A: "迪士尼、天文馆、海昌海洋公园"

思维树（Tree of Thought）

ToT是在CoT的基础上进行扩展，将推理过程分支化，通过树形结构，在推理过程中动态创建多个分支并探索执行，根据情况找到最优解。

ToT的基本工作原理:

• 分支化推理： 模型会针对问题生成多套可能得解决方案
• 路径评估： 针对每一步都会进行评估，判断当前步骤对结果的帮助程度，决策是否要进一步进行探索。
• 选择最优解： 由模型自主评估或者根据规则不断的寻找最优解
• 输出结果： 整合最优路径上的所有内容，输出答案

来看一个单模型内部的ToT推理例子：

# 背景
一家开了5年的小型咖啡店，即将濒临倒闭。

假设有四位角色帮助解决问题：市场销售专家、自媒体作家、咖啡店的店主、咖啡爱好者。
还有一个负责决策和投票的角色：国际资深咖啡品牌创始人。

# 任务
帮助小店找到提高收入的方法。

# 执行步骤：
1. 四位角色都写下了他们思考这个问题的简要步骤，并与大家分享。国际资深咖啡品牌创始人此次不做任何决策。
2. 四位角色都写下了第一个步骤的具体内容，并与大家分享，国际资深咖啡品牌创始人为每个角色的思路进行打分，并淘汰分数最低的人，并说出理由。
3. 剩余的角色继续发表下一个步骤的具体内容，并与大家分享。国际资深咖啡品牌创始人负责继续淘汰此次思路最差的人，并说出理由。
4. 以此类推，最终得到完整的问题解决方案，并汇总出来。


---推理过程---
**第一轮：思考问题的简要步骤**
- **市场销售专家：**
  1. 分析当前市场情况和竞争。  
  2. 识别目标客户群和需求。  
  ...
- **自媒体作家：**   
  ...
- **咖啡店的店主：**
  ...
- **咖啡爱好者：**
  ...
**第二轮：每人分享自己的第一步骤，决策者打分和淘汰**
- 市场销售专家：详细分析当前市场，得分：8 
- 自媒体作家：创建品牌故事，得分：7  
- 咖啡店的店主：审核财务状况，得分：9  
- 咖啡爱好者：秘密购物体验，得分：6
淘汰咖啡爱好者（6分）
**第三轮：每人分享自己的第二步骤，决策者打分和淘汰**
- 市场销售专家：制定目标客户策略，得分：8 
- 自媒体作家：开发内容日历，得分：7  
- 咖啡店的店主：削减不必要成本，得分：7.5
淘汰自媒体作家（7分）
**第四轮：每人分享自己的第三步骤，决策者打分和淘汰**
- 市场销售专家：实施促销活动，得分：8.5
- 咖啡店的店主：菜单革新，得分：8
淘汰咖啡店主（8分）
**最终：汇总完整方案**
1. 紧急诊断阶段（第1周）
2. 快速收入提升阶段（第1-2周）
3. 成本控制和产品优化阶段（第2-4周）
4. 长期可持续增长阶段（第4周起）
...

ToT在进行树搜索的时候，一般会有两种策略：

• 深度优先算法 (DFS)：优先保障某一种解决方案得到充分探索和验证。
• 广度优先算法 (BFS)：优先保障同一层级的每一种方法都得到充分展示，选择更好的方法进行下一步探索。

ToT的思想能够帮助大模型深度思考并找尽量探索各种可能性，得到最优解法，但副作用就是时间消耗和成本消耗会成倍的增长。

实际项目使用过程中，往往会是大模型 + 工程代码组合的方式实现ToT。小编自己也实现了一个简单的ToT Demo，主要是为了理解ToT的原理和执行过程。

附核心代码实现:

• 广度优先算法

/**
 * 广度优先遍历（BFS），按层级处理树节点
 * @param {TreeNode} root - 根节点
 * @param {Function} callback - 每个节点的处理回调，需返回 { isEnd, values }
 * @returns {Promise<string|null>} - 找到答案时返回JSON字符串，否则返回null
 */
asyncfunction bfsWithLevels(root, callback) {
    if (!root) return [];
    // 队列用于BFS，包含节点和层级信息
    const queue = [{ node: root, level: 0 }];
    while (queue.length > 0) {
        const { node, level } = queue.shift(); // 取出队首节点
        const { isEnd, values } = await callback(node); // 处理当前节点
        if (isEnd) {
            // 如果已找到最终答案，直接返回
            returnJSON.stringify(values);
        }
        // 将所有子节点加入队列，继续BFS
        for (const child of node.children) {
            queue.push({ node: child, level: level + 1 });
        }
    }
    // 未找到答案
    returnnull;
}

• 任务执行器

/**
 * 执行当前节点的任务，调用大模型获取结果
 * @param {TreeNode} node - 当前任务节点
 */
async function doTask(node) {
    const values = node.search(node); // 获取历史上下文
    const task = node.getValue(); // 当前任务内容
    console.log(`[执行任务] ${task}`);
    const systemPrompt = `
        # 任务
        1. 根据要求完成任务
        2. 尽量简短的回答问题, 只输出答案，不要输出解释
        3. 不要格式化文字，输出纯文本
        4. 如果任务无法明确执行或者缺少必要信息，回复"不知道"
        # 历史上下文
        ${JSON.stringify(values)}
        # 用户原始问题
        ${userQuestion}
    `
    const result = await callModel(systemPrompt, task);
    const output = {
        "task": task,
        "result": result
    }
    console.log(`[任务执行结果] \n ${result}`);
    node.setValue(JSON.stringify(output)) // 保存结果到节点
}

• 生成新任务，每次都由三个"专家", 生成三个不同的解决方案。

/**
 * 生成下一个任务列表（由专家提出解题思路并拆解）
 * @param {TreeNode} node - 当前节点
 * @returns {Promise<string[]>} - 返回三个专家的首个任务
 */
async function nextTask(node) {
    const values = node.search(node);
    const systemPrompt = `
        # 任务
        1. 假如有三个专家，为了解决问题，三个专家分别提出完整的解题思路
        2. 如果已经有部分答案，则参考答案提出后续解题思路
        3. 把解题思路拆解成多个独立的任务
        4. 每个任务都只包含一个具体的问题, 注意只进行任务规划，不要执行具体的任务
        5. 不要输出解释, 也不要格式化输出, 输出应是纯文本格式
        # 输出要求
        {
            "expert1": ["任务1", "任务2", "任务n"],
            "expert2": ["任务1", "任务2", "任务n"],
            "expert3": ["任务1", "任务2", "任务n"],
        }
        # 当前答案
        ${JSON.stringify(values)}
    `
    let tasks = await callModel(systemPrompt, userQuestion);
    tasks = JSON.parse(tasks);
    // 只取每个专家的第一个任务，作为下一步扩展
    const output = [tasks.expert1[0], tasks.expert2[0], tasks.expert3[0]]
    console.log('[生成下一批任务] \n' + JSON.stringify(output));
    return output
}

• 任务评估，判断当前任务的价值和后续策略。

/**
 * 检查当前节点的答案是否已经足够完善
 * @param {TreeNode} node - 当前节点
 * @returns {Promise<{status: string, values: any[]}>}
 */
asyncfunction checkStatus(node) {
    const values = node.search(node);
    const systemPrompt = `
        # 任务
        1. 下面是一段针对用户原始问题的任务步骤拆解
        2. 需要仔细阅读"用户原始问题"和"当前答案"，判断当前答案是否能足够完善
        3. 足够完善输出yes, 需要补充输出maybe, 完全不相关输出no
        4. 不要额外输出其他内容
        # 当前答案
        ${JSON.stringify(values)}
    `
    const status = await callModel(systemPrompt, `用户原始问题:\n ${userQuestion}`);
    const statusMap = {
        "yes": "已经符合要求, 开始整理输出",
        "maybe": "需要补充信息",
        "no": "完全不相关, 放弃答案"
    }
    console.log('[检查任务状态]' + statusMap[status])
    return {
        status: status.trim(),
        values: values
    }
}

• 主流程调用

// 主流程：以用户问题为根节点，BFS搜索答案
bfsWithLevels(new TreeNode(userQuestion), async (node) => {
    let result;
    if (node.isRoot(node)) {
        // 根节点初始化状态
        result = {
            status: 'maybe',
            values: []
        }
    } else {
        // 非根节点，先执行任务，再检查状态
        await doTask(node);
        result = await checkStatus(node);
    }
    // 已经找到最终答案，直接返回
    if (result.status === 'yes') {
        return {
            isEnd: true,
            values: result.values
        };
    }
    // 可能还需要补充信息，继续生成子任务
    if (result.status === 'maybe') {
        let tasks = await nextTask(node);
        tasks.forEach(taskDesc => {
            node.addChild(new TreeNode(taskDesc))
        });
    }
    // 继续BFS
    return {
        isEnd: false,
        values: []
    }
}).then(async (res) => {
    // 最终整理输出
    const output = await callModel(`
        # 任务
        整理并格式化数据，回答用户问题
        # 数据
        ${res}
    `, userQuestion);
    console.log(`[最终结果] \n ${output}`)
});

• 程序运行结果

Q:规划一个北京的旅游行程, 大概5天时间, 希望行程适合小朋友
A:
[生成下一批任务]
["确定适合小朋友的北京景点列表","研究北京适合儿童的餐饮选择","收集北京亲子游的攻略和评价"]
[执行任务] 确定适合小朋友的北京景点列表
[任务执行结果]
北京动物园
北京欢乐谷
...
[检查任务状态] 需要补充信息
[生成下一批任务]
["分析已确定的景点列表，筛选出最适合5天行程的景点","评估每个景点的游玩时长和适合年龄段","检查景点开放时间和门票信息"]
[执行任务] 研究北京适合儿童的餐饮选择
[任务执行结果]
北京动物园熊猫馆附近有亲子餐厅，提供儿童套餐
欢乐谷园区内有多家快餐店，适合儿童口味
...
[检查任务状态] 需要补充信息
[生成下一批任务]
["确定适合儿童的北京旅游景点","筛选儿童友好的餐饮场所","选择适合儿童的住宿地点"]
[执行任务] 收集北京亲子游的攻略和评价
[任务执行结果]
第一天: 天安门广场-故宫-景山公园
第二天: 北京动物园-北京海洋馆
第三天: 颐和园-圆明园
第四天: 北京欢乐谷
第五天: 中国科技馆-奥林匹克公园(鸟巢、水立方)
[检查任务状态] 已经符合要求, 开始整理输出
[最终结果]
以下是一个适合亲子游的5天北京行程规划，兼顾趣味性、教育性和轻松度：
第一天：历史文化初体验
上午：天安门广场（看升旗仪式需早起/常规参观）
上午：故宫（建议选择中轴线+珍宝馆路线，可租儿童讲解器）
下午：景山公园（登顶俯瞰故宫全景，山不高适合孩子）
晚上：前门大街（尝冰糖葫芦、坐复古电车）
第二天：动物王国日
...

好了，今天的内容就分享到这里了，如果觉得有帮助，别忘了点个关注！

如果有写的不对的内容，也欢迎评论区指正！