LangChain链和LangGraph图的学习笔记【六】——提示语模板（3）——Few-Shot Prompting（少样本提示） 模板类

一、Few-Shot Prompting（少样本提示）的概念：

1. 大模型有几种典型的提示方式：

|--------------------|----------------------------------------------------------|
| 方式 | 说明 |
| Zero-Shot（零样本） | 只给指令，不给示例："请把下面句子翻译成英文：你好" |
| One-Shot（单样本） | 只给一个示例，是 Few-Shot 的特例 |
| Few-Shot（少样本） | 给指令 + 几个示例： "示例1：你好→Hello；示例2：再见→Goodbye；请翻译：谢谢" |

2. Few-Shot 的核心价值：

通过示例让模型"模仿学习"，无需微调就能学会自定义符号或规则（如你代码中的 # 代表乘方），稳定输出格式（如 JSON、固定标签），提升复杂任务的准确率。

二、【少样本提示语模板1】：

FewShotChatMessagePromptTemplate（对话消息版）

FewShotChatMessagePromptTemplate****类用于实现"少样本提示"（Few-Shot Prompting），即向模型提供几个示例，让模型模仿示例的格式和规律来回答问题，提升回答的准确性。它会把每个示例渲染成一轮或多轮对话消息（如 HumanMessage + AIMessage），作为"历史对话"插入到消息序列中------即让模型以为"用户之前问过这些问题，我（AI助手）之前是这样回答的"，从而模仿这种问答模式。

所在模块：langchain_core.prompts。

导入方式：from langchain_core.prompts import FewShotChatMessagePromptTemplate

# 从 langchain_core 的 prompts 模块中导入 FewShotChatMessagePromptTemplate 类
# 该类用于实现"少样本提示"（Few-Shot Prompting），即向模型提供几个示例，
# 让模型模仿示例的格式和规律来回答问题，提升回答的准确性
from langchain_core.prompts import FewShotChatMessagePromptTemplate

1. 应用步骤：‌

（1） 定义示例数据‌。
（2） 定义聊天示例模板‌：使用 ChatPromptTemplate 定义单轮对话的结构（如 Human 对应 input，AI 对应 output）。
（3） 组装模板‌：使用 FewShotChatMessagePromptTemplate。
（4） 结合主提示词‌：通常将其作为 ChatPromptTemplate 的一部分嵌入。

（5）执行调用：渲染出完整消息列表后调用模型。

2. 核心参数：

|----------------------|-------------------------|-----------------------------|
| 参数 | 类型 | 说明 |
| examples | Listdict | 静态示例列表 |
| example_selector | BaseExampleSelector | 动态示例选择器（与 examples 二选一） |
| example_prompt | ChatPromptTemplate | 单个示例的对话式渲染模板 |

【注意】它没有 prefix / suffix / example_separator 参数。前后文和最终问题需要通过外层的 ChatPromptTemplate.from_messages(...) 来组织，示例之间的分隔天然由消息边界完成，无需分隔符。

3. 代码示例**（后附有完整的代码，可直接复制运行）：**

示例代码实现了一个 Few-Shot（少样本提示）+ 自定义模型 实现把"#"符号换作乘方。

（1） 定义示例数据‌。

提示词工程：用 FewShotChatMessagePromptTemplate 把「3#2=9、3#3=27」两个示例包装成历史对话，配合系统指令教会模型理解自定义符号 # 表示乘方。

# 定义一个示例列表 examples，用于 Few-Shot（少样本）提示
# 列表中每个字典都是一个"输入→输出"的示例对，告诉模型符号 # 代表乘方运算的规律
examples = [
    # 第一个示例：3 # 2 即 3 的 2 次方，答案是 9（3² = 9）
    {"input": "3 # 2", "output": "9"},
    # 第二个示例：3 # 3 即 3 的 3 次方，答案是 27（3³ = 27）
    {"input": "3 # 3", "output": "27"},
]

（2） 定义聊天示例模板‌：使用 ChatPromptTemplate 定义单轮对话的结构（如 Human 对应 input，AI 对应 output）。

# 创建示例的提示词模板 example_prompt
# 它定义了每个示例在最终对话中的呈现格式：一条 human（用户）消息 + 一条 ai（模型）消息
# 即把每个示例伪装成"用户曾经问过、模型曾经答过"的历史对话
example_prompt = ChatPromptTemplate.from_messages([
    # human 角色消息，{input} 是占位符，会被示例字典中的 input 值替换（如 "3 # 2"）
    ("human", "{input}"),
    # ai 角色消息，{output} 是占位符，会被示例字典中的 output 值替换（如 "9"）
    ("ai", "{output}"),
])

（3） 组装模板‌：使用 FewShotChatMessagePromptTemplate。

# 创建少样本聊天提示词模板对象 few_shot_chat_prompt
# 该对象在渲染时会把 examples 中的所有示例，按照 example_prompt 定义的格式，
# 逐条转换为对话消息并插入到最终的提示词中
few_shot_chat_prompt = FewShotChatMessagePromptTemplate(
    # 指定单个示例的渲染模板（即上面创建的 example_prompt）
    example_prompt=example_prompt,
    # 指定要使用的示例数据列表（即上面定义的 examples）
    examples=examples,
)

（4） 结合主提示词‌：通常将其作为 ChatPromptTemplate 的一部分嵌入。

# 创建最终的完整对话提示词模板 final_chat_prompt
# 它把系统指令、少样本示例、用户当前问题三部分组合成一个完整的对话消息序列
final_chat_prompt = ChatPromptTemplate.from_messages([
    # system（系统）消息：设定模型的角色和任务规则
    # 告诉模型它是一个数学助手，要按示例格式回答，且符号 # 代表乘方运算
    ("system", "你是一个数学助手，请按照示例格式回答，符号#代表乘方。"),
    # 插入少样本示例模板对象，渲染后会展开为多轮 human/ai 示例对话
    # （注意：这里直接放对象而非元组，因为 FewShotChatMessagePromptTemplate 本身可渲染为多条消息）
    few_shot_chat_prompt,
    # human（用户）消息：用户真正要提问的问题，{input} 占位符将在 invoke 时被实际值替换
    ("human", "{input}"),
])

（5）执行调用：渲染出完整消息列表后调用模型，计算 2 # 9（即 2⁹ = 512），并打印答案和实际使用的模型名称。

# 调用模板的 invoke 方法进行渲染（变量填充）
# 传入参数字典 {"input": "2 # 9"}，把模板中所有的 {input} 占位符替换为 "2 # 9"
# 返回的 messages 是一个消息对象列表，包含 system 消息、4 条示例消息、1 条用户消息
messages = final_chat_prompt.invoke({"input": "2 # 9"})

# 调用 llm.invoke() 把渲染好的消息列表发送给大模型，进行同步推理
# 返回值 info 是一个 AIMessage 对象，包含模型的回复内容及元数据
info = llm.invoke(messages)

【示例1的完整代码，可直接复制运行】

# 这段代码实现了一个 Few-Shot（少样本提示）+ 自定义模型 的完整调用流程：
# 环境准备：通过 .env 文件安全地加载 API 密钥和阿里云百炼的服务地址；
# 模型初始化：创建支持深度思考（thinking）和联网搜索（search）的 qwen3.8-max 客户端，并开启流式输出；
# 提示词工程：用 FewShotChatMessagePromptTemplate 把「3#2=9、3#3=27」两个示例包装成历史对话，配合系统指令教会模型理解自定义符号 # 表示乘方；
# 执行调用：渲染出完整消息列表后调用模型，计算 2 # 9（即 2⁹ = 512），并打印答案和实际使用的模型名称。

# 从 langchain_openai 库中导入 ChatOpenAI 类
# 该类用于与兼容 OpenAI API 协议的大模型服务进行交互（如通义千问等国产模型也支持此协议）
from langchain_openai import ChatOpenAI

# 从 langchain_core 的 prompts 模块中导入 ChatPromptTemplate 类
# ChatPromptTemplate 用于构建"对话形式"的提示词模板，支持 system/human/ai 等多种角色的消息
from langchain_core.prompts import ChatPromptTemplate

# 从 langchain_core 的 prompts 模块中导入 FewShotChatMessagePromptTemplate 类
# 该类用于实现"少样本提示"（Few-Shot Prompting），即向模型提供几个示例，
# 让模型模仿示例的格式和规律来回答问题，提升回答的准确性
from langchain_core.prompts import FewShotChatMessagePromptTemplate

# 导入 Python 标准库 os 模块
# 用于操作环境变量、文件路径等系统相关功能
import os

# 从 dotenv 库中导入 load_dotenv 函数
# 该函数用于读取项目目录下的 .env 文件，并将其中的键值对加载到环境变量中
from dotenv import load_dotenv

# 执行 load_dotenv() 函数，自动查找并加载当前目录（或上级目录）下的 .env 文件
# 好处：将 API 密钥等敏感信息保存在 .env 文件中，而不是硬编码在代码里，更安全
load_dotenv()

# 通过 os.getenv() 从环境变量中读取名为 "API_KEY" 的值，赋给变量 key
# 这个 key 就是调用大模型 API 时所需的身份验证密钥（对应 .env 文件中的 API_KEY=xxx）
key = os.getenv("API_KEY")

# 从环境变量中读取名为 "ALI_URL" 的值，赋给变量 url
# 这是阿里云百炼（通义千问）API 的服务地址，因为要使用国产模型而非 OpenAI 官方模型，
# 所以必须指定自定义的 base_url（形如 https://dashscope.aliyuncs.com/compatible-mode/v1）
url = os.getenv("ALI_URL")

# 创建 ChatOpenAI 实例（即初始化一个大模型客户端对象），赋给变量 llm
# 后续通过 llm 对象来调用大模型进行推理
llm = ChatOpenAI(

    # 指定要使用的模型名称，这里是通义千问 qwen3.8-max 模型
    model="qwen3.8-max",

    # 指定 API 服务的基础地址，使用上面从环境变量读取的阿里云 API 地址
    # 这样请求就会发送到阿里云服务器，而不是 OpenAI 官方服务器
    base_url=url,

    # 指定 API 密钥，使用上面从环境变量读取的 key，用于身份验证
    api_key=key,

    # 设置温度参数为 1（取值范围一般为 0~2）
    # temperature 控制输出的随机性/创造性：值越大回答越随机多样，值越小回答越确定保守
    # 设为 1 表示使用模型默认的标准随机性
    temperature=1,

    # 开启流式输出模式（streaming）
    # 开启后模型的回复会像"打字机"一样逐字/逐块返回，而不是等待全部生成完毕才返回，
    # 可以显著降低首字响应延迟，改善用户体验
    streaming=True,

    # extra_body 用于向 API 请求体中添加额外的自定义参数（OpenAI 标准参数之外的扩展参数）
    extra_body={

        # 开启"深度思考"模式：模型在给出最终答案前会先进行内部推理（思维链），
        # 可以提高复杂问题（如数学、逻辑题）的回答质量
        "thinking": {"type": "enabled"},

        # 开启"联网搜索"模式：允许模型在回答时联网检索最新信息，
        # 适用于需要实时数据或模型知识库中没有的内容
        "search": {"type": "enabled"},
    },
)

# 定义一个示例列表 examples，用于 Few-Shot（少样本）提示
# 列表中每个字典都是一个"输入→输出"的示例对，告诉模型符号 # 代表乘方运算的规律
examples = [
    # 第一个示例：3 # 2 即 3 的 2 次方，答案是 9（3² = 9）
    {"input": "3 # 2", "output": "9"},
    # 第二个示例：3 # 3 即 3 的 3 次方，答案是 27（3³ = 27）
    {"input": "3 # 3", "output": "27"},
]

# 创建示例的提示词模板 example_prompt
# 它定义了每个示例在最终对话中的呈现格式：一条 human（用户）消息 + 一条 ai（模型）消息
# 即把每个示例伪装成"用户曾经问过、模型曾经答过"的历史对话
example_prompt = ChatPromptTemplate.from_messages([
    # human 角色消息，{input} 是占位符，会被示例字典中的 input 值替换（如 "3 # 2"）
    ("human", "{input}"),
    # ai 角色消息，{output} 是占位符，会被示例字典中的 output 值替换（如 "9"）
    ("ai", "{output}"),
])

# 创建少样本聊天提示词模板对象 few_shot_chat_prompt
# 该对象在渲染时会把 examples 中的所有示例，按照 example_prompt 定义的格式，
# 逐条转换为对话消息并插入到最终的提示词中
few_shot_chat_prompt = FewShotChatMessagePromptTemplate(
    # 指定单个示例的渲染模板（即上面创建的 example_prompt）
    example_prompt=example_prompt,
    # 指定要使用的示例数据列表（即上面定义的 examples）
    examples=examples,
)

# 创建最终的完整对话提示词模板 final_chat_prompt
# 它把系统指令、少样本示例、用户当前问题三部分组合成一个完整的对话消息序列
final_chat_prompt = ChatPromptTemplate.from_messages([
    # system（系统）消息：设定模型的角色和任务规则
    # 告诉模型它是一个数学助手，要按示例格式回答，且符号 # 代表乘方运算
    ("system", "你是一个数学助手，请按照示例格式回答，符号#代表乘方。"),
    # 插入少样本示例模板对象，渲染后会展开为多轮 human/ai 示例对话
    # （注意：这里直接放对象而非元组，因为 FewShotChatMessagePromptTemplate 本身可渲染为多条消息）
    few_shot_chat_prompt,
    # human（用户）消息：用户真正要提问的问题，{input} 占位符将在 invoke 时被实际值替换
    ("human", "{input}"),
])

# 调用模板的 invoke 方法进行渲染（变量填充）
# 传入参数字典 {"input": "2 # 9"}，把模板中所有的 {input} 占位符替换为 "2 # 9"
# 返回的 messages 是一个消息对象列表，包含 system 消息、4 条示例消息、1 条用户消息
messages = final_chat_prompt.invoke({"input": "2 # 9"})

# 调用 llm.invoke() 把渲染好的消息列表发送给大模型，进行同步推理
# 返回值 info 是一个 AIMessage 对象，包含模型的回复内容及元数据
info = llm.invoke(messages)

# 打印完整的 AIMessage 对象
# 输出包括：content（回复内容）、response_metadata（响应元数据，如模型名、token 用量）、
# usage_metadata（token 消耗统计）等全部信息，便于调试查看
print(info)

# 打印模型回复的正文内容
# info.content 是 AIMessage 对象的 content 属性，即模型对 "2 # 9" 的最终答案（应为 512）
print('问题答案：', info.content)

# 打印实际调用的大模型名称
# info.response_metadata 是一个字典，存储 API 响应的元数据；
# 其中 'model_name' 键对应的值就是服务端实际处理请求的模型名称
print('调用的大模型：', info.response_metadata['model_name'])

三、【少样本提示语模板2】：

FewShotPromptTemplate（字符串版）

FewShotPromptTemplate（适用于传统 LLM/字符串提示）适用于将提示词作为纯文本字符串处理的场景。FewShotPromptTemplate，仅传入1组示例到examples参数中，就能快速搭建出One-shot提示模板。当然传入多组也可。

【注意】
（1） 示例质量至关重要‌：示例要清晰无误，并覆盖各种情况。错误的示例会导致模型模仿错误。
（2） 保持一致性‌：示例的格式、风格应与期望的输出完全一致。
（3） 数量适中‌：通常 2~5 个示例效果最佳。过多示例不仅增加成本，还可能引入噪声。
（4） 思维链（Chain-of-Thought）‌：对于复杂推理任务，在示例中展示逐步推理过程（即输出 中包含思考步骤），能显著提升模型的逻辑能力。
（5）变量匹配‌：确保示例字典中的 Key 与 example_prompt 模板中的变量名严格匹配。

1. 应用步骤：‌

（1） 定义示例数据‌：创建一个字典列表，每个字典包含输入和输出的键值对。
（2） 定义示例格式化模板 ：使用 PromptTemplate 定义单个示例如何展示。
（3）使用"FewShotPromptTemplate"组装模板‌，传入示例列表、示例模板、前缀和后缀。
（4） 生成最终提示‌：调用 .format() 方法填入用户实际输入。

（5）执行调用：渲染出完整消息列表后调用模型。

2. 核心参数：

|-----------------------|-------------------------|----------------------------------|
| 参数 | 类型 | 说明 |
| examples | Listdict | 静态示例列表，每项是一个变量字典 |
| example_selector | BaseExampleSelector | 动态示例选择器（与 examples 二选一） |
| example_prompt | PromptTemplate | 单个示例的渲染模板 |
| prefix | str | 拼在所有示例之前的文本（通常放任务指令） |
| suffix | str | 拼在所有示例之后的文本（通常放真正的问题，含占位符） |
| input_variables | Liststr | suffix 中需要外部填充的变量名 |
| example_separator | str | 示例之间的分隔符，默认 "\n\n" |
| template_format | str | 占位符语法，默认 "f-string"（即 {var}） |

3. 代码示例**（后附有完整的代码，可直接复制运行）：**

（1） 定义示例数据‌：创建一个字典列表，每个字典包含输入和输出的键值对。

# 定义少样本示例列表 examples
# 每个字典代表一个"输入→输出"的标注样本，用于教会模型情感分类的任务格式
examples = [
    # 第一个示例："高兴" 对应的情感标签是 "正面"
    {"input": "高兴", "output": "正面"},
    # 第二个示例："愤怒" 对应的情感标签是 "负面"
    {"input": "愤怒", "output": "负面"},
]

（2） 定义示例格式化模板 ：使用 PromptTemplate 定义单个示例如何展示。

# 创建单个示例的渲染模板 example_prompt
# 它定义了每个示例在最终提示词中的文本格式
example_prompt = PromptTemplate(
    # template 定义模板字符串，{input} 和 {output} 是占位符
    # 渲染后每个示例会变成类似 "用户输入: 高兴\n情感标签: 正面" 的文本块
    template="用户输入: {input}\n情感标签: {output}",
    # 声明模板中使用到的变量名列表，format() 时会校验这些变量是否都被传入
    input_variables=["input", "output"]
)

（3）使用"FewShotPromptTemplate"组装模板‌，传入示例列表、示例模板、前缀和后缀。

# 创建少样本提示词模板对象 few_shot_prompt
# 它负责将系统指令、所有示例、用户问题三部分拼接成一段完整的纯文本提示词
few_shot_prompt = FewShotPromptTemplate(
    # 传入上面定义的示例数据列表
    examples=examples,
    # 传入单个示例的渲染模板，决定每个示例如何被格式化为文本
    example_prompt=example_prompt,
    # prefix：拼接在所有示例之前的前缀文本
    # 这里充当系统指令，告诉模型它的角色和任务要求
    prefix="你是一个情感分析专家。请根据以下示例判断用户输入的情感。",
    # suffix：拼接在所有示例之后的后缀文本
    # {user_input} 是占位符，会在 format() 时被实际的用户输入替换
    suffix="用户输入: {user_input}",
    # 声明 suffix 中用到的变量名（注意：这里用 user_input 而非 input，避免与示例变量冲突）
    input_variables=["user_input"],
    # 定义示例之间的分隔符为两个换行符
    # 使各示例在视觉上清晰分开，便于模型理解每个示例的边界
    example_separator="\n\n"
)

（4） 生成最终提示‌：调用 .format() 方法填入用户实际输入。

# 调用 few_shot_prompt.format() 方法，传入实际参数进行模板渲染
# user_input="今天天气阳光明媚很适宜郊游。" 会替换 suffix 中的 {user_input} 占位符
# 返回值 final_prompt 是一个完整的纯文本字符串，包含系统指令 + 2个示例 + 用户问题
final_prompt = few_shot_prompt.format(user_input="今天天气阳光明媚很适宜郊游。")

（5）执行调用：渲染出完整消息列表后调用模型。

# 调用 llm.invoke() 将纯文本提示词发送给大模型进行推理
# 当传入字符串而非消息列表时，ChatOpenAI 会自动将其包装为单条 human 消息
# 返回值 info 是 AIMessage 对象，包含模型回复内容及元数据
info = llm.invoke(final_prompt)

【示例2的完整代码，可直接复制运行】

# 从 langchain_openai 库中导入 ChatOpenAI 类
# 该类用于与兼容 OpenAI API 协议的大模型服务进行交互，支持通义千问等国产模型
from langchain_openai import ChatOpenAI

# 从 langchain_core.prompts 模块中导入 PromptTemplate 类
# PromptTemplate 是最基础的字符串提示词模板，通过占位符 + format() 生成纯文本提示词
# 注意：它与 ChatPromptTemplate 不同，后者生成的是消息列表（messages），而它生成的是单个字符串
from langchain_core.prompts import PromptTemplate

# 从 langchain_core.prompts 模块中导入 FewShotPromptTemplate 类
# 该类用于实现"少样本提示"（Few-Shot），将多个示例拼接成一段纯文本提示词
# 与 FewShotChatMessagePromptTemplate 的区别在于：它输出的是字符串而非对话消息列表
from langchain_core.prompts import FewShotPromptTemplate

# 导入 Python 标准库 os 模块
# 用于读取环境变量、操作文件路径等系统级功能
import os

# 从 dotenv 库中导入 load_dotenv 函数
# 该函数用于加载项目目录下的 .env 文件，将其中的键值对注入到环境变量中
from dotenv import load_dotenv

# 执行 load_dotenv()，自动查找并解析当前目录或上级目录中的 .env 文件
# 将 API_KEY、ALI_URL 等敏感配置从代码中分离出来，提高安全性
load_dotenv()

# 从环境变量中读取名为 "API_KEY" 的值，赋给变量 key
# 这是调用大模型 API 所需的身份验证密钥，对应 .env 文件中的 API_KEY=xxx
key = os.getenv("API_KEY")

# 从环境变量中读取名为 "ALI_URL" 的值，赋给变量 url
# 这是阿里云百炼平台的 API 服务地址（如 https://dashscope.aliyuncs.com/compatible-mode/v1）
# 因为使用的是通义千问而非 OpenAI 官方模型，必须指定自定义 base_url
url = os.getenv("ALI_URL")

# 创建 ChatOpenAI 实例（大模型客户端对象），赋给变量 llm
# 后续通过 llm.invoke() 向模型发送请求并获取回复
llm = ChatOpenAI(

    # 指定要使用的模型名称为通义千问 qwen3.8-max
    model="qwen3.8-max",

    # 指定 API 的基础地址为阿里云百炼的服务端点
    # 使请求路由到阿里云服务器而非 OpenAI 官方服务器
    base_url=url,

    # 传入 API 密钥用于身份认证
    api_key=key,

    # 设置温度参数为 1，控制输出的随机性/创造性
    # 值为 1 表示使用模型默认的采样策略，适合需要一定多样性的任务
    temperature=1,

    # 开启流式输出模式
    # 模型回复会逐块返回而非等待全部生成完毕，降低首字延迟，提升用户体验
    streaming=True,

    # extra_body 用于传递 OpenAI 标准参数之外的扩展参数
    # 这些参数会被直接添加到 HTTP 请求体中，供阿里云百炼平台识别和处理
    extra_body={

        # 开启深度思考（thinking）模式
        # 模型在输出最终答案前会先进行内部推理（思维链），提升复杂任务的准确性
        "thinking": {"type": "enabled"},

        # 开启联网搜索（search）模式
        # 允许模型在回答时检索互联网上的最新信息，弥补训练数据的时效性不足
        "search": {"type": "enabled"},
    },
)

# 定义少样本示例列表 examples
# 每个字典代表一个"输入→输出"的标注样本，用于教会模型情感分类的任务格式
examples = [
    # 第一个示例："高兴" 对应的情感标签是 "正面"
    {"input": "高兴", "output": "正面"},
    # 第二个示例："愤怒" 对应的情感标签是 "负面"
    {"input": "愤怒", "output": "负面"},
]

# 创建单个示例的渲染模板 example_prompt
# 它定义了每个示例在最终提示词中的文本格式
example_prompt = PromptTemplate(
    # template 定义模板字符串，{input} 和 {output} 是占位符
    # 渲染后每个示例会变成类似 "用户输入: 高兴\n情感标签: 正面" 的文本块
    template="用户输入: {input}\n情感标签: {output}",
    # 声明模板中使用到的变量名列表，format() 时会校验这些变量是否都被传入
    input_variables=["input", "output"]
)

# 创建少样本提示词模板对象 few_shot_prompt
# 它负责将系统指令、所有示例、用户问题三部分拼接成一段完整的纯文本提示词
few_shot_prompt = FewShotPromptTemplate(
    # 传入上面定义的示例数据列表
    examples=examples,
    # 传入单个示例的渲染模板，决定每个示例如何被格式化为文本
    example_prompt=example_prompt,
    # prefix：拼接在所有示例之前的前缀文本
    # 这里充当系统指令，告诉模型它的角色和任务要求
    prefix="你是一个情感分析专家。请根据以下示例判断用户输入的情感。",
    # suffix：拼接在所有示例之后的后缀文本
    # {user_input} 是占位符，会在 format() 时被实际的用户输入替换
    suffix="用户输入: {user_input}",
    # 声明 suffix 中用到的变量名（注意：这里用 user_input 而非 input，避免与示例变量冲突）
    input_variables=["user_input"],
    # 定义示例之间的分隔符为两个换行符
    # 使各示例在视觉上清晰分开，便于模型理解每个示例的边界
    example_separator="\n\n"
)

# 调用 few_shot_prompt.format() 方法，传入实际参数进行模板渲染
# user_input="今天天气阳光明媚很适宜郊游。" 会替换 suffix 中的 {user_input} 占位符
# 返回值 final_prompt 是一个完整的纯文本字符串，包含系统指令 + 2个示例 + 用户问题
final_prompt = few_shot_prompt.format(user_input="今天天气阳光明媚很适宜郊游。")

# 打印渲染后的完整提示词文本
# 可以直观检查拼接结果是否符合预期，便于调试提示词工程的效果
print("===== 渲染后的完整提示词 =====")
print(final_prompt)
print("="*80)
# 调用 llm.invoke() 将纯文本提示词发送给大模型进行推理
# 当传入字符串而非消息列表时，ChatOpenAI 会自动将其包装为单条 human 消息
# 返回值 info 是 AIMessage 对象，包含模型回复内容及元数据
info = llm.invoke(final_prompt)

# 打印模型回复的正文内容
# info.content 即模型对 "今天天气阳光明媚很适宜郊游。" 的情感判断结果（预期为"正面"）
print("===== 根据示例和用户的问题生成的结果 =====")
print(info.content)
print("="*80)
# 打印实际处理请求的模型名称
# info.response_metadata 是字典，存储 API 响应元数据；
# 'model_name' 键对应的值是服务端实际使用的模型标识
print('调用的大模型：', info.response_metadata['model_name'])


# 查看模板对象的各个组成部分，理解它是如何拼接的
print("前缀(prefix):", few_shot_prompt.prefix)
print("后缀(suffix):", few_shot_prompt.suffix)
print("示例分隔符:", repr(few_shot_prompt.example_separator))
print("示例数量:", len(few_shot_prompt.examples))

# 手动查看每个示例被 example_prompt 渲染后的结果
for i, ex in enumerate(few_shot_prompt.examples):
    rendered = few_shot_prompt.example_prompt.format(**ex)
    print(f"示例{i+1}渲染结果:\n{rendered}\n")