Prompt Template：组件化管理 prompt

prompt 毫无疑问是 AI Agent 中最核心的部分。

我们调用大模型完成各种功能，都是在 prompt 里描述的。

而且类似 RAG 查询向量数据库，查到的文档也是放在 prompt 里给到大模型。

但这节不讲 prompt 怎么写，因为在公司里有专门的产品部门负责写 prompt，我们要学的是如何管理它。

比如 prompt 之间的组合，prompt 里的示例的管理等。

之前都是直接写字符串：

而实际上是可以通过 Prompt Template 的 api 来动态的管理。

我们新建一个项目，测试下这些 api：

mkdir prompt-template-test
cd prompt-template-test
npm init -y

安装下用到的包：

pnpm install dotenv @langchain/core @langchain/openai

创建.env 文件：

# OpenAI API 配置
OPENAI_API_KEY=sk-xxx
OPENAI_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
MODEL_NAME=qwen-plus
EMBEDDINGS_MODEL_NAME=text-embedding-v3

然后写一下 Prompt Template 的第一个案例：

创建 src/prompt-template1.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import { PromptTemplate } from'@langchain/core/prompts';

// 初始化模型
const model = new ChatOpenAI({
    modelName: process.env.MODEL_NAME,
    apiKey: process.env.OPENAI_API_KEY,
    temperature: 0,
    configuration: {
        baseURL: process.env.OPENAI_BASE_URL,
    },
});

const naiveTemplate = PromptTemplate.fromTemplate(`
你是一名严谨但不失人情味的工程团队负责人，需要根据本周数据写一份周报。

公司名称：{company_name}
部门名称：{team_name}
直接汇报对象：{manager_name}
本周时间范围：{week_range}

本周团队核心目标：
{team_goal}

本周开发数据（Git 提交 / Jira 任务）：
{dev_activities}

请根据以上信息生成一份【Markdown 周报】，要求：
- 有简短的整体 summary（两三句话）
- 有按模块/项目拆分的小结
- 用一个 Markdown 表格列出关键指标（字段示例：模块 / 亮点 / 风险 / 下周计划）
- 语气专业但有一点人情味，适合作为给老板和团队抄送的周报。
`);

const prompt = await naiveTemplate.format({
    company_name: '星航科技',
    team_name: '数据智能平台组',
    manager_name: '刘总',
    week_range: '2025-03-10 ~ 2025-03-16',
    team_goal: '完成用户画像服务的灰度上线，并验证核心指标是否达标。',
    dev_activities:
        '- 阿兵：完成用户画像服务的 Canary 发布与回滚脚本优化，提交 27 次，相关任务：DATA-321 / DATA-335\n' +
        '- 小李：接入埋点数据，打通埋点 → Kafka → DWD → 画像服务的全链路，提交 22 次\n' +
        '- 小赵：完善画像服务的告警与Dashboard，新增 8 个告警规则，提交 15 次\n' +
        '- 小周：配合产品输出 A/B 实验报表，支持 3 条对外汇报用数据',
    });

console.log('格式化后的提示词:');
console.log(prompt);

const stream = await model.stream(prompt);
console.log('\nAI 回答:');
forawait (const chunk of stream) {
    process.stdout.write(chunk.content);
}

我们让 ai 给生成周报，要给他一些上下文信息。

定义了一个 Prompt Template，其中有一些占位符。

用的时候通过 format 方法传入占位符的具体内容。

之后给大模型填充数据之后的 prompt 来生成回答。

我们完全可以换一组内容来生成新的 prompt：

const prompt2 = await naiveTemplate.format({
    company_name: '极光云科技',
    team_name: '订单结算后端组',
    manager_name: '陈总',
    week_range: '2025-04-07 ~ 2025-04-13',
    team_goal: '本周以稳定性为主，集中清理历史技术债和高频告警。',
    dev_activities:
      '- 老王：修复高优先级线上 Bug 7 个（包含两起支付超时问题），提交 19 次，关联工单：PAY-1024 / PAY-1056\n' +
      '- 小何：重构结算批任务调度逻辑，将执行时间从 35min 优化到 18min，提交 24 次\n' +
      '- 小陈：梳理告警策略，合并冗余告警 12 条，新增 SLO 监控 3 项，提交 16 次\n' +
      '- 实习生小刘：补齐历史接口的缺失单测，用例覆盖 12 个核心方法，整体覆盖率从 52% 提升到 61%',
  });
console.log('格式化后的提示词:');
console.log(prompt2);

之前我们是直接拼接字符串，而现在用 Prompt Template 的 api 来管理。

现在都是一整个的 prompt，实际上可能需要按照角色、背景、任务、格式等来拆分管理 prompt，这样用的时候再组合。

这就需要用 PipelinePromptTemplate

创建 src/pipeline-prompt-template.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import { PipelinePromptTemplate, PromptTemplate } from'@langchain/core/prompts';

// 初始化模型
const model = new ChatOpenAI({
    modelName: process.env.MODEL_NAME,
    apiKey: process.env.OPENAI_API_KEY,
    temperature: 0,
    configuration: {
        baseURL: process.env.OPENAI_BASE_URL,
    },
});

// A. 人设模块
const personaPrompt = PromptTemplate.fromTemplate(
    `你是一名资深工程团队负责人，写作风格：{tone}。
你擅长把枯燥的技术细节写得既专业又有温度。\n`
);

// B. 背景模块
const contextPrompt = PromptTemplate.fromTemplate(
    `公司：{company_name}
部门：{team_name}
直接汇报对象：{manager_name}
本周时间范围：{week_range}
本周部门核心目标：{team_goal}\n`
);

// C. 任务模块
const taskPrompt = PromptTemplate.fromTemplate(
    `以下是本周团队的开发活动（Git / Jira 汇总）：
{dev_activities}

请你从这些原始数据中提炼出：
1. 本周整体成就亮点
2. 潜在风险和技术债
3. 下周重点计划建议\n`
);

// D. 格式模块
const formatPrompt = PromptTemplate.fromTemplate(
    `请用 Markdown 输出周报，结构包含：
1. 本周概览（2-3 句话的 Summary）
2. 详细拆分（按模块或项目分段）
3. 关键指标表格，表头为：模块 | 亮点 | 风险 | 下周计划

注意：
- 尽量引用一些具体数据（如提交次数、完成的任务编号）
- 语气专业，但可以偶尔带一点轻松的口吻，符合 {company_values}。
`
);

// E. 最终组合 Prompt（把上面几个模块拼在一起）
const finalWeeklyPrompt = PromptTemplate.fromTemplate(
    `{persona_block}
{context_block}
{task_block}
{format_block}

现在请生成本周的最终周报：`
);

const pipelinePrompt = new PipelinePromptTemplate({
    pipelinePrompts: [
        { name: 'persona_block', prompt: personaPrompt },
        { name: 'context_block', prompt: contextPrompt },
        { name: 'task_block', prompt: taskPrompt },
        { name: 'format_block', prompt: formatPrompt },
    ],
    finalPrompt: finalWeeklyPrompt,
    inputVariables: [
        'tone',
        'company_name',
        'team_name',
        'manager_name',
        'week_range',
        'team_goal',
        'dev_activities',
        'company_values',
    ],
});

const pipelineFormatted = await pipelinePrompt.format({
    tone: '专业、清晰、略带幽默',
    company_name: '星航科技',
    team_name: 'AI 平台组',
    manager_name: '王总',
    week_range: '2025-02-03 ~ 2025-02-09',
    team_goal: '完成智能周报 Agent 的 MVP 版本，并打通 Git / Jira 数据源。',
    dev_activities:
        '- Git: 58 次提交，3 个主要分支合并\n' +
        '- Jira: 完成 12 个 Story，关闭 7 个 Bug\n' +
        '- 关键任务：完成智能周报 Pipeline 设计、实现 Prompt 拆分、接入 ExampleSelector',
    company_values: '「极致、开放、靠谱」的价值观',
});

console.log('PipelinePromptTemplate 组合后的 Prompt：');
console.log(pipelineFormatted);

我们创建 PipelinePromptTemplate

指定了一个 finalPrompt 最终的 prompt，以及它组合的所有 pipelinePrompts。

（忽略上面的 inputVariables 参数，占位符变量会自动识别出来，不用手动声明）。

这里我们就不用调用大模型了，就看看生成的 prompt 就行：

有同学说，这样组合有什么好处呢？

当 prompt 大了之后优势就明显了，每一部分都可以单独维护和复用。

比如我们把这个 formatPrompt 导出，用于创建另一个 prompt。

新建 src/pipeline-prompt-template2.mjs

import { PromptTemplate, PipelinePromptTemplate } from'@langchain/core/prompts';
import {
  personaPrompt,
  contextPrompt,
} from'./pipeline-prompt-template.mjs';

// 示例：复用「人设 + 背景」模块，用于一个“季度 OKR 回顾邮件”场景

// 1. 本场景自己的任务说明模块
const okrReviewTaskPrompt = PromptTemplate.fromTemplate(`
以下是本季度与你所在团队相关的关键事实与数据（OKR 进展、重要事件等）：
{okr_facts}

请你基于这些信息，整理一份发给 {manager_name} 的【季度 OKR 回顾邮件】，重点包含：
1. 本季度整体达成情况（相对 OKR 的完成度）
2. 关键成果与亮点
3. 暴露出的主要问题 / 风险
4. 下季度的改进方向与优先级建议
`);

// 2. 本场景自己的格式要求模块
const okrReviewFormatPrompt = PromptTemplate.fromTemplate(
`请用 Markdown 写这封邮件，结构建议为：
1. 邮件开头（1-2 句话的问候 + 本邮件目的）
2. 本季度整体概览
3. 逐条 OKR 的回顾（可分小节）
4. 主要问题 / 风险
5. 下季度计划与请求支持

语气保持专业、克制但真诚，既让老板看到成绩，也能感受到你在主动暴露问题、寻求改进。`
);

// 3. 用 PipelinePromptTemplate 组合成最终 Prompt
const okrReviewPipeline = new PipelinePromptTemplate({
pipelinePrompts: [
    { name: 'persona_block', prompt: personaPrompt },   // 复用人设
    { name: 'context_block', prompt: contextPrompt },   // 复用背景
    { name: 'task_block', prompt: okrReviewTaskPrompt },
    { name: 'format_block', prompt: okrReviewFormatPrompt },
  ],
finalPrompt: PromptTemplate.fromTemplate(
    `{persona_block}
{context_block}
{task_block}
{format_block}

现在请生成本次的【季度 OKR 回顾邮件】：`
  ),
inputVariables: [
    'tone',
    'company_name',
    'team_name',
    'manager_name',
    'week_range',
    'team_goal',
    'okr_facts',
  ],
});

// 4. 示例：构造一个季度 OKR 回顾场景的 Prompt
const promptForReview = await okrReviewPipeline.format({
tone: '专业、真诚、偏书面表达',
company_name: '星航科技',
team_name: 'AI 平台组',
manager_name: '王总',
week_range: '2025 Q1',
team_goal: '支撑公司核心 AI 能力建设，完成三大基础平台的落地与稳定运行。',
okr_facts:
    '- O1：完成在线特征平台的 V1 上线，覆盖 3 条核心业务链路；\n' +
    '- O2：训练并上线新一代推荐模型，首页 CTR 提升 6.3%；\n' +
    '- O3：推动 GPU 资源利用率优化项目，整体利用率从 42% 提升到 67%；\n' +
    '- 重要事件：一次线上 P1 事故，一次跨部门联合专项；\n' +
    '- 团队：新增 2 位同学，整体人效相比去年同期提升约 18%。',
});

console.log('季度 OKR 回顾邮件 Prompt：\n');
console.log(promptForReview);

创建季度总结的 prompt，前面的角色 + 背景部分 prompt 直接复用周报的

跑一下：

这么多 inputVariables，其实有的是比较固定的，比如公司名、经理名等。

可以用 partial 来预填入一些变量，生成新的 PromptTemplate

创建 src/partial.mjs

import { pipelinePrompt } from"./pipeline-prompt-template.mjs";

const pipelineWithPartial = await pipelinePrompt.partial({
    company_name: '星航科技',
    company_values: '「极致、开放、靠谱」的价值观',
    tone: '偏正式但不僵硬',
});

const partialFormatted = await pipelineWithPartial.format({
    team_name: 'AI 平台组',
    manager_name: '刘东',
    week_range: '2025-02-10 ~ 2025-02-16',
    team_goal: '上线周报 Agent 到内部试用环境，并收集反馈。',
    dev_activities:
        '- 小明：完成 Git/Jira 集成封装\n' +
        '- 小红：实现 Prompt 配置化加载\n' +
        '- 小强：接入权限系统，支持按部门过滤数据',
});

const partialFormatted2 = await pipelineWithPartial.format({
    team_name: 'AI 工程效率组',
    manager_name: '王强',
    week_range: '2025-02-17 ~ 2025-02-23',
    team_goal: '打通 CI/CD 可观测链路，并推动落地到核心服务。',
    dev_activities:
        '- 阿俊：完成流水线执行数据的链路追踪接入\n' +
        '- 小白：梳理核心服务发布流程，补齐变更记录\n' +
        '- 小七：研发发布回滚一键脚本 PoC 版本',
});

console.log(partialFormatted);
console.log('\n================ 分割线：第二份周报模板 ================\n');
console.log(partialFormatted2);

这里我们把 PromptTemplate 预填入了一些固定的变量。

然后新的 PromptTemplate 用的时候就只需要填入其他变量就好了。

PromptTemplate 产出的就是一个字符串，实际上我们更多是用 SystemMesage、HumanMessage、AIMessage、ToolMessage 的 messages 数组来调大模型：

这种就需要 ChatPromptTemplate 了。

创建 src/chat-prompt-template.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import { ChatPromptTemplate } from'@langchain/core/prompts';

const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});


const chatPrompt = ChatPromptTemplate.fromMessages([
  [
    'system',
    `你是一名资深工程团队负责人，擅长用结构化、易读的方式写技术周报。
写作风格要求：{tone}。

请根据后续用户提供的信息，帮他生成一份适合给老板和团队同时抄送的周报草稿。`,
  ],
  [
    'human',
    `本周信息如下：

公司名称：{company_name}
团队名称：{team_name}
直接汇报对象：{manager_name}
本周时间范围：{week_range}

本周团队核心目标：
{team_goal}

本周开发数据（Git 提交 / Jira 任务等）：
{dev_activities}

请据此输出一份 Markdown 周报，结构建议包含：
1. 本周概览（2-3 句话）
2. 详细拆分（按项目或模块分段）
3. 关键指标表格（字段示例：模块 / 亮点 / 风险 / 下周计划）

语气专业但有人情味。`,
  ],
]);

const chatMessages = await chatPrompt.formatMessages({
tone: '专业、清晰、略带鼓励',
company_name: '星航科技',
team_name: '智能应用平台组',
manager_name: '王总',
week_range: '2025-05-05 ~ 2025-05-11',
team_goal: '完成内部 AI 助手灰度上线，并确保核心链路稳定。',
dev_activities:
    '- 小李：完成 AI 助手工单流转能力，对接客服系统，提交 25 次\n' +
    '- 小张：接入日志检索和知识库查询，提交 19 次\n' +
    '- 小王：完善监控、告警与埋点，新增 10 条核心告警规则\n' +
    '- 实习生小陈：补充使用文档和 FAQ，支持 3 个内部试点团队',
});

console.log('ChatPromptTemplate 生成的消息:');
console.log(chatMessages);

const response = await model.invoke(chatMessages);

console.log('\nAI 生成的周报草稿:');
console.log(response.content);

参数是一个二维数组，数组第一个元素是 message 类型：

实际上还是 ChatPromptTemplate 用的多，也就是 messages 数组的方式管理 prompt

那之前的 PipelinePromptTemplate 一般就是这样用：

src/pipeline-prompt-template3.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  PipelinePromptTemplate,
  PromptTemplate,
  ChatPromptTemplate,
} from'@langchain/core/prompts';
import {
  personaPrompt,
  contextPrompt,
} from'./pipeline-prompt-template.mjs';

// 初始化 Chat 模型
const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// A. 本场景自己的任务说明模块
const weeklyTaskPrompt = PromptTemplate.fromTemplate(
`以下是本周与你所在团队相关的关键事实与数据（Git / Jira / 运维等）：
{dev_activities}

请你基于这些信息，帮我生成一份【技术周报】，重点包含：
1. 本周整体达成情况
2. 关键成果与亮点
3. 主要问题 / 风险
4. 下周的改进方向与优先级建议
`
);

// B. 本场景自己的格式要求模块
const weeklyFormatPrompt = PromptTemplate.fromTemplate(
`请用 Markdown 写这份周报，结构建议为：
1. 本周概览（2-3 句话）
2. 详细拆分（按项目或模块分段）
3. 关键指标表格（字段示例：模块 / 亮点 / 风险 / 下周计划）

语气要求：{tone}，既专业清晰，又适合发给老板并抄送团队。`
);

// C. 最终的 ChatPromptTemplate：接收由 Pipeline 拼好的几块内容
const finalChatPrompt = ChatPromptTemplate.fromMessages([
  [
    'system',
    `你是一名资深工程团队负责人，擅长把复杂的技术细节总结成结构化、易读的周报。

下面是一些已经预先整理好的信息块，请你综合理解后，再根据用户补充的信息生成周报。`,
  ],
  [
    'human',
    `人设与写作风格：
{persona_block}

团队与本周背景：
{context_block}

任务与输入数据：
{task_block}

输出格式要求：
{format_block}

现在请基于以上信息，直接输出最终的周报内容。`,
  ],
]);

const weeklyChatPipelinePrompt = new PipelinePromptTemplate({
pipelinePrompts: [
    { name: 'persona_block', prompt: personaPrompt },     // 复用人设
    { name: 'context_block', prompt: contextPrompt },     // 复用背景
    { name: 'task_block', prompt: weeklyTaskPrompt },     // 本文件自己的任务模块
    { name: 'format_block', prompt: weeklyFormatPrompt }, // 本文件自己的格式模块
  ],
// 注意：这里的 finalPrompt 是 ChatPromptTemplate，而不是普通 PromptTemplate
finalPrompt: finalChatPrompt,
inputVariables: [
    'tone',
    'company_name',
    'team_name',
    'manager_name',
    'week_range',
    'team_goal',
    'dev_activities',
  ],
});

// E. 示例：构造一份消息数组并喂给 Chat 模型
const promptValue = await weeklyChatPipelinePrompt.formatPromptValue({
tone: '专业、清晰、略带鼓励',
company_name: '星航科技',
team_name: 'AI 平台组',
manager_name: '王总',
week_range: '2025-05-12 ~ 2025-05-18',
team_goal: '完成周报自动生成能力的灰度验证，并收集团队反馈。',
dev_activities:
    '- Git：本周合并 4 个主要特性分支，包含 Prompt 配置化和日志观测优化\n' +
    '- Jira：关闭 9 个 Story / 5 个 Bug，新增 2 个 TechDebt 任务\n' +
    '- 运维：本周线上 P1 事故 0 起，P2 1 起（由配置变更引起，已完成复盘）\n' +
    '- 其他：完成与数据平台、运维平台两次联合评审会议',
});

console.log('Pipeline + ChatPromptTemplate 生成的消息:');
console.log(promptValue.toChatMessages());

// const aiResponse = await model.invoke(messages);

// console.log('\nAI 生成的周报内容:');
// console.log(aiResponse.content);

这里我们复用了之前的两个 PromptTemplate，然后创建了两个新的 PromptTemplate

最终的 finalPrompt 是 ChatPromptTemplate

然后用 formatPromptValue 这个方法拿到填入变量后的 messages 数组：

这个 ChatPromptTemplate 还有另一种写法：

src/chat-prompt-template2.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  ChatPromptTemplate,
  SystemMessagePromptTemplate,
  HumanMessagePromptTemplate,
} from'@langchain/core/prompts';

const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

const systemTemplate = SystemMessagePromptTemplate.fromTemplate(
`你是一名资深工程团队负责人，擅长用结构化、易读的方式写技术周报。
写作风格要求：{tone}。

请根据后续用户提供的信息，帮他生成一份适合给老板和团队同时抄送的周报草稿。`
);

const humanTemplate = HumanMessagePromptTemplate.fromTemplate(
`本周信息如下：

公司名称：{company_name}
团队名称：{team_name}
直接汇报对象：{manager_name}
本周时间范围：{week_range}

本周团队核心目标：
{team_goal}

本周开发数据（Git 提交 / Jira 任务等）：
{dev_activities}

请据此输出一份 Markdown 周报，结构建议包含：
1. 本周概览（2-3 句话）
2. 详细拆分（按项目或模块分段）
3. 关键指标表格（字段示例：模块 / 亮点 / 风险 / 下周计划）

语气专业但有人情味。`
);

const composedTemplate = ChatPromptTemplate.fromMessages([
  systemTemplate,
  humanTemplate,
]);

const chatMessages = await composedTemplate.formatMessages({
tone: '专业、清晰、略带鼓励',
company_name: '星航科技',
team_name: '智能应用平台组',
manager_name: '王总',
week_range: '2025-05-05 ~ 2025-05-11',
team_goal: '完成内部 AI 助手灰度上线，并确保核心链路稳定。',
dev_activities:
    '- 小李：完成 AI 助手工单流转能力，对接客服系统，提交 25 次\n' +
    '- 小张：接入日志检索和知识库查询，提交 19 次\n' +
    '- 小王：完善监控、告警与埋点，新增 10 条核心告警规则\n' +
    '- 实习生小陈：补充使用文档和 FAQ，支持 3 个内部试点团队',
});

console.log('使用 SystemMessagePromptTemplate / HumanMessagePromptTemplate 生成的消息:');
console.log(chatMessages);

// const response = await model.invoke(chatMessages);

// console.log('\nAI 生成的周报草稿:');
// console.log(response.content);

不是传入二维数组了，而是分别用 SystemMessagePromptTemplate、HumanMessagePromptTemplate 等创建具体的 PromptTemplate

然后组合到 fromMessages 的参数数组里。

结果一样：

ChatPromptTemplate 是 messages 数组的方式，而 input variables 只能填充一些占位符的值。

那如果我是想插入一段聊天记录呢？

这种就要用 MessagesPlaceholder 了。

创建 src/messages-placeholder.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  ChatPromptTemplate,
  MessagesPlaceholder,
} from'@langchain/core/prompts';

// 演示：在 ChatPromptTemplate 中通过 MessagesPlaceholder 注入「对话历史」

// 1. 初始化 Chat 模型
const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// 2. 定义一个包含 MessagesPlaceholder 的 ChatPromptTemplate
const chatPromptWithHistory = ChatPromptTemplate.fromMessages([
  [
    'system',
    `你是一名资深工程效率顾问，善于在多轮对话的上下文中给出具体、可执行的建议。`,
  ],
// 这里用 MessagesPlaceholder 来承载「之前的多轮对话」
new MessagesPlaceholder('history'),
  [
    'human',
    `这是用户本轮的新问题：{current_input}

请结合上面的历史对话，一并给出你的建议。`,
  ],
]);

// 3. 构造一个模拟的历史对话 + 当前输入
const historyMessages = [
  {
    role: 'human',
    content: '我们团队最近在做一个内部的周报自动生成工具。',
  },
  {
    role: 'ai',
    content:
      '听起来不错，可以先把数据源（Git / Jira / 运维）梳理清楚，再考虑 Prompt 模块化设计。',
  },
  {
    role: 'human',
    content: '我们已经把 Prompt 拆成了「人设」「背景」「任务」「格式」四块。',
  },
  {
    role: 'ai',
    content:
      '很好，接下来可以考虑把这些模块做成可复用的 PipelinePromptTemplate，方便在不同场景复用。',
  },
];

const formattedMessages = await chatPromptWithHistory.formatPromptValue({
history: historyMessages,
current_input: '现在我们想再优化一下多人协同编辑周报的流程，有什么建议？',
});

console.log('包含历史对话的消息数组：');
console.log(formattedMessages.toChatMessages());

// const aiReply = await model.invoke(formattedMessages);

// console.log('\nAI 回复内容：');
// console.log(aiReply.content);

这里用 MessagesPlaceholder 来插入一段对话历史，变量名是 history

我们平时用 ChatPromptTemplate 比较多，所以需要用到 MessagesPlaceholder 插入对话历史的场景也比较多。

最后还有一个 FewShotPromptTemplate

也就是生成一些带少量示例的 prompt。

src/fewshot-prompt-template.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  FewShotPromptTemplate,
  PromptTemplate,
} from'@langchain/core/prompts';

// 1. 初始化 Chat 模型
const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// 2. 定义 few-shot 示例模板（单条示例长什么样）
const examplePrompt = PromptTemplate.fromTemplate(
`用户输入：{user_requirement}
期望周报结构：{expected_style}
模型示例输出片段：
{report_snippet}
---`
);

// 3. 准备几条示例数据（few-shot examples）
const examples = [
  {
    user_requirement:
      '重点突出稳定性治理，本周主要在修 Bug 和清理技术债，适合发给偏关注风险的老板。',
    expected_style: '语气稳健、偏保守，多强调风险识别和已做的兜底动作。',
    report_snippet:
      `- 支付链路本周共处理线上 P1 Bug 2 个、P2 Bug 3 个，全部在 SLA 内完成修复；\n` +
      `- 针对历史高频超时问题，完成 3 个核心接口的超时阈值和重试策略优化；\n` +
      `- 清理 12 条重复/噪音告警，减少值班同学 30% 的告警打扰。`,
  },
  {
    user_requirement:
      '偏向对外展示成果，希望多写一些亮点，适合发给更大范围的跨部门同学。',
    expected_style: '语气积极、突出成果，对技术细节做适度抽象。',
    report_snippet:
      `- 新上线「订单实时看板」，业务侧可以实时查看核心转化漏斗；\n` +
      `- 首次打通埋点 → 数据仓库 → 实时服务链路，为后续精细化运营提供基础能力；\n` +
      `- 和产品、运营一起完成 2 场内部分享，会后收到 15 条正向反馈。`,
  },
];

// 4. 把示例封装成 FewShotPromptTemplate
const fewShotPrompt = new FewShotPromptTemplate({
  examples,
  examplePrompt,
prefix:
    `下面是几条已经写好的【周报示例】，你可以从中学习语气、结构和信息组织方式：\n`,
suffix:
    `\n基于上面的示例风格，请帮我写一份新的周报。` +
    `\n如果用户有额外要求，请在满足要求的前提下，尽量保持示例中的结构和条理性。`,
inputVariables: [],
});

const fewShotBlock = await fewShotPrompt.format({});
console.log(fewShotBlock);

我们先用 PromptTemplate 创建了示例的 prompt 模版

然后创建了 2 个示例，加上前缀、后缀

看下最终的 prompt：

这就是生成少量示例的 FewShotPromptTemplate

很明显，FewShotPromptTemplate 可以结合其他 PromptTemplate 一起用，通过 PipelinePromptTemplate 组合到一块。

但如果示例特别多呢？

消耗 token 岂不是很多？

如果我不同的 query，需要选一些不同的示例来加入 prompt 呢？

或者根据长度限制来选择示例呢？

这种就要用 ExampleSelector 的 api 了，也就是示例选择器。

创建 src/example-selector1.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  FewShotPromptTemplate,
  PromptTemplate,
} from'@langchain/core/prompts';
import { LengthBasedExampleSelector } from'@langchain/core/example_selectors';

// 演示：使用 LengthBasedExampleSelector 自动选择「长度合适」的 few-shot 示例

// 1. 初始化 Chat 模型
const model = new ChatOpenAI({
modelName: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
temperature: 0,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// 2. 定义单条示例的 Prompt 模板
const examplePrompt = PromptTemplate.fromTemplate(
`用户需求：{user_requirement}
周报片段示例：
{report_snippet}
---`
);

// 3. 构造一批「长度差异明显」的示例，方便观察选择效果
const examples = [
  {
    user_requirement: '本周主要在做基础设施稳定性治理，想突出风险控制。',
    report_snippet:
      `- 核心链路共处理 P1 级别故障 1 起，P2 故障 2 起，均在 SLA 内完成处置；\n` +
      `- 对 5 个高风险接口补充了限流与熔断策略，覆盖 80% 高峰流量；\n` +
      `- 新增 6 条针对延迟抖动的告警规则，减少漏报风险。`,
  },
  {
    user_requirement: '偏向对外展示成果，多写一些亮点和业务价值。',
    report_snippet:
      `- 上线「实时订单看板」，支持业务实时查看转化漏斗；\n` +
      `- 打通埋点 → 数据仓库 → 实时服务的闭环，支撑后续精细化运营；\n` +
      `- 完成 2 场内部分享，会后收到 15 条正向反馈。`,
  },
  {
    user_requirement:
      '只是想要一个非常简短的周报，两三句话就够了，主要告诉老板「一切稳定」即可。',
    report_snippet: `本周整体运行平稳，未发生重大事故，核心指标均在预期范围内。`,
  },
  {
    user_requirement:
      '需要一份比较详细的技术周报，涵盖研发、测试、上线、监控等各个环节，篇幅可以略长。',
    report_snippet:
      `- 研发：完成结算服务重构第一阶段，拆分出 3 个独立子服务，接口延迟较旧架构下降约 35%；\n` +
      `- 测试：补齐 20+ 条关键路径自动化用例，整体用例数量提升到 180 条，回归时间从 2 天缩短到 0.5 天；\n` +
      `- 上线：采用灰度 + Canary 策略，期间监控到 2 次轻微指标抖动，均在 5 分钟内回滚处理；\n` +
      `- 监控：新增 8 条核心告警和 3 个 SLO 指标，后续会结合值班反馈继续收敛噪音告警。`,
  },
];

// 4. 创建 LengthBasedExampleSelector
const exampleSelector = await LengthBasedExampleSelector.fromExamples(examples, {
  examplePrompt,
// 这里简单地用字符长度近似控制，真实项目中可以配合 token 估算
maxLength: 700,
getTextLength: (text) => text.length,
});

// 5. 基于 selector 构建 FewShotPromptTemplate
const fewShotPrompt = new FewShotPromptTemplate({
  examplePrompt,
  exampleSelector,
prefix:
    '下面是一些不同风格和长度的周报片段示例，你可以从中学习语气和结构：\n',
suffix:
    '\n\n现在请根据上面的示例风格，为下面这个场景写一份新的周报：\n' +
    '场景描述：{current_requirement}\n' +
    '请输出一份适合发给老板和团队同步的 Markdown 周报草稿。',
inputVariables: ['current_requirement'],
});

// 6. 演示：给定一个较长/较复杂的需求，让 selector 自动选出合适的示例
const currentRequirement =
'我们本周在做「内部 AI 助手」项目，既有稳定性保障（处理线上问题），' +
'也有新功能上线（接入知识库、日志检索）。希望周报既能体现「把坑都兜住了」，' +
'又能展示一部分业务侧能感知到的亮点。';


const finalPrompt = await fewShotPrompt.format({
current_requirement: currentRequirement,
});

console.log(finalPrompt);

// const stream = await model.stream(finalPrompt);
// console.log('\n=== AI 输出 ===');
// for await (const chunk of stream) {
//   process.stdout.write(chunk.content);
// }

我们创建了 LengthBasedExampleSelector，根据长度来选择示例。

长度计算 maxLength 减去调用 format 的所有字段的长度。

剩下的就是示例的长度，根据这个来选择。

这个长度默认是字符长度，如果你要根据 token 多少来计算的话，改一下 getTextLength 参数即可。

除了根据长度选择示例，也支持根据语义选择相近的示例。

这个也是基于向量数据库做的。

我们先写入一些示例到 milvus 里：

src/weekly-report-examples-writer-milvus.mjs

import 'dotenv/config';
import { MilvusClient, DataType, MetricType, IndexType } from'@zilliz/milvus2-sdk-node';
import { OpenAIEmbeddings } from'@langchain/openai';

const COLLECTION_NAME = 'weekly_report_examples';
const VECTOR_DIM = 1024;

const EXAMPLES = [
  {
    scenario:
      '支付系统稳定性治理，强调风险防控、告警收敛和应急预案完善。',
    report_snippet:
      `- 本周聚焦支付链路稳定性，共处理 P1 事故 1 起、P2 事故 2 起，均在 SLA 内完成修复；\n` +
      `- 针对历史高频超时问题，完成 3 个关键接口的超时阈值和重试策略优化；\n` +
      `- 优化告警策略，合并冗余告警 10 条，新增 5 条基于 SLO 的告警规则。`,
  },
  {
    scenario:
      '新功能首发，更多是对外展示亮点，如新看板、新能力上线，适合发给大量跨部门同学。',
    report_snippet:
      `- 上线「运营实时看板」，支持业务实时查看核心转化漏斗；\n` +
      `- 打通埋点 → DWD → 实时服务链路，为后续精细化运营提供基础；\n` +
      `- 组织 2 场跨部门分享，帮助非技术同学理解新能力的业务价值。`,
  },
  {
    scenario:
      '重大版本发布节奏紧凑，需要对外同步一揽子新能力，强调可视化展示和业务价值。',
    report_snippet:
      `- 正式发布「增长分析 2.0」版本，新增留存分群、活动追踪等 5 项核心能力；\n` +
      `- 与市场同学联合输出发布解读文档，并在周会中向核心干系人进行路演；\n` +
      `- 配合运营梳理了 3 条重点推广场景，推动更多业务线接入新能力。`,
  },
  {
    scenario:
      '偏向产品体验优化和灰度试点，虽然不是大规模首发，但需要让老板看到长期产品线升级方向。',
    report_snippet:
      `- 针对「自助配置」后台完成一轮体验优化，减少 3 个关键操作步骤，提升整体可用性；\n` +
      `- 在小流量场景下灰度上线「智能推荐」能力，观察首周转化率提升约 3 个百分点；\n` +
      `- 拉通产品、运营和数据同学，对后续两个月的产品升级路线图达成一致。`,
  },
  {
    scenario:
      '技术债清理为主，核心工作是重构、单测补齐、文档完善，节奏偏稳，不强调对外大新闻。',
    report_snippet:
      `- 对老旧结算模块进行分层重构，拆出 3 个独立子模块，代码结构更加清晰；\n` +
      `- 补齐 25 条关键路径单元测试用例，整体覆盖率从 55% 提升到 68%；\n` +
      `- 完成 2 份系统设计文档补全，方便后续同学接手维护。`,
  },
  {
    scenario:
      '以老系统拆分和代码瘦身为主，更多是内部质量提升，重点在于风险可控和长期维护成本下降。',
    report_snippet:
      `- 拆分历史「大单体」服务中的账务子模块，沉淀为独立结算服务，减少跨模块耦合；\n` +
      `- 清理 30+ 条废弃接口和配置项，并在网关层加保护，降低后续演进阻力；\n` +
      `- 对关键重构路径补充回滚预案和演练手册，保证发布过程可控。`,
  },
  {
    scenario:
      '聚焦测试补齐和监控完善，希望通过一轮技术债治理把「隐性风险」暴露并关掉。',
    report_snippet:
      `- 新增 40+ 条端到端回归用例，覆盖主交易链路和高风险边界场景；\n` +
      `- 完成核心链路埋点和监控指标补齐，为后续 SLO 建设打下基础；\n` +
      `- 针对本周发现的 3 个潜在性能瓶颈，拉齐改造方案并排入后续技术债清单。`,
  },
  {
    scenario:
      '偏向团队协作和流程优化，比如值班轮值、需求评审机制、跨团队沟通等软性建设。',
    report_snippet:
      `- 完成新一轮值班排班和值班手册更新，降低新同学值班心理压力；\n` +
      `- 优化需求评审流程，引入「技术风险清单」模板，帮助更早发现潜在问题；\n` +
      `- 与运维、产品同学一起梳理了故障复盘模板，后续复盘将更聚焦于可执行改进项。`,
  },
];

const embeddings = new OpenAIEmbeddings({
apiKey: process.env.OPENAI_API_KEY,
model: process.env.EMBEDDINGS_MODEL_NAME,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
dimensions: VECTOR_DIM,
});

// 初始化 Milvus 客户端
const client = new MilvusClient({
address: process.env.MILVUS_ADDRESS ?? 'localhost:19530',
});

/**
 * 获取文本的向量嵌入
 */
asyncfunction getEmbedding(text) {
const result = await embeddings.embedQuery(text);
return result;
}

/**
 * 创建或获取集合
 */
asyncfunction ensureCollection() {
try {
    // 检查集合是否存在
    const hasCollection = await client.hasCollection({
      collection_name: COLLECTION_NAME,
    });

    if (!hasCollection.value) {
      console.log('创建集合...');
      await client.createCollection({
        collection_name: COLLECTION_NAME,
        fields: [
          {
            name: 'id',
            data_type: DataType.VarChar,
            max_length: 100,
            is_primary_key: true,
          },
          {
            name: 'scenario',
            data_type: DataType.VarChar,
            max_length: 2000,
          },
          {
            name: 'report_snippet',
            data_type: DataType.VarChar,
            max_length: 10000,
          },
          {
            name: 'vector',
            data_type: DataType.FloatVector,
            dim: VECTOR_DIM,
          },
        ],
      });
      console.log('✓ 集合创建成功');

      // 创建索引
      console.log('创建索引...');
      await client.createIndex({
        collection_name: COLLECTION_NAME,
        field_name: 'vector',
        index_type: IndexType.IVF_FLAT,
        metric_type: MetricType.COSINE,
        params: { nlist: 1024 },
      });
      console.log('✓ 索引创建成功');
    }

    // 确保集合已加载
    try {
      await client.loadCollection({ collection_name: COLLECTION_NAME });
      console.log('✓ 集合已加载');
    } catch (error) {
      console.log('✓ 集合已处于加载状态');
    }
  } catch (error) {
    console.error('创建集合时出错:', error.message);
    throw error;
  }
}

/**
 * 将周报示例插入到 Milvus
 */
asyncfunction insertExamples() {
try {
    if (EXAMPLES.length === 0) {
      return0;
    }

    console.log(`\n开始生成向量并插入 ${EXAMPLES.length} 条周报示例...`);

    const insertData = awaitPromise.all(
      EXAMPLES.map(async (example, index) => {
        // 这里用 scenario + report_snippet 作为向量文本
        const vector = await getEmbedding(example.scenario + example.report_snippet);
        return {
          id: `weekly_${index + 1}`,
          scenario: example.scenario,
          report_snippet: example.report_snippet,
          vector,
        };
      })
    );

    const insertResult = await client.insert({
      collection_name: COLLECTION_NAME,
      data: insertData,
    });

    const insertedCount = Number(insertResult.insert_cnt) || 0;
    console.log(`✓ 已插入 ${insertedCount} 条记录`);
    return insertedCount;
  } catch (error) {
    console.error('插入周报示例时出错:', error.message);
    console.error('错误详情:', error);
    throw error;
  }
}

/**
 * 主函数
 */
asyncfunction main() {
try {
    console.log('='.repeat(80));
    console.log('周报示例写入 Milvus');
    console.log('='.repeat(80));

    // 连接 Milvus
    console.log('\n连接 Milvus...');
    await client.connectPromise;
    console.log('✓ 已连接\n');

    // 确保集合存在
    await ensureCollection();

    // 插入示例数据
    await insertExamples();

    console.log('='.repeat(80));
    console.log('写入完成！');
    console.log('='.repeat(80));
  } catch (error) {
    console.error('\n错误:', error.message);
    console.error(error.stack);
    process.exit(1);
  }
}

main();

这里就是一个集合，然后写入一些示例数据。

之后创建 example-selector2.mjs

我们测试下语义选择示例的功能：

import 'dotenv/config';
import { ChatOpenAI, OpenAIEmbeddings } from'@langchain/openai';
import {
  FewShotPromptTemplate,
  PromptTemplate,
} from'@langchain/core/prompts';
import { SemanticSimilarityExampleSelector } from'@langchain/core/example_selectors';
import { Milvus } from'@langchain/community/vectorstores/milvus';

// 演示：使用 SemanticSimilarityExampleSelector 基于「语义相似度」自动从 Milvus 中选择 few-shot 示例

const COLLECTION_NAME =
  process.env.MILVUS_COLLECTION_NAME ?? 'weekly_report_examples';
const VECTOR_DIM = 1024;

// 1. 初始化 Chat 模型
const model = new ChatOpenAI({
temperature: 0,
model: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// 2. 初始化 embeddings
const embeddings = new OpenAIEmbeddings({
apiKey: process.env.OPENAI_API_KEY,
model: process.env.EMBEDDINGS_MODEL_NAME,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
dimensions: VECTOR_DIM,
});

// 3. 定义单条示例 Prompt 模板
const examplePrompt = PromptTemplate.fromTemplate(
`用户场景：{scenario}
生成的周报片段：
{report_snippet}
---`
);

// 4. 连接 Milvus，并基于已存在的集合创建向量库
const milvusAddress = process.env.MILVUS_ADDRESS ?? 'localhost:19530';

const vectorStore = await Milvus.fromExistingCollection(embeddings, {
collectionName: COLLECTION_NAME,
clientConfig: {
    address: milvusAddress,
  },
// 与 weekly-report-examples-writer-milvus.mjs 中创建的索引保持一致
indexCreateOptions: {
    index_type: 'IVF_FLAT',
    metric_type: 'COSINE',
    params: { nlist: 1024 },
    search_params: {
      nprobe: 10,
    },
  },
});

const exampleSelector = new SemanticSimilarityExampleSelector({
  vectorStore,
k: 2, // 每次只选出语义上最相近的 2 条示例
});

// 5. 用 selector 构建 FewShotPromptTemplate
const fewShotPrompt = new FewShotPromptTemplate({
  examplePrompt,
  exampleSelector,
prefix:
    '下面是一些不同类型的周报示例，你可以从中学习语气和结构（系统会自动从 Milvus 选出和当前场景最相近的示例）：\n',
suffix:
    '\n\n现在请根据上面的示例风格，为下面这个场景写一份新的周报：\n' +
    '场景描述：{current_scenario}\n' +
    '请输出一份适合发给老板和团队同步的 Markdown 周报草稿。',
inputVariables: ['current_scenario'],
});

// 6. 演示：给定几个不同的场景描述，让 selector 挑出语义上最接近的示例
const currentScenario1 =
'我们本周主要是在清理历史技术债：重构老旧的订单模块、补齐核心接口的单测，' +
'同时也完善了一些文档，方便后面新人接手。整体没有对外大范围发布的新功能。';

// 一个语义上明显不同的场景：偏「首发上线 + 对外宣传」
const currentScenario2 =
'本周完成新一代运营看板的首批功能上线，重点打通埋点和实时数仓链路，' +
'并面向运营和市场同学做了多场宣讲，希望更多同学开始使用新能力。';

console.log('\n===== 场景 1：技术债清理为主 =====\n');
const finalPrompt1 = await fewShotPrompt.format({
current_scenario: currentScenario1,
});
console.log(finalPrompt1);

console.log('\n\n===== 场景 2：新功能首发 + 对外宣传 =====\n');
const finalPrompt2 = await fewShotPrompt.format({
current_scenario: currentScenario2,
});
console.log(finalPrompt2);

// 如果需要真正调用模型，可以解开下面注释
// const stream = await model.stream(finalPrompt);
// console.log('\n=== AI 输出 ===');
// for await (const chunk of stream) {
//   process.stdout.write(chunk.content);
// }

这里我们不再直接用 milvus 的 sdk 的 api，而是用 @langchain/community 里封装的 Milvus

安装下用到的包：

pnpm install @langchain/community @zilliz/milvus2-sdk-node

跑一下：

有 FewShotPromptTemplate 自然就有 FewShotChatMessagePromptTemplate，也就是对话形式的 prompt

创建 src/fewshot-chat-prompt-template.mjs

import 'dotenv/config';
import { ChatOpenAI } from'@langchain/openai';
import {
  ChatPromptTemplate,
  FewShotChatMessagePromptTemplate,
} from'@langchain/core/prompts';

// 1. 初始化 Chat 模型
const model = new ChatOpenAI({
temperature: 0.3,
model: process.env.MODEL_NAME,
apiKey: process.env.OPENAI_API_KEY,
configuration: {
    baseURL: process.env.OPENAI_BASE_URL,
  },
});

// 2. few-shot 示例：每条示例是「human 问 + ai 答」的聊天片段
const EXAMPLES = [
  {
    input: '本周主要推进支付稳定性治理，做了事故处置、告警优化和演练。',
    output:
      '- 本周围绕支付链路稳定性开展治理工作：完成 1 起 P1 事故与 2 起 P2 事故的排查与修复，均在 SLA 内关闭；\n' +
      '- 梳理并合并冗余告警规则 8 条，新建 4 条基于 SLO 的告警，大幅降低无效告警噪音；\n' +
      '- 组织 1 次故障应急演练，验证支付核心链路的应急预案可行性。',
  },
  {
    input: '本周交付了新运营看板，并给业务同学做了多场分享。',
    output:
      '- 上线新一代「运营实时看板」，支持业务实时查看关键转化指标和漏斗数据；\n' +
      '- 衔接埋点、数据仓库与可视化链路，为后续精细化运营提供统一数据口径；\n' +
      '- 面向市场和运营团队组织 2 场产品培训，帮助非技术同学理解看板核心能力和使用场景。',
  },
];

// 3. 把上面的结构映射为 FewShotChatMessagePromptTemplate 可用的 examples
const fewShotExamples = new FewShotChatMessagePromptTemplate({
examplePrompt: ChatPromptTemplate.fromMessages([
    [
      'human',
      '下面是本周的工作概述：\n{input}\n\n请帮我整理成适合发在团队周报里的要点列表。',
    ],
    ['ai', '{output}'],
  ]),
examples: EXAMPLES,
exampleSeparator: '\n\n', // 可选：示例之间的分隔符，仅影响 formatMessages 输出
inputVariables: [], // 示例本身不依赖运行时变量
});

// 4. 把 few-shot 示例和最终用户输入组合成一个完整的 ChatPromptTemplate
const chatPrompt = ChatPromptTemplate.fromMessages([
  [
    'system',
    '你是一名资深技术负责人，请根据给定的工作内容，参考上面的示例，帮我写一段结构清晰、重点突出的周报片段（使用 Markdown 列表）。',
  ],
  [
    'system',
    '下面是若干参考示例，请重点学习它们的「表达方式和结构」，而不是照搬具体内容：',
  ],
  fewShotExamples,
  [
    'human',
    '这是我本周的实际工作内容，请帮我整理成周报：\n{current_work}',
  ],
]);

const currentWork =
'本周完成了订单模块的一轮重构，拆分了历史遗留的大文件，并补齐了核心路径的单测；' +
'同时修复了两起线上性能问题，并把指标接入统一监控看板。';

asyncfunction main() {
// 组装成消息
const messages = await chatPrompt.formatMessages({
    current_work: currentWork,
  });

console.log('\n===== 发送给模型的消息 =====\n');
console.log(messages);

// 如果你配置了模型，可以真正调用一次
try {
    const stream = await model.stream(messages);
    console.log('\n===== 模型输出 =====\n');
    forawait (const chunk of stream) {
      process.stdout.write(chunk.content);
    }
    console.log('\n');
  } catch (e) {
    console.log(
      '\n（提示：如需真实调用模型，请确认已配置 MODEL_NAME / OPENAI_API_KEY / OPENAI_BASE_URL）',
    );
  }
}

main();

和 FewShotPromptTempalate 的区别只不过是现在示例变成了 ai 和 human 的对话历史了。

代码上传了课程仓库： https://github.com/QuarkGluonPlasma/ai-agent-course-code

总结

这节我们学了 Prompt Template 相关的 api。

主要有这些：

• PromptTemplate：提示词模版，可以填入占位符变量
• ChatPromptTemplate：对话形式（messages 数组）的提示词模版
• FewShotPromptTemplate：生成带示例的提示词模版
• FewShotChatTemplatePromptTemplate：生成带示例的提示词模版，对话形式
• LengthBasedExampleSelector：根据长度选择合适的示例
• SemanticSimilarityExampleSelector：选择语义相近的示例
• PipelinePromptTemplate：合并多个 Prompt Template 成一个大的 Prompt Template

有了这些 prompt template 的 api，就可以用组件化的方式来管理 prompt 了，用到的时候再组合。