3. 少样本提示（few-shotting）

LangChain 少样本提示核心类和方法速览

前置知识：涉及的核心类和方法

在写代码之前，先把涉及的"零件"搞清楚。

1. `PromptTemplate` --- 字符串模板

python 复制代码

from langchain_core.prompts import PromptTemplate

作用： 把一个带 {占位符} 的字符串模板，填上实际值后生成最终文本 。它是 LangChain 中最基础的文本构建块，所有更复杂的模板都基于它扩展。

以下是初始化 PromptTemplate 对象时需要传入的参数，掌握它们是后续灵活构建提示的基础：

初始化参数：

参数	类型	说明
`template`	`str`	模板字符串，用 `{变量名}` 做占位符
`input_variables`	`list[str]`	有哪些变量需要填入

在实际开发中，通常先用 from_template 类方法自动提取变量，或者手动指定 input_variables 以保证数据安全。

示例：

python 复制代码

template = PromptTemplate(
    template="你好，我叫{name}，今年{age}岁",
    input_variables=["name", "age"],
)

result = template.invoke({"name": "小明", "age": 25}).to_string()
# 输出："你好，我叫小明，今年25岁"

说明： 它实现了 Runnable 接口，所以可以 .invoke(dict) 调用，返回 PromptValue 对象。PromptValue 有两个关键方法：

方法	返回值	说明
`.to_string()`	`str`	转成普通字符串
`.to_messages()`	`list[BaseMessage]`	转成聊天消息列表

2. `ChatPromptTemplate` --- 聊天消息模板

python 复制代码

from langchain_core.prompts import ChatPromptTemplate

作用： PromptTemplate 只能生成字符串，但聊天模型需要的是消息列表 （SystemMessage、HumanMessage、AIMessage）。ChatPromptTemplate 就是生成消息列表的模板，它让开发者可以精确控制每条消息的角色和内容。

示例：

python 复制代码

prompt = ChatPromptTemplate([
    ("system", "你是一个{role}"),       # 系统消息模板
    ("human", "{user_input}"),          # 用户消息模板
])

messages = prompt.invoke({"role": "数学老师", "user_input": "1+1等于几?"}).to_messages()
# 输出：[SystemMessage("你是一个数学老师"), HumanMessage("1+1等于几?")]

消息元组格式： ("角色", "模板内容")，角色可以是：

"system" → 系统消息（设定对话背景）
"human" → 用户消息（实际提问）
"ai" → AI 消息（历史回复，用于情境延续）

使用中可根据需要添加多个元组，角色也可省略而直接传入 SystemMessage 等对象来构建

3. `FewShotPromptTemplate` --- 少样本提示模板（字符串版）

python 复制代码

from langchain_core.prompts import FewShotPromptTemplate

作用： 这是核心类。接收一堆示例 + 一个格式化模板 ，自动把所有示例拼成一段文本，然后附加你的实际问题。适合纯文本 LLM 或需要整体控制提示布局的场景。

下面列出它所有初始化参数，理解每个参数的用途能帮助你自由设计提示结构：

参数	类型	说明
`examples`	`list[dict]`	示例列表，每个示例是一个字典，键名需与 `example_prompt` 中的变量名对应
`example_prompt`	`PromptTemplate`	用于格式化单个示例的模板，决定每个示例的呈现形式
`prefix`	`str`（可选）	放在所有示例前面的文字，通常用来下达整体指令或背景说明
`suffix`	`str`（可选）	放在所有示例后面的文字，通常用于放置用户的实际提问，内部可以包含变量
`input_variables`	`list[str]`	`suffix` 中用到的变量名列表
`example_selector`	`BaseExampleSelector`（可选）	示例选择器，和 `examples` 二选一。当示例数量动态变化时用于智能筛选

内部工作流程：

遍历 examples 列表中的每个示例字典
用 example_prompt 逐一格式化每个示例
把 prefix + 所有格式化后的示例 + suffix 拼接起来
通过 .invoke() 返回完整的 PromptValue

使用时请注意，若 examples 为固定集合，直接传入即可；若需根据输入长度动态选择示例，则应使用 example_selector。

4. `FewShotChatMessagePromptTemplate` --- 少样本提示模板（聊天消息版）

python 复制代码

from langchain_core.prompts import FewShotChatMessagePromptTemplate

作用： 与 FewShotPromptTemplate 类似，但输出的是聊天消息列表 ，而不是字符串。专为聊天模型设计，可与 ChatPromptTemplate 无缝配合，保留每条示例消息的角色信息。

初始化参数非常简洁，但关键在于搭配的 example_prompt 类型必须匹配：

参数	类型	说明
`examples`	`list[dict]`	示例列表，每个字典对应一条示例，键名需与消息模板中的变量一致
`example_prompt`	`ChatPromptTemplate`	用于格式化单个示例的聊天消息模板，决定每个示例生成哪些消息

关键区别： example_prompt 必须是 ChatPromptTemplate（生成消息），而不是 PromptTemplate（生成字符串）。这保证了示例能够以多轮对话的形式展现给模型。

5. `LengthBasedExampleSelector` --- 按长度选择示例

python 复制代码

from langchain_core.example_selectors import LengthBasedExampleSelector

作用： 当示例太多时，根据格式化后的总长度自动选择一部分示例，防止超过 LLM 的上下文窗口。它属于最简单的示例选择器，适合示例数量不多但需控制 token 数的场景。

需要设置的参数如下：

参数	说明
`examples`	可供选择的全部示例列表
`example_prompt`	格式化单个示例的模板，用于计算每个示例格式化后的长度
`max_length`	格式化后所有选中示例的总长度上限（超过上限的示例将被舍弃）
`get_text_length`	测量长度的函数，默认按空格/换行分词后统计词数，也可自定义

它提供两个主要方法，方便在运行时维护和筛选示例：

方法	说明
`add_example(example: dict)`	动态添加新示例到候选列表
`select_examples(input_variables: dict)`	根据当前输入（常与 `suffix` 结合）计算剩余空间，并选择合适数量的示例，返回 `list[dict]`

6. `tool_example_to_messages` --- 工具调用示例转换器

python 复制代码

from langchain_core.utils.function_calling import tool_example_to_messages

注意：此功能处于测试阶段，API 可能变化。

作用： 把"输入文本 + 期望的结构化输出"转换成标准的 HumanMessage / AIMessage / ToolMessage 格式，这样聊天模型就能直接看懂示例，并模仿类似的工具调用行为。

调用时需传入如下参数：

参数	类型	说明
`input`	`str`	用户的原始输入文本
`tool_calls`	`list[BaseModel]`	Pydantic 模型实例列表，表示期望的结构化输出内容
`ai_response`	`str`（可选）	模型对应该示例的简短文本回复，通常用于区分是否有信息被提取

返回值： list[BaseMessage] --- 转换后的消息列表，可直接嵌入 MessagesPlaceholder 作为示例对话历史。

7. `MessagesPlaceholder` --- 消息占位符

python 复制代码

from langchain_core.prompts import MessagesPlaceholder

作用： 在 ChatPromptTemplate 中预留一个"消息插槽"，后续 invoke 时用实际的消息列表替换它。这使得模板可以动态插入历史对话、示例消息等可变消息序列。

python 复制代码

prompt = ChatPromptTemplate([
    SystemMessage(content="你是一个助手"),
    MessagesPlaceholder("history"),          # 这里会被替换
    ("human", "{user_input}"),
])

# invoke 时传入 history
prompt.invoke({
    "history": [HumanMessage("你好"), AIMessage("你好！")],
    "user_input": "我叫小明",
})

MessagesPlaceholder 的参数只是占位符名称，模板在调用时会从输入字典中查找同名键对应的消息列表。若要插入固定消息，也可以直接在模板中声明。

3.1 概念

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

这能解决什么问题？LLM 虽然知识渊博，但有时我们需要它以非常特定的格式、风格或逻辑来回答问题。提供正确的示例可以减少模型"胡说八道"或犯低级错误的概率，将其输出约束在你提供的范例范围内。

强制要求模型以特定的格式（如JSON、XML、特定的列表样式）输出结果。样例可以当作格式样板。
有些任务很难用文字指令清晰描述（例如："请用莎士比亚的风格写作"）。提供几个例子比写长

篇大论的指令更有效。

对于需要多步推理的复杂任务，示例可以展示出思考链，引导模型遵循类似的推理路径。

3.2 实现少样本提示

examples (4个dict)

│

▼
example_prompt_template (ChatPromptTemplate)

│ 逐个格式化，每个dict → HumanMessage + AIMessage

▼

few_shot_prompt.invoke({})

│ 生成 8 条消息（4问4答）

▼

ChatPromptTemplate 组装:

SystemMessage, ...8条示例..., HumanMessage(真实问题)

│

▼

chain.invoke({"text": "hi, what is your favourite food?"})

│

▼

AIMessage("你好，你最喜欢的食物是什么？")

先准备示例数据 → 定义示例如何成对出现 → 包装成少样本模板 → 把系统消息、少样本模板、新用户输入拼成最终提示 → 丢给模型。

实现少样本提示的第一步 也是最重要的一步是提出一个好的示例数据集 。好的示例应该在运行时相

关、清晰、信息丰富，并提供模型尚不知道的信息。

python 复制代码

from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate, PromptTemplate
from langchain_deepseek import ChatDeepSeek

#少样本提示词
#向LLM提供少量示例或者样本，教会她如何执行某些特定任务技术

#1、先准备示例集
examples = [
    {"text": "hi, what is your name?",    "output": "你好，你叫什么名字？"},
    {"text": "hi, what is your age?",     "output": "你好，你多大了？"},
    {"text": "where are you from?",       "output": "你来自哪里？"},
    {"text": "what do you like to do?",   "output": "你喜欢做什么？"},
]

如何让大模型看懂这份示例呢？之前我们说过聊天模型读的是聊天消息 。因此，接下来我们需要将示例集实例化成 聊天模型可以读懂的聊天消息。

对于 LangChain 就需要创建一个FewShotChatMessagePromptTemplate 对象来实例化示例集。
FewShotChatMessagePromptTemplate 是一个提示词模板，专门用来将示例集实例化为聊天消
息

python 复制代码

#2、定义单个实例的格式化模板
#ChatPromptTemplate 接收一个列表，列表里每个元组代表一条消息：("角色", "模板内容")
#{text} 和 {output} 是占位符，对应 examples 里每个字典的 key。调用时会被替换成实际值。
example_prompt_template=ChatPromptTemplate([
    ("user", "{text}"), #→   HumanMessage(content="hi, what is your name?")
    ("ai", "{output}"), #→   AIMessage(content="你好，你叫什么名字？")
])

#3、创建少样本提示词模板
#FewShotChatMessagePromptTemplate --- 少样本提示模板（聊天消息版）
# 与 FewShotPromptTemplate(少样本提示模板（字符串版）)类似，但输出的是聊天消息列表，而不是字符串。
# 用于和 ChatPromptTemplate 配合。
few_shot_prompt = FewShotChatMessagePromptTemplate(
    examples=examples, #示例数据
    example_prompt=example_prompt_template, #每个示例怎么格式化成消息："按什么格式把每个字典转成消息"
)

#打印看看示例生成了什么
# few_shot_prompt.invoke({}) --- 调用模板。
# 因为示例里没有需要外部传入的变量（所有占位符的值都来自 examples 本身），所以传空字典 {}
# .to_messages() --- 把结果转为消息列表
# msg.type --- 消息的类型字符串（"human"、"ai"、"system"）
# msg.content --- 消息的文本内容
print("===少样本模板生成的消息序列===")
for msg in few_shot_prompt.invoke({}).to_messages():
    print(f"{msg.type}: {msg.content}")

#构建最终的完整提示
#ChatPromptTemplate --- 聊天消息模板
# PromptTemplate 只能生成字符串，
# 但聊天模型需要的是消息列表（SystemMessage、HumanMessage、AIMessage）。
# ChatPromptTemplate 就是生成消息列表的模板。
chat_prompt_template=ChatPromptTemplate([
    ("system","你的任务只有一件事，把用户输入的英文翻译成中文，不要回答其他的问题，只输出对应中文翻译即可"),
    few_shot_prompt,
    ("user","{text}"),
])
#验证最终提示长什么样
filled = chat_prompt_template.invoke(
    {
        "language_from": "英文",
        "language_to": "中文",
        "text": "hi, what is your favourite food?",
    }
)
for msg in filled.to_messages():
    print(f"{msg.type}: {msg.content}")

#构建链并调用模型
model=ChatDeepSeek(model="deepseek-v4-flash")
chain=chat_prompt_template | model
response=chain.invoke({
    "language_from": "英文",
    "language_to": "中文",
    "text": "hi, what is your favourite food?",
})
print("===模型回答===")
response.pretty_print()

步骤	做了什么	为什么这样做
1. 准备示例	定义 `examples` 列表，每个示例包含 `"text"`（输入）和 `"output"`（期望输出）。	少样本学习的核心：向模型展示几个输入-输出的配对，让模型"学会"任务的模式。
2. 定义单个示例的格式	创建 `examples_prompt_template`，将每个示例映射为一条 `HumanMessage` + 一条 `AIMessage`。	聊天模型需要消息格式的示例，不能直接读字典。这个模板规定了如何把一条原始数据转成消息对。
3. 创建少样本模板	用 `FewShotChatMessagePromptTemplate` 包装示例列表和单个示例模板。	这个组件负责将整个示例列表自动转换成一组连续的消息（例如：人→机→人→机...）。它实现了 Runnable 接口，可以像函数一样调用。
4. 构建最终提示	创建一个 `ChatPromptTemplate`，依次放入：系统消息、少样本模板、用户新输入。	系统消息定义全局任务，少样本模板提供示范，最后放上真正要处理的问题。这样模型在看到新输入前，先看到了几个"正确答案"的例子。
5. 调用模型	将最终提示与模型组合成链，并 `invoke` 传入变量。	链式调用会自动完成：变量填充 → 生成完整消息列表 → 发送给 LLM → 返回回答。

少样本提示总结

第一步：准备示例集（教材）

先想清楚：我要让模型学会什么任务？ 然后用一个列表，把"输入→输出"的例子写出来。

python

复制代码

examples = [
    {"input": "用户会说的话", "output": "模型应该回答的话"},
    {"input": "...", "output": "..."},
]

为什么先做这一步？

因为示例是少样本提示的灵魂。你的示例质量，直接决定了模型学得好不好。花时间打磨示例，比改代码更重要。

第二步：定义单个示例的排版格式

用一个 ChatPromptTemplate，告诉 LangChain：每个示例应该按什么格式转换成聊天消息？

python

复制代码

from langchain_core.prompts import ChatPromptTemplate

example_prompt = ChatPromptTemplate([
    ("user", "{input}"),    # 用户角色，取示例中的 "input" 字段
    ("ai", "{output}"),     # AI角色，取示例中的 "output" 字段
])

注意：{input} 和 {output} 必须和你示例字典里的键名保持一致。

第三步：用少样本模板"批量翻译"示例

这一步是"自动化工厂"。FewShotChatMessagePromptTemplate 拿你前两步准备好的"教材"和"排版格式"，自动把所有示例变成一长串聊天消息。

python

复制代码

from langchain_core.prompts import FewShotChatMessagePromptTemplate

few_shot_prompt = FewShotChatMessagePromptTemplate(
    examples=examples,              # 第一步的示例列表
    example_prompt=example_prompt,  # 第二步的排版模板
)

到这里，你已经有了一组"可插入的对话历史"。

第四步：组装最终提示模板

用一个大号的 ChatPromptTemplate，把系统指令 + 示例对话 + 新问题串成一条完整的消息序列。

python

复制代码

final_prompt = ChatPromptTemplate([
    ("system", "这里是给模型的全局指令，告诉它要做什么"),  # 系统消息
    few_shot_prompt,                                     # 第三步生成的示例对话
    ("user", "{input}"),                                 # 真正要处理的新问题
])

为什么是这个顺序？

因为聊天模型是按顺序读消息的。系统消息定基调 → 示例对话给范例 → 最后的问题让它照葫芦画瓢。

第五步：串联模型，执行调用

最后，把模板和模型用管道符 | 串成链，调用 invoke 传入变量。

python

复制代码

from langchain_deepseek import ChatDeepSeek

model = ChatDeepSeek(model="deepseek-v4-flash")  # 或 deepseek-chat
chain = final_prompt | model

response = chain.invoke({
    "input": "你想问的新问题",
})

复制代码

第一步：准备示例（字典列表）
         ↓
第二步：定义单示例排版格式（ChatPromptTemplate）
         ↓
第三步：批量翻译成消息（FewShotChatMessagePromptTemplate）
         ↓
第四步：组装最终提示（ChatPromptTemplate：系统 + 示例 + 新问题）
         ↓
第五步：串联模型，invoke 调用

3.3 使用案例

3.3.1 案例一：推理引导

我们希望输入：

《教父》和《星球大战》的导演来自同一个国家吗？

让聊天模型可以先分析再得出结论，而不是直接得出结论。分析过程需要展示出来

python 复制代码

# ==================== 1. 导入所需模块 ====================
from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate
from langchain_deepseek import ChatDeepSeek

# ==================== 2. 准备示例集（每个示例都展示了"先推理、后答案"的模式） ====================
examples = [
    {
        "question": "李白和杜甫，谁更长寿？",
        "answer": (
            "是否需要后续问题：是的。\n"
            "后续问题：李白享年多少岁？\n"
            "中间答案：李白享年61岁。\n"
            "后续问题：杜甫享年多少岁？\n"
            "中间答案：杜甫享年58岁。\n"
            "所以最终答案是：李白"
        )
    },
    {
        "question": "腾讯的创始人什么时候出生？",
        "answer": (
            "是否需要后续问题：是的。\n"
            "后续问题：腾讯的创始人是谁？\n"
            "中间答案：腾讯由马化腾创立。\n"
            "后续问题：马化腾什么时候出生？\n"
            "中间答案：马化腾出生于1971年10月29日。\n"
            "所以最终答案是：1971年10月29日"
        )
    },
    {
        "question": "孙中山的外祖父是谁？",
        "answer": (
            "是否需要后续问题：是的。\n"
            "后续问题：孙中山的母亲是谁？\n"
            "中间答案：孙中山的母亲是杨太夫人。\n"
            "后续问题：杨太夫人的父亲是谁？\n"
            "中间答案：杨太夫人的父亲是杨胜辉。\n"
            "所以最终答案是：杨胜辉"
        )
    },
    {
        "question": "电影《红高粱》和《霸王别姬》的导演来自同一个国家吗？",
        "answer": (
            "是否需要后续问题：是的。\n"
            "后续问题：《红高粱》的导演是谁？\n"
            "中间答案：《红高粱》的导演是张艺谋。\n"
            "后续问题：张艺谋来自哪里？\n"
            "中间答案：中国。\n"
            "后续问题：《霸王别姬》的导演是谁？\n"
            "中间答案：《霸王别姬》的导演是陈凯歌。\n"
            "后续问题：陈凯歌来自哪里？\n"
            "中间答案：中国。\n"
            "所以最终答案是：是"
        )
    },
]

# ==================== 3. 定义"单个示例"的格式化模板 ====================
# 这个是纯字符串模板，每个示例会被格式化成：Question: ... \n answer ...
example_prompt = PromptTemplate.from_template("Question: {question}\n{answer}")

# ==================== 4. 创建"少样本提示模板"（字符串版） ====================
# 注意：这里用的是 FewShotPromptTemplate，而不是 FewShotChatMessagePromptTemplate
few_shot_prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    # suffix 是示例之后的模板字符串，{input} 是真正要问的新问题
    suffix="Question: {input}",
    input_variables=["input"],
)

# ==================== 5. 生成最终的提示字符串并打印（调试用） ====================
final_prompt_str = few_shot_prompt.invoke({"input": "《教父》和《星球大战》的导演来自同一个国家吗？"})
print("=== 最终发给模型的提示字符串 ===")
print(final_prompt_str)

# ==================== 6. 调用 DeepSeek 模型 ====================
model = ChatDeepSeek(model="deepseek-v4-flash")
response = model.invoke(final_prompt_str)  # 直接传入字符串，模型会自动包装成 HumanMessage

print("\n=== 模型回答 ===")
response.pretty_print()

3.3.2 案例二：使用示例数据增强 LangChain 信息提取能力

在结构化输出那一块笔记中有一个使用场景是使用结构化输出进行信息提取 。当时说明

可以结合少样本提示来实现。于是在这里，我们来实现一个基于 LangChain 的结构化信息提取系统，专门从文本中提取人物相关信息。例如我们希望，对于输入以下文本："篮球场上，身高两米的中锋王伟默契地将球传给一米七的后卫挚友李明，完成一记绝杀。这对老友用十年配合弥补了身高的差距。"代码会提取出结构化数据

说白了，就是先造好一个名叫Data的模具，再定义几个文本描述和标注数据作为样板，接着用一个翻译官把样板变成模型能看懂的工具调用消息格式，再把这些消息和模板通通塞给模型

tool_example_to_messages (工具函数)
- 它是一个翻译官 。我们定义了一对示例："输入文本"和"期望的结构化对象"。但这个"结构化对象"模型看不太明白，得由它翻译成模型能秒懂的消息序列（即 HumanMessage → AIMessage（带工具调用） → ToolMessage → AIMessage）。
- 它的核心参数：
  - input_str：示例中的原始文本
  - tool_calls：我们希望模型调用的工具列表（这里是包含我们定义的 Data 对象的列表）
  - ai_response：最后的确认消息，比如"检测到人"或"未检测到人"
- 为什么需要它？
  
  因为我们希望模型学会调用工具来输出结构化结果。这个函数把"教它调用工具"的过程完全自动化了，不用我们手动去拼那四条消息。
Data 和 Person (Pydantic BaseModel)
- 它们是干什么的？
  
  它们是数据模具 。我们用它来定义最终想要的那个结构化数据的"形状"。Person 定义了单个人的信息，Data 定义了一组 Person 的列表。Field(description="...") 是模具上的标签，告诉模型每个字段是什么意思。
- 它的核心参数：
  - Field(...) 表示该字段是必填的。
  - Field(default=None) 表示该字段是可选的。
- 为什么需要它？
  
  之前我们让模型输出纯文本，现在要它输出一个结构化的"对象"。Pydantic 类能精确描述这个对象的样子，并能在模型输出后进行验证，确保格式正确。它也是我们定制的工具。
with_structured_output(schema)
- 它是干什么的？
  
  这是一个模式绑定器 。它能把我们刚才定义的那个"数据模具（Data 类）"绑定到模型上，告诉模型："你接下来输出的内容，必须严格按照这个模具来"
- 为什么需要它？
  
  这是开启模型"结构化输出"能力的核心开关。没有它，模型只能返回给我们人类看的一堆字。

示例代码：

定义数据模具

Data

└── people: List[Person] ← 一个 Data 里包含多个人

└── Person ← 每个人有自己的属性

├── name

├── hair_color

├── skin_color

└── height_in_meters

python 复制代码

# ==================== 0. 导入所需模块 ====================
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
from langchain_deepseek import ChatDeepSeek

# ==================== 1. 定义数据模具（结构化输出 Schema）====================
# 为什么要定义这两个类？这就叫"结构化输出的 Schema"。
# 想一想：你让大模型"从一段文字里提取人名和身高"，它默认只会返回一段自然语言文字，
# 比如"我发现了王伟，身高两米..."。但你的程序需要的是 Python 对象，方便后续存入数据库、转 JSON、做逻辑判断。
# Pydantic 的作用就是： 定义一个"模具"，告诉模型：你的输出必须长成这个样子，缺字段填 None，多出来的不要。
# 先定义单个人的信息"模具"
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[str] = Field(default=None, description="以米为单位的高度")

# 再定义一个总"模具"，里面装着多个 Person
class Data(BaseModel):
    """提取关于人的数据。"""
    people: List[Person]

准备两个关键示例

这两个示例的设计非常讲究，不是随便选的，两个示例覆盖了最核心的两种边界情况。这比给 10 个"完美信息"的示例更有效。

示例	输入特征	期望输出	教会模型什么
示例1	文本里没有任何名字	`Data(people=[])`，空列表	不要无中生有。没人就是没人，别捏造
示例2	有人名但其他信息全缺	`Person(name="小强", height=None, ...)`	不知道就填 `None`。别因为不知道身高就瞎编一个

python 复制代码

# ==================== 2. 准备两个关键示例（教材） ====================
# 示例1（无人物信息）：把文本和期望的 Data 对象配成对
example_1_text = "海洋是广阔而蓝色的。它有两万多英尺深。"
example_1_output = Data(people=[])  # 期望：没提取到人

# 示例2（部分信息缺失）：给模型看，信息不全的也要正常提取
example_2_text = "小强从中国远行到美国。"
example_2_output = Data(people=[
    Person(name="小强", height_in_meters=None, skin_color=None, hair_color=None),
])

# 把示例放在一个列表里，方便之后处理
examples = [
    (example_1_text, example_1_output),
    (example_2_text, example_2_output),
]

把示例变成模型能读的消息

python 复制代码

# ==================== 3. 把示例变成模型爱吃的"粮草"（消息序列）====================
#准备一个用来装所有示例消息的大箱子等会儿 MessagesPlaceholder 会用这个列表替换掉自己。
example_messages = []

for text, tool_call in examples:
    # 根据提取结果，生成一个简单的AI确认语
    if tool_call.people:
        ai_response = "检测到人"
    else:
        ai_response = "未检测到人"

    # 关键一步：调用"翻译官" tool_example_to_messages
    # 它会把这个示例对，翻译成【HumanMessage, AIMessage(调用工具), ToolMessage, AIMessage("检测到人")】
    # 并加到 example_messages 这个大箱子里
    example_messages.extend(
        tool_example_to_messages(
            text,           # 原始文本
            [tool_call],    # 要调用的工具列表，这里就是把示例中的 Data 对象包一层
            ai_response=ai_response  # 最终的AI确认消息
        )
    )

遍历每一个示例，每次循环拿到：

变量	第一次循环的值	第二次循环的值
text	"海洋是广阔而蓝色的..."	"小强从中国远行到美国。"
tool_call	Data(people=[])	Data(people=[Person(name="小强", ...)])
ai_response	"未检测到人"	"检测到人"

tool_call.people 的判断逻辑：

空列表 [] 在 Python 里是 falsy 的 → "未检测到人"

有元素的列表是 truthy 的 → "检测到人"

tool_example_to_messages 内部做了什么？以示例 2（"小强从中国远行到美国"）为例，它会生成如下消息序列：

顺序	消息类型	内容	为什么
1	HumanMessage	"小强从中国远行到美国。"	模拟用户发来的待提取文本
2	AIMessage	tool_calls=[{"name": "Data", "args": {"people": [{"name": "小强", ...}]}}]	模拟 AI 决定调用 Data 工具，传入提取结果
3	ToolMessage	工具调用结果的回执	模拟工具返回了结果
4	AIMessage	"检测到人"	AI 最后的确认语（你传的 ai_response）

这就是一整套"人机交互记录"。模型看到这段记录后，会学习到：收到类似文本时，我应该调用 Data 工具，参数长这样。

extend 和 append 的区别：extend 把列表展开后逐个加进去，不是把整个列表当一个元素加进去。因为 tool_example_to_messages 返回的是一个列表（可能 3-4 条消息），要展开。

搭建最终提示模板

.from_messages() 是 ChatPromptTemplate 的一个类方法，和直接 ChatPromptTemplate([...]) 效果完全一样，写法不同而已。

python 复制代码

# ==================== 4. 搭建最终提示模板（总装车间）====================
final_prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="你是一个提取信息的专家，只从文本中提取相关信息。如果您不知道要提取的属性值，属性值返回null"),
    MessagesPlaceholder("example_messages"),  # 占位符，这里会放入示例消息列表
    ("user", "{new_message}"),               # 真正要提取的新文本
])

MessagesPlaceholder 工作原理：

模板定义时 ------ 这里是个坑

python 复制代码

MessagesPlaceholder("example_messages")

invoke 调用时 ------ 用实际列表填坑

python 复制代码

final_prompt.invoke({
    "example_messages": example_messages,  # ← 替换那个坑
    "new_message": "篮球场上，身高两米的..."
})

填完之后，最终消息序列就是：

**[0] SystemMessage: "你是一个提取信息的专家..."

LangChain之核心组件(少样本提示词)

3. 少样本提示（few-shotting）

LangChain 少样本提示核心类和方法速览

前置知识：涉及的核心类和方法

1. PromptTemplate --- 字符串模板

2. ChatPromptTemplate --- 聊天消息模板

3. FewShotPromptTemplate --- 少样本提示模板（字符串版）

4. FewShotChatMessagePromptTemplate --- 少样本提示模板（聊天消息版）

5. LengthBasedExampleSelector --- 按长度选择示例

6. tool_example_to_messages --- 工具调用示例转换器

7. MessagesPlaceholder --- 消息占位符

3.1 概念

3.2 实现少样本提示

少样本提示 总结

第一步：准备示例集（教材）

第二步：定义单个示例的排版格式

第三步：用少样本模板"批量翻译"示例

第四步：组装最终提示模板

第五步：串联模型，执行调用

3.3 使用案例

3.3.1 案例一：推理引导

3.3.2 案例二：使用示例数据增强 LangChain 信息提取能力

定义数据模具

准备两个关键示例

把示例变成模型能读的消息

搭建最终提示模板

模板定义时 ------ 这里是个坑

invoke 调用时 ------ 用实际列表填坑

1. `PromptTemplate` --- 字符串模板

2. `ChatPromptTemplate` --- 聊天消息模板

3. `FewShotPromptTemplate` --- 少样本提示模板（字符串版）

4. `FewShotChatMessagePromptTemplate` --- 少样本提示模板（聊天消息版）

5. `LengthBasedExampleSelector` --- 按长度选择示例

6. `tool_example_to_messages` --- 工具调用示例转换器

7. `MessagesPlaceholder` --- 消息占位符

少样本提示总结