【LangChain实战】LangChain 学习笔记（三）：提示词模板与示例选择器

👋 欢迎阅读

🏠个人主页：愿旖旎 📘专栏传送门：算法专栏 💻当前学习内容：LangChain

📑 目录

• 一、前置讲解

• 二、提示词模板

• 三、示例选择器（Example Selectors）

• 四、复盘（附答案）

一、前置讲解

在进入正文前，先花 10 秒了解本篇会反复用到的核心概念，带着印象去读正文，学习效率更高。

🧠 前置知识一：PromptTemplate

字符串提示词模板，用占位符动态生成提示词。

🗨️ 前置知识二：ChatPromptTemplate

聊天消息模板，可组合 System/User/AI 消息。

📍 前置知识三：MessagesPlaceholder

消息占位符，在指定位置插入一整段对话历史。

🔤 前置知识四：少样本提示（Few-shot）

给模型看几个示例再提问，比写长篇指令更有效。

🎯 前置知识五：示例选择器

从大量示例中按策略挑最合适的几个：长度/语义相似/MMR/NGram。

二、提示词模板

2.1 认识提示词模板

提示词模板（Prompt Template） 是 LangChain 的核心抽象之一，被广泛应用于构建大语言模型（LLM） 应用的各个环节。简单来说，只要是需要动态、批量或有结构地向大语言模型发送请求的地方，几乎都会用到提示词模板。

一个简单的例子：假设我们想根据城市名询问 LLM 其历史，按之前做法，需定义 HumanMessage("请介绍上海的历史")、HumanMessage("请介绍西安的历史") 等，每次都会重复"请介绍 xxx 的历史"。在 LangChain 中，可定义模板：

• 固定文本（模板）："请介绍{city}的历史。"

• 输入变量：["city"]

提示词模板就是一个可复用的提示词蓝图，允许我们动态地生成提示词，而不是每次都手动编写完整的提示词。它类似于编程中的字符串格式化功能：创建一个带有占位符的模板，然后在运行时用具体的值（变量）填充这些占位符，从而生成最终发送给 LLM 的完整提示词。

提示词模板解决了以下几个核心问题：

2.2 用法

2.2.1 字符串模板（PromptTemplate）

LangChain 提供了 PromptTemplate 类来轻松实现这一功能。PromptTemplate 实现了标准的 Runnable 接口。

代码示例：

from langchain_core.prompts import PromptTemplate
​
# 1. 定义模板（{language} 是变量占位符）
prompt_template = PromptTemplate.from_template("把下面的内容翻译成{language}")
​
# 2. 实例化模板（传入变量值，{language} 被替换成实际内容）
print(prompt_template.invoke({"language": "中文"}))

运行结果：

text='把下面的内容翻译成中文'

PromptTemplate 类的参数与方法：

因此，除了通过 PromptTemplate.from_template 定义提示模板的方式外，下面这种方式也可以直接初始化模板：

代码示例：

prompt_template = PromptTemplate(
   input_variables=["language"],
   template="Translate the following into {language}",
)

2.2.2 聊天消息模板（ChatPromptTemplate）

ChatPromptTemplate 模板：专为 LangChain 聊天模型设计。可以方便地构建包含 SystemMessage、HumanMessage、AIMessage 的消息模板。

代码示例：

from langchain_core.prompts import ChatPromptTemplate
​
# 1. 设置模板（两段消息：system 定义角色/规则，user 是用户内容）
#   {language}、{text} 是变量占位符
prompt_template = ChatPromptTemplate(
  [
      ("system", "把下面的内容翻译成{language}。"),
      ("user", "{text}"),
  ]
)
# 说明：
# 在 0.2.24 版本后可以直接使用 ChatPromptTemplate() 来初始化模板
# 在 0.2.24 版本前，需要使用 ChatPromptTemplate.from_messages() 来初始化模板
​
# 2. 实例化模板，获取消息实例（把变量值填进去）
messages_value = prompt_template.invoke(
  {
       "language": "中文",
       "text": "你叫什么名字？",
  }
)
# to_messages()：把 PromptValue 转成消息列表
messages = messages_value.to_messages()
print(messages)

运行结果：

[SystemMessage(content='把下面的内容翻译成中文。', …), HumanMessage(content='你叫什么名字？', …)]

ChatPromptTemplate 同样实现了标准的 Runnable 接口，因此我们还可以通过链来完成调用：

代码示例：

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
​
# 定义大模型
model = ChatOpenAI(
   model="deepseek-chat",
   api_key=os.getenv("DEEPSEEK_API_KEY"),
   base_url="https://api.deepseek.com",
)
​
# 1. 设置模板（system 定义规则，user 是用户内容）
prompt_template = ChatPromptTemplate(
  [
      ("system", "把下面的内容翻译成{language}。"),
      ("user", "{text}"),
  ]
)
​
# 2. 定义输出解析器（把 AIMessage 转成纯字符串）
parser = StrOutputParser()
​
# 3. 定义链：模板填变量 → 调模型 → 解析成字符串
chain = prompt_template | model | parser
​
# 流式输出：模型生成一点就吐一点
for token in chain.stream(
  {
       "language": "English",
       "text": "你好，我叫斯蒂芬，很高兴认识你",
  }
):
   print(token, end="|")

运行结果：

|Hello|,| my| name| is| Stephen|.| Nice| to| meet| you|.|||

2.2.3 消息占位符（MessagesPlaceholder）

在上面的 ChatPromptTemplate 中，我们看到了如何格式化两条消息，每条消息都是字符串。但如果希望将消息插入特定位置怎么办？使用 MessagesPlaceholder——它负责在特定位置添加消息列表。

代码示例：

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
​
# 设置模板：system 消息 + 一个"消息占位符"
# MessagesPlaceholder("msgs") = 留一个位置，运行时把一整段对话消息塞进来
prompt_template = ChatPromptTemplate(
  [
      ("system", "你是一个聊天助手"),
       MessagesPlaceholder("msgs"),  # 消息占位符
  ]
)
​
# 要传入占位符的消息列表（多轮对话历史）
messages_to_pass = [
   HumanMessage(content="中国首都是哪里?"),
   AIMessage(content="中国首都是北京。"),
   HumanMessage(content="那法国呢?"),
]
​
# 实例化模板：把消息列表填进 msgs 占位符
formatted_prompt = prompt_template.invoke({"msgs": messages_to_pass})
print(formatted_prompt)

在不显式使用 MessagesPlaceholder 类也可以完成该能力：

2.3 使用 LangChain Hub 的提示词模板

LangChain Hub 是一个用于上传、浏览、拉取和管理提示词（Prompt） 的地方。随着 LLM 的发展，提示词变得越来越重要。LangChain 正在打造一个类似于 GitHub 的平台——GitHub 长期以来一直是共享和协作代码的首选平台，于是推出了 LangChain Hub。

LangChain Hub 创建一个分享和发现 Prompt 的平台，使开发者更容易发现新用例和精炼提示词。这一举措使提示工程师更容易合作、复用现有提示词，并对其进行微调以实现特定结果，从而加速对话代理和其他基于语言的应用的开发与部署。

LangChain Hub 官网地址：LangSmith

目前收藏最高的提示词模板是：hardkothari/prompt-maker。我们就以它为例，演示如何使用 LangChain Hub 上的提示词。Prompt Maker 模板是一个提示生成器，可以自动化优化提示过程，从而提高语言模型在各种应用中的质量和效果。

要使用该功能，需先申请并配置 LangSmith 环境变量：LANGSMITH_API_KEY="你的 LangSmith API Key"。然后从 hub 拉取相应提示并使用。

代码示例：

import os
from langchain_openai import ChatOpenAI
from langsmith import Client

# 从 LangSmith Hub 拉取 "hardkothari/prompt-maker" 提示词模板
# dangerously_pull_public_prompt=True：确认信任该公共模板（新版 SDK 的安全要求）
client = Client()
prompt = client.pull_prompt(
"hardkothari/prompt-maker",
include_model=True,
dangerously_pull_public_prompt=True,
)

# 定义模型（适配 DeepSeek）
model = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
)

# 定义链：Hub 模板 → 模型
chain = prompt | model

# 交互式问答循环
while True:
task = input("\\n你的任务是什么？（输入 quit 退出聊天）\\n")
if task == "quit":
break
lazy_prompt = input("\\n你当前的提示是什么？（输入 quit 退出聊天）\\n")
if lazy_prompt == "quit":
break
print("\\n Response:")
chain.invoke({"lazy_prompt": lazy_prompt, "task": task}).pretty_print()

通过使用这个模板，可以大幅减少手动调整提示词所需的工作量，从而节省时间和资源。Prompt Maker 通过分析初始提示词的结构和内容，然后应用一组预定规则或算法来优化提示词，以提高响应质量、清晰度和相关性。这在提示词质量对模型输出影响较大的场景中特别有用，例如客服机器人、对话代理或数据分析任务。

2.4 少样本提示（Few-shot）

少样本提示是一种通过向 LLM 提供少量具体示例或样本，来教会它如何执行某项特定任务的技术。提高模型性能的最有效方法之一是给出一个模型示例，指导大模型你想做什么、怎么做。

零样本 vs 少样本：我们直接给模型一道考题，不给任何例子——例如输入 "What is 2 🦜 9?"，此时模型的解法有千百种，因此没什么效果；但如果给上样本，它就有了固定意义。例如以下样例，模型通过示例学习后可以发现 🦜 与 ➕ 含义相似，并按照此规则得出 What is 2 🦜 9? 的结果是 11：

代码示例（示例集）：

examples = [
{"input": "2 🦜 2", "output": "4"},
{"input": "2 🦜 3", "output": "5"},
]

少样本提示主要解决以下核心问题：

实现少样本提示（FewShotChatMessagePromptTemplate）

要让大模型"看懂"示例，需要将示例集转换为聊天模型可识别的消息格式。在 LangChain 中，通过 FewShotChatMessagePromptTemplate 对象来实现这一目的——它是一个提示词模板，专门用于将示例集实例化为聊天消息。

代码示例：

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import (
ChatPromptTemplate,
FewShotChatMessagePromptTemplate,
)

# 单个示例的格式化模板（一个示例 = 一问一答）
example_prompt = ChatPromptTemplate(
[
("human", "{input}"),
("ai", "{output}"),
]
)

# 样本示例：教模型"🦜"表示加法
examples = [
{"input": "2 🦜 2", "output": "4"},
{"input": "2 🦜 3", "output": "5"},
]

# 少样本提示词模板：把多个示例拼进提示词，让模型照着范例学习
few_shot_prompt = FewShotChatMessagePromptTemplate(
example_prompt=example_prompt, # 用于格式化单个示例
examples=examples, # 样本示例
)

# 最终完整提示词：system 角色 + 示例 + 用户真实提问
final_prompt = ChatPromptTemplate(
[
("system", "你是一个神奇的数学奇才。"),
few_shot_prompt,
("human", "{input}"),
]
)

# 定义模型
model = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
)

# 链：最终模板 → 模型
chain = final_prompt | model
chain.invoke({"input": "2 🦜 9 等于多少?"}).pretty_print()

运行结果：

根据我们之前的规律（🦜 代表加法），2 🦜 9 = 2 + 9 = 11。

先来看看 FewShotChatMessagePromptTemplate，它也实现了标准的 Runnable 接口：

// 返回值： // FewShotChatMessagePromptTemplate：配置好的少样本聊天消息提示模板对象。

生成的提示结构为：前缀消息 + 示例消息 + 后缀消息；支持静态示例列表或基于输入的动态示例选择。

使用案例 1：推理引导（FewShotPromptTemplate）

代码示例：

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate

# 创建字符串模板：一个示例 = "Question: 问题\\n答案"
example_prompt = PromptTemplate.from_template("Question: {question}\\n{answer}")

# 创建示例集（教模型：复杂问题要拆成一步一步推理，最后给出最终答案）
examples = [
{
"question": "李白和杜甫，谁更长寿？",
"answer": """
是否需要后续问题：是的。
后续问题：李白享年多少岁？
中间答案：李白享年61岁。
后续问题：杜甫享年多少岁？
中间答案：杜甫享年58岁。
所以最终答案是：李白
""",
},
{
"question": "腾讯的创始人什么时候出生？",
"answer": """
是否需要后续问题：是的。
后续问题：腾讯的创始人是谁？
中间答案：腾讯由马化腾创立。
后续问题：马化腾什么时候出生？
中间答案：马化腾出生于1971年10月29日。
所以最终答案是：1971年10月29日
""",
},
]

# 少样本模板：示例 + 后缀（用户真正的问题）
prompt = FewShotPromptTemplate(
examples=examples, # 示例集
example_prompt=example_prompt, # 每个示例怎么格式化
suffix="Question: {input}", # 示例后面的用户问题模板
input_variables=["input"], # 后缀里的变量
)

# 生成 [HumanMessage] 消息列表
prompt_messages = prompt.invoke(
{"input": "阿狸和亚索是否来自同一个地区？"}
).to_messages()

model = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
)

model.invoke(prompt_messages).pretty_print()

运行结果：

阿狸和亚索并非来自同一个地区。

阿狸是艾欧尼亚的瓦斯塔亚狐狸，而亚索是艾欧尼亚的战士，虽然他们都与艾欧尼亚有关，但阿狸的故乡是艾欧尼亚的某片幽静森林，而亚索则来自艾欧尼亚的某个部族（通常被提及为诺克萨斯边境附近的村庄）。严格来说，他们都属于艾欧尼亚，但背景设定中并未明确说他们来自同一具体地区。如果按“地区”广义理解为同一大陆，那么确实都是艾欧尼亚的；如果按具体出生地，则不是同一个地方。所以最终答案取决于“地区”的划定——若指艾欧尼亚，则是；若指具体地点，则不是。

FewShotPromptTemplate 相关方法：

使用案例 2：增强信息提取能力

代码示例：

import os
from langchain_openai import ChatOpenAI
from typing import List, Optional
from pydantic import BaseModel, Field
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import SystemMessage
from langchain_core.utils.function_calling import tool_example_to_messages

# 1. 定义结构化输出
class Person(BaseModel):
"""一个人的信息。"""
name: Optional[str] = Field(default=None, description="这个人的名字")
hair_color: Optional[str] = Field(default=None, description="如果知道这个人头发的颜色")
skin_color: Optional[str] = Field(default=None, description="如果知道这个人的肤色")
height_in_meters: Optional[float] = Field(default=None, description="以米为单位的高度")

class Data(BaseModel):
"""提取关于人的数据。"""
people: List[Person]

# 2. 定义 2 个示例（教模型提取行为：什么该提取、信息缺失时怎么办）
examples = [
("海洋是广阔而蓝色的。它有两万多英尺深。", Data(people=[])), # 没有人物信息
("小强从中国远行到美国。", Data(people=[
Person(name="小强", height_in_meters=None, skin_color=None, hair_color=None),
])), # 部分信息缺失
]

# 3. 定义提示词模板（system 定规则 + 示例占位 + 用户真问题）
prompt_template = ChatPromptTemplate(
[
SystemMessage(content="你是一个提取信息的专家，只从文本中提取相关信息。"
"如果您不知道要提取的属性的值，属性值返回null"),
MessagesPlaceholder("example_messages"),
("user", "{new_message}"),
]
)

# 4. 获取样例消息列表（把每个示例转成模型能理解的聊天消息格式）
example_messages = []
for txt, tool_call in examples:
ai_response = "检测到人" if tool_call.people else "未检测到人"
example_messages.extend(
tool_example_to_messages(txt, [tool_call], ai_response=ai_response)
)

# 5. 调用
model = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
)
structured_model = model.with_structured_output(schema=Data, method="function_calling")

# 定义链：示例+问题 → 结构化提取
chain = prompt_template | structured_model
result = chain.invoke({
"example_messages": example_messages,
"new_message": "篮球场上，身高两米的中锋王伟默契地将球传给一米七的后卫挚友李明，完成一记绝杀。",
})
print(result)

# 额外案例：没有人名的文本
result_no_people = chain.invoke({
"example_messages": example_messages,
"new_message": "海边的日出很美，金色的阳光洒在平静的海面上。",
})
print(result_no_people)

运行结果：

三、示例选择器（Example Selectors）

3.1 概念

一旦我们有了示例数据集，就需要考虑提示中应该有多少个示例。关键的权衡是：更多的示例通常会提高性能，但更大的提示会增加成本和延迟；超过某个阈值，太多示例可能会开始混淆模型。

找到正确数量的示例在很大程度上取决于模型、任务、示例质量以及成本和延迟限制。有趣的是，模型越好，它需要的精准示例就越少。但其实，最佳方法是使用不同数量的示例进行一些实验。

若此时我们有大量的示例数据集，对于大模型来说，没必要全部使用作为参考。我们需要一种方法，根据给定输入从数据集中选择示例。在 LangChain 中，示例选择器可以帮助我们从一组示例集合中，根据具体策略选择正确的示例子集，构建少样本提示。

选择策略：

3.2 按长度选择示例（Length）

概念

当我们担心构造提示时会超过上下文窗口长度时，可根据特定长度内可容纳的数量选择示例——对于较长的输入，选择更少的示例；对于较短的输入，选择更多的示例。实现按长度选择示例的选择器是：LengthBasedExampleSelector。

常见参数：

// 返回值： // LengthBasedExampleSelector：配置好的示例选择器对象。

内置方法：

• add_example：将新示例添加到列表中。

  SemanticSimilarityExampleSelector::add_example(example: dict[str, str]);

  # 功能：
  # 向当前的示例选择器中动态添加一个新示例。该示例会被向量化并存储到底层的向量数据库中，
  # 以便后续的 `select_examples` 查询能够基于语义相似度检索到它。
  # 适用于需要在线更新示例库的场景（如用户反馈或增量学习）。

  # 参数说明：
  # example: 一个字典，键为示例中的变量名（如 "input"、"output"），值为对应的文本内容。
  # 该字典的结构应与创建时传入的示例结构完全一致。

  # 返回值：
  # 无（void）

• select_examples：根据输入选择要使用的示例。

  SemanticSimilarityExampleSelector.select_examples(
  input_variables: dict
  ) -> List[dict]:

  # 功能：
  # 根据输入的变量字典，从示例存储中选择与输入语义最相似的 k 个示例（k 在构造函数中指定）。
  # 该方法会自动将输入变量组合成文本，计算其嵌入向量，然后在向量库中检索最相似的示例。

  # 参数说明：
  # input_variables: 包含当前输入变量的字典，例如 {"input": "large"}。
  # 字典中的键值对会被用于构建检索文本，以匹配示例的语义。

  # 返回值：
  # List[dict]：选中的示例列表，每个示例为字典，包含所有示例字段（如 input、output 等）。

代码示例：

import os
from langchain_openai import ChatOpenAI
from langchain_core.example_selectors import LengthBasedExampleSelector
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate

# 反义词示例集合
examples = [
{"input": "happy", "output": "sad"},
{"input": "tall", "output": "short"},
{"input": "energetic", "output": "lethargic"},
{"input": "sunny", "output": "gloomy"},
{"input": "windy", "output": "calm"},
]

# 字符串模板（单个示例的格式）
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="Input: {input}\\nOutput: {output}",
)

# 长度示例选择器：按长度动态选示例（从前往后塞，超长就停）
example_selector = LengthBasedExampleSelector(
examples=examples,
example_prompt=example_prompt,
max_length=15,
)

# 用选择器创建动态模板
dynamic_prompt = FewShotPromptTemplate(
example_selector=example_selector,
example_prompt=example_prompt,
prefix="给出每个输入的反义词",
suffix="Input: {adjective}\\nOutput:",
input_variables=["adjective"],
)

#只看组装好的提示词（不调模型）
print(dynamic_prompt.invoke({"adjective": "happy"}).to_messages()[0].content)

运行结果：

=== 提示词内容 ===
给出每个输入的反义词

Input: happy
Output: sad

Input: tall
Output: short

Input: energetic
Output: lethargic

Input: happy
Output:

可见：5 个反义词示例只塞进了前 3 个（长度达到 max_length 就停止）。

3.3 按语义相似性选择示例（Similarity）

概念

语义相似是衡量文本在含义上的接近程度。例如：

LangChain 能根据输入和示例之间的语义相似性决定选择哪些示例，它通过查找与输入具有最大余弦相似性的嵌入示例来实现。实现该策略的选择器是：SemanticSimilarityExampleSelector。

常见参数：

内置方法 from_examples：

其他方法：add_example（添加新示例）、select_examples（根据输入选择示例）。

代码示例：

import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
os.environ["HF_HUB_DISABLE_XET"] = "1"

from langchain_openai import ChatOpenAI
from langchain_chroma import Chroma
from langchain_core.example_selectors import SemanticSimilarityExampleSelector
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_core.embeddings import Embeddings
from fastembed import TextEmbedding

# 嵌入封装：DeepSeek 没有 embedding 接口，这里用 fastembed（本地轻量，免 torch）
class FastEmbed(Embeddings):
def __init__(self, model="BAAI/bge-small-en-v1.5"):
self.m = TextEmbedding(model)
def embed_documents(self, texts):
return [v.tolist() for v in self.m.embed(list(texts))]
def embed_query(self, text):
return next(self.m.embed([text])).tolist()

# 反义词示例集合
examples = [
{"input": "happy", "output": "sad"},
{"input": "tall", "output": "short"},
{"input": "energetic", "output": "lethargic"},
{"input": "sunny", "output": "gloomy"},
{"input": "windy", "output": "calm"},
]

# 字符串模板
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="Input: {input}\\nOutput: {output}",
)

# 语义相似示例选择器：挑和用户问题【语义最接近】的示例（不是按顺序/长度）
example_selector = SemanticSimilarityExampleSelector.from_examples(
examples,
FastEmbed(), # 嵌入类用于生成语义相似度向量
Chroma, # 向量库，存储嵌入并做相似度搜索
k=1, # 选几个示例
)

# 用选择器实例化模板
similar_prompt = FewShotPromptTemplate(
example_selector=example_selector,
example_prompt=example_prompt,
prefix="给出每个输入的反义词",
suffix="Input: {adjective}\\nOutput:",
input_variables=["adjective"],
)

# 只看组装好的提示词（看选了哪些示例）
print(similar_prompt.invoke({"adjective": "worried"}).to_messages()[0].content)

运行结果：

=== 提示词内容（worried【担心】语义最接近哪个示例）===
给出每个输入的反义词

Input: happy
Output: sad

Input: worried
Output:

可见：worried（担心）在语义上最接近 happy（开心），所以只选中了它。

3.4 按最大边际相关性选择示例（MMR）

概念

最大边际相关性（MMR，Maximum Marginal Relevance） 是一种重排序算法，它利用语义相似性作为基础工具，从候选集中选出一组既能代表查询主题又彼此多样化的结果。

它与语义相似性的区别可类比为：

典型使用场景：

实现该策略的选择器是：MaxMarginalRelevanceExampleSelector。

内置方法：from_examples、add_example、select_examples。

代码示例：

import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
os.environ["HF_HUB_DISABLE_XET"] = "1"

from langchain_openai import ChatOpenAI
from langchain_chroma import Chroma
from langchain_core.example_selectors import MaxMarginalRelevanceExampleSelector
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_core.embeddings import Embeddings
from fastembed import TextEmbedding

# 嵌入封装：DeepSeek 没有 embedding 接口，这里用 fastembed（本地轻量，免 torch）
class FastEmbed(Embeddings):
def __init__(self, model="BAAI/bge-small-en-v1.5"):
self.m = TextEmbedding(model)
def embed_documents(self, texts):
return [v.tolist() for v in self.m.embed(list(texts))]
def embed_query(self, text):
return next(self.m.embed([text])).tolist()

# 反义词示例集合
examples = [
{"input": "happy", "output": "sad"},
{"input": "tall", "output": "short"},
{"input": "energetic", "output": "lethargic"},
{"input": "sunny", "output": "gloomy"},
{"input": "windy", "output": "calm"},
]

# 字符串模板
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="Input: {input}\\nOutput: {output}",
)

# MMR 示例选择器：既看重"和问题的相似度"，又兼顾"示例之间不重复"
example_selector = MaxMarginalRelevanceExampleSelector.from_examples(
examples,
FastEmbed(), # 嵌入类
Chroma, # 向量库
k=2, # 选 2 个（MMR 特点：相似的 + 补充多样性的）
)

# 用选择器实例化模板
similar_prompt = FewShotPromptTemplate(
example_selector=example_selector,
example_prompt=example_prompt,
prefix="给出每个输入的反义词",
suffix="Input: {adjective}\\nOutput:",
input_variables=["adjective"],
)

#只看组装好的提示词（MMR 选了哪 2 个示例）
print(similar_prompt.invoke({"adjective": "worried"}).to_messages()[0].content)

运行结果：

=== 提示词内容（MMR 选中的 2 个示例）===
给出每个输入的反义词

Input: happy
Output: sad

Input: windy
Output: calm

Input: worried
Output:

可见：worried → 选了最像的 happy + 补充多样性的 windy。

3.5 按 n-gram 重叠选择示例（NGram）

概念

n-gram 指一个文本序列中连续的 n 个词（word）或字符（character）。n-gram 重叠 是一种通过计算两段文本之间共同拥有的 n-gram 数量来衡量相似度的方法。

因此，传统 n-gram 重叠 是一种表面形式匹配，只关心词是否完全一样，无法处理同义词。

语义 n-gram 重叠：它不再比较词本身，而是比较词背后的语义向量（Embedding）——计算它们在语义空间中的向量是否相似，若相似度超过阈值就认为它们"重叠"。例如 "苹果" vs "iPhone" 向量相似度 0.95 → 视为重叠；"好用" vs "不错" 相似度 0.82 → 视为重叠。常用于剽窃检测，能发现"改换了词汇但保留了核心思想"的"智能"剽窃。

LangChain 实现该策略的选择器是：NGramOverlapExampleSelector，其参数如下：

threshold 取值行为：

内置方法：add_example(example)、select_examples(input_variables) → list[dict]。

代码示例：

import os
from langchain_openai import ChatOpenAI
from langchain_community.example_selectors import NGramOverlapExampleSelector
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate

# 翻译示例
examples = [
{"input": "See Spot run.", "output": "看见Spot跑。"},
{"input": "My dog barks.", "output": "我的狗叫。"},
{"input": "Spot can run.", "output": "Spot可以跑。"},
]

# 字符串模板
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="Input: {input}\\nOutput: {output}",
)

# NGram 示例选择器：按 n-gram 重叠度来挑和用户问题最像的示例
example_selector = NGramOverlapExampleSelector(
examples=examples,
example_prompt=example_prompt,
threshold=0, # 按重叠分数排序，并排除与输入没有 n-gram 重叠的示例
)

# 用选择器实例化模板
dynamic_prompt = FewShotPromptTemplate(
example_selector=example_selector,
example_prompt=example_prompt,
prefix="给出每个输入的中文翻译",
suffix="Input: {sentence}\\nOutput:",
input_variables=["sentence"],
)

# 定义大模型（适配 DeepSeek）
model = ChatOpenAI(
model="deepseek-chat",
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com",
)

# 方式一：只看组装好的提示词（选了哪些示例）
print(dynamic_prompt.invoke({"sentence": "Spot can run fast."}).to_messages()[0].content)

运行结果：

=== 提示词内容（NGram 选中的示例）===
给出每个输入的中文翻译

Input: Spot can run.
Output: Spot可以跑。

Input: See Spot run.
Output: 看见Spot跑。

Input: Spot can run fast.
Output:

可见：Spot can run fast. 与 Spot can run.、See Spot run. 的 n-gram 重叠最多，被优先选中。

3.6 总结对比

四、复盘（附答案）

💡 思考题

📝 答案

 🎯 闭幕

从"提示词模板"到"少样本提示"，从"LangChain Hub"到"四大示例选择器"——这一篇帮你把 LangChain 的提示工程走了一遍。

如果本文对你有帮助，欢迎：

👍 点赞 ｜ ⭐ 收藏 ｜ 👤 关注作者 ｜ 💬 留言交流你的疑问或补充

你的每一次互动都是我继续更新的动力，我们下一篇见！🚀