02 Prompt组件及使用技巧

1 为什么需要Prompt（提示）

绝大多数 LLM 应用不会直接将用户原始输入原封不动地传递给模型，而是通过提示模板（Prompt Template）构建一个包含附加上下文的完整输入框架。这种设计的核心逻辑在于：大语言模型的本质是基于预训练数据的统计模式匹配。若用户指令模糊或缺乏必要背景信息，模型极易因理解偏差生成偏离预期的输出。

1.1 Prompt 的关键作用

精准锚定任务目标
通过明确指令（如“翻译”“总结”“代码生成”），直接限定模型的输出方向，避免其因语义歧义产生无关内容。
示例对比：
模糊指令：“写点关于春天的内容。”
→ 模型可能输出诗歌、天气分析或自然现象描述，难以满足用户真实需求。明确指令：“请以300字篇幅描述春天的自然景观，需包含鲜花、绿草和微风的细节描写。”
→ 模型能聚焦用户意图，生成结构清晰、内容契合的结果。

注入上下文信息，提升推理准确性
提示模板通过补充任务背景、约束条件或格式要求，为模型提供必要的推理线索。
场景适配：
学术场景：“请以学术论文格式总结量子计算的发展历程。”商业场景：“将用户评论分类为‘正面’‘中性’‘负面’，并输出JSON格式结果。”
约束条件：
“用不超过50字解释相对论的基本原理。” → 强制模型提炼核心概念，避免冗长描述。
降低交互门槛，优化用户体验
通过预设的 Prompt 模板，用户无需理解模型内部机制，只需输入直观指令即可获得结构化输出。
复杂任务简化：
“帮我设计一个待办事项APP。” → 模型根据预设模板自动补全功能模块、技术栈选择等细节。多模态支持：
“分析这张图片中的物体，并总结其应用场景。” → 提示模板可整合视觉与文本信息，实现跨模态推理。

1.2 技术视角：Prompt 工程的价值

Prompt 设计不仅是简单的指令输入，更是模型能力调优的核心手段。通过角色扮演（如“你是一位资深律师”）、思考链引导（分步骤推理）或参数化模板（动态替换变量），开发者可显著提升模型在复杂任务中的表现。例如：

角色扮演增强专业性：
“作为营养师，请为健身人群设计高蛋白食谱。”分步推理提升准确性：
“首先列出用户需求，其次分析解决方案，最后总结最佳选择。”

2 LangChain中的Prompt组件

Prompt 是所有 AI 应用交互的起点，为了适配不同的 LLM ，LangChain 封装了 Prompt 组件，并且 Prompt 组件是高可移植性的，同一个 Prompt 可以支持各种 LLM ，在切换 LLM 的时候，无需修改 Prompt。

LangChain 提供了灵活的 PromptTemplate 工具，允许开发者定义可重用的文本模板，并通过变量动态插入内容。

对于 PromptTemplate ，在 LangChain 中，又涵盖了多个子组件，例如：角色提示模板、消息占位符、文本提示模板、聊天消息提示模板、提示、消息等

不同 Prompt 组件功能的简介：

PromptTemplate ：用于创建文本消息提示模板，用于用于与大语言模型/文本生成模型进行交互。ChatPromptTemplate ：用于创建聊天消息提示模板，一般用于与聊天模型进行交互。MessagePlaceholder：消息占位符，在聊天模型中对不确定是否需要的消息进行占位。 SystemMessagePromptTemplate ：用于创建系统消息提示模板，角色为系统。HumanMessagePromptTemplate ：用于创建人类消息提示模板，角色为人类。 AIMessagePromptTemplate ：用于创建AI消息提示模板，角色为AI。PipelinePromptTemplate ：用于创建管道消息，管道消息可以将提示模板作为变量进行快速复用。

[!tip]

LLMs和Chat Models的区别：

LLMs的输入和输出都是文本，而Chat Models输入输出都是消息列表基本现在的大语言模型都是用的Chat Models，LLMs应用场景没有Chat Models多。

Prompt 不同方法的功能简介：

partial ：用于格式化提示模板中的部分变量。

format：传递变量数据，格式化提示模板为文本消息。

invoke ：传递变量谁，格式化提示模板为提示。

to_string：将提示/消息提示列表转换成字符串。

to_messages ：用于将消息提示列表转换成字符串。

Prompt 中重载的运算符：

+运算符：在 Prompt 组件中，对 + 运算符使用 add 方法进行重写，所以几乎所有 Prompt 组件都可以使用 + 进行组装拼接。

3 基础 Prompt 模板

PromptTemplate 是 LangChain 中用于构建和管理提示词（Prompt）的核心组件之一，它允许开发者定义可复用的文本模板，并通过动态变量插入生成最终的 Prompt。它是构建 LLM（大语言模型）应用时非常关键的一环。

3.1 PromptTemplate 的基本概念

3.1.1 定义

PromptTemplate 是一个 字符串模板，其中包含固定文本 + 动态变量。模型输入前，这些变量会被实际值替换，形成最终的 Prompt 输入给 LLM。

3.1.2 核心作用

将用户意图结构化为模型能理解的形式。支持多场景复用（如翻译、摘要、问答等）。提高开发效率与代码可维护性。

3.2 PromptTemplate 的基本用法

示例：定义一个简单的 Prompt 模板


from langchain.prompts import PromptTemplate

# 定义模板
template = PromptTemplate(
    input_variables=["name", "task"],
    template="Hello {name}, could you please help me with {task}?"
)

# 使用模板生成具体 Prompt
prompt = template.format(name="Alice", task="data analysis")
print(prompt)
# 输出: Hello Alice, could you please help me with data analysis?

3.3 PromptTemplate 的核心参数

参数名	类型	说明
`input_variables`	List[str]	模板中使用的变量名列表
`template`	str	包含变量的原始字符串模板
`template_format`	str	模板格式，默认是 f-string，也可使用 jinja2 等高级模板引擎

3.4 支持的模板格式

LangChain 支持多种模板格式，最常用的是：

1. 默认格式：f-string（推荐）

使用 {variable} 语法。简洁直观，适合大多数场景。


template = PromptTemplate.from_template("请总结以下文章：{article}")

2. Jinja2 模板（高级功能）

支持条件判断、循环等逻辑。需指定 template_format="jinja2"。


from langchain.prompts import PromptTemplate

template_str = """
{% if user_type == 'vip' %}
尊敬的VIP用户，以下是您的专属服务：
{{ content }}
{% else %}
普通用户服务如下：
{{ content }}
{% endif %}
"""

template = PromptTemplate(
    input_variables=["user_type", "content"],
    template=template_str,
    template_format="jinja2"
)

prompt = template.format(user_type="vip", content="每日新闻摘要")
print(prompt)

3.5 PromptTemplate 的常见方法

方法	说明
`.format(**kwargs)`	替换变量，生成完整 Prompt 字符串，适用于简单场景
`.format_prompt(**kwargs)`	返回 `PromptValue` 对象，可用于直接调用 LLM
`.from_template(template_string)`	快捷创建模板对象
`.partial()`	固定部分变量，生成新的 PartialPromptTemplate

1. `.format(**kwargs)`

作用：替换模板中的变量，生成完整的 Prompt 字符串，传输给LLM，适用于简单场景。
示例：


from langchain.prompts import PromptTemplate

# 定义模板
template = PromptTemplate.from_template("将以下文本翻译成{language}：{text}")

# 替换变量生成完整 Prompt
formatted_prompt = template.format(language="法语", text="你好")
print(formatted_prompt)

# 调用 LLM（假设已有模型实例）
# llm(formatted_prompt)  # 传递给 LLM 的输入

输出：


将以下文本翻译成法语：你好

2. `.format_prompt(**kwargs)`

作用：返回 PromptValue 对象（包含 Prompt 内容），可直接用于调用 LLM。
示例：


from langchain.prompts import PromptTemplate

# 定义模板
template = PromptTemplate.from_template("回答以下问题：{question}")

# 生成 PromptValue 对象
prompt_value = template.format_prompt(question="巴黎是哪个国家的首都？")

# 调用 LLM（假设已有模型实例）
# llm(prompt_value)  # 传递给 LLM 的输入

说明：

PromptValue 是 LangChain 中统一的 Prompt 输入格式，支持更复杂的 Prompt 结构（如多轮对话）。

3. `.from_template(template_string)`

作用：通过字符串快速创建 PromptTemplate 对象。
示例：


from langchain.prompts import PromptTemplate

# 直接通过字符串创建模板
template = PromptTemplate.from_template("请用{language}写一首关于{topic}的诗")

# 替换变量生成 Prompt
formatted_prompt = template.format(language="中文", topic="春天")
print(formatted_prompt)

输出：


请用中文写一首关于春天的诗

4. `.partial()`

作用：固定模板中部分变量，生成新的 PartialPromptTemplate。
示例：


from langchain.prompts import PromptTemplate

# 定义模板
template = PromptTemplate.from_template("将以下文本翻译成{language}：{text}")

# 固定 language 变量为 "英语"
english_translator = template.partial(language="英语")

# 调用时只需提供 text
formatted_prompt = english_translator.format(text="你好，世界！")
print(formatted_prompt)

输出：


将以下文本翻译成英语：你好，世界！

补充说明：

.format() vs .format_prompt()：

两者返回都可以直接传入LLM进行调用。.format() 直接返回字符串，适合简单场景。.format_prompt() 返回 PromptValue，适合需要传递复杂结构（如多轮对话）的场景。

.partial() 的灵活性：
通过 .partial() 预设部分变量，可以简化重复调用时的参数传递，例如固定翻译目标语言或任务类型。

综合示例：结合多轮对话


from langchain.prompts import PromptTemplate

# 定义多轮对话模板
template = PromptTemplate.from_template(
    "历史对话：{history}
用户问题：{question}
回答："
)

# 模拟历史对话
history = [
    {"role": "user", "content": "什么是量子计算？"},
    {"role": "assistant", "content": "量子计算是基于量子力学原理的计算模型..."}
]

# 格式化历史对话为字符串
history_str = "
".join([f"{msg['role']}: {msg['content']}" for msg in history])

# 生成完整 Prompt
formatted_prompt = template.format(history=history_str, question="量子计算的优势是什么？")
print(formatted_prompt)

输出：


历史对话：
user: 什么是量子计算？
assistant: 量子计算是基于量子力学原理的计算模型...
用户问题：量子计算的优势是什么？
回答：

3.6 结合 LLM 使用 PromptTemplate


from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# 定义模板
prompt = PromptTemplate.from_template("请将以下内容翻译成{language}：{text}")

# 初始化 LLM
llm = OpenAI(model_name="text-davinci-003")

# 构建完整的提示并调用模型
formatted_prompt = prompt.format(language="西班牙语", text="你好吗？")
response = llm(formatted_prompt)

print(response)  # 输出翻译结果

3.7 进阶用法：与 FewShotPromptTemplate 结合使用

在少样本学习（Few-Shot Learning）中，可以通过 FewShotPromptTemplate 来增强模型理解能力。


from langchain.prompts import FewShotPromptTemplate, PromptTemplate

examples = [
    {"word": "happy", "antonym": "sad"},
    {"word": "tall", "antonym": "short"}
]

example_prompt = PromptTemplate.from_template("单词：{word}
反义词：{antonym}")

few_shot_prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    prefix="请找出下列单词的反义词：",
    suffix="单词：{word}
反义词：",
    input_variables=["word"]
)

prompt = few_shot_prompt.format(word="big")
print(prompt)

输出：


请找出下列单词的反义词：
单词：happy
反义词：sad
单词：tall
反义词：short
单词：big
反义词：

4 聊天 Prompt 模板（Chat 消息）

ChatPromptTemplate 是 LangChain 中用于处理聊天模型（如 GPT 系列）提示词的核心工具。它允许开发者通过定义不同角色（如 System、Human、AI）的提示模板，构建结构化的对话输入，从而引导模型生成符合预期的回复。

4.1 大语言模型中角色的概念

大语言模型（LLM）中的角色分类主要用于定义对话中的不同参与方及其职责，帮助模型更清晰地理解交互逻辑，并生成符合预期的回答。通常包含以下三种核心角色。

4.1.1 系统角色（System Role）

定义：系统角色用于设定模型的行为准则、个性特征、知识范围以及交互规则。它是模型的“基础设定”，通常在对话开始前配置。作用：
指导模型以特定的风格或规则回答问题（例如，语气、知识边界、输出格式等）。定义模型的行为规范（例如，避免敏感话题、遵循法律规则等）。在多轮对话中保持一致性（例如，确保模型始终扮演某个角色或遵循某个任务目标）。
示例：
“你是一个专业的Python编程助手，需要用通俗易懂的方式回答问题。”“你必须用中文回答，并且每句话不超过20个字。”

4.1.2 用户角色（User Role）

定义：用户角色代表与模型交互的用户，即提出问题、指令或请求的人。作用：
提供模型需要处理的输入内容（例如，提问、任务指令、上下文信息等）。引导对话方向（例如，通过问题或指令明确需求）。
示例：
“请解释Python中的装饰器是什么？”“帮我写一封感谢信给客户。”

4.1.3 助手角色（Assistant Role）

定义：助手角色代表模型本身，负责根据系统角色的设定和用户角色的输入，生成合适的回复。作用：
根据系统角色的规则和用户的需求，生成自然、准确的回答。在多轮对话中维护上下文一致性（例如，记住之前的对话历史）。
示例：
“装饰器是Python中一种用于修改或增强函数行为的工具……”“以下是一封感谢信的范文：‘尊敬的客户，感谢您对我们公司的支持……’”

4.1.4 角色分类的层级与关系

在实际应用中，角色分类通常按以下层级组织：

系统角色：定义全局规则和模型行为。用户角色：提供具体任务或问题。助手角色：根据规则和任务生成回答。

4.1.5 角色分类的实际应用

多轮对话：通过角色划分，模型可以记住上下文并保持对话连贯性。例如：
用户：“帮我预订明天从北京到上海的机票。”助手：“好的，您需要经济舱还是商务舱？”用户：“经济舱。”助手：“已为您查询到以下航班……”
角色扮演：通过系统角色设定，模型可以扮演特定身份（例如，医生、律师、客服等），提供专业化服务。

4.1.6 角色分类的优势

结构化交互：明确区分对话中的参与者，减少歧义。灵活性：通过调整系统角色，模型可以适应不同场景（例如，学术咨询、客服支持、创意写作等）。可控性：用户可以通过系统角色的设定控制模型的行为边界（例如，限制敏感话题或格式要求）。

4.2 ChatPromptTemplate基本使用

1. 核心概念

ChatPromptTemplate：用于生成聊天模型输入的提示模板，支持多角色对话（System、Human、AI）。SystemMessagePromptTemplate：定义系统角色的提示（如设定模型行为准则）。HumanMessagePromptTemplate：定义用户角色的提示（即用户的输入）。AIMessagePromptTemplate：定义助手角色的提示（可选，用于模拟历史对话）。

2. 创建 ChatPromptTemplate

通过组合不同角色的模板，构建完整的对话输入。

步骤：

导入必要的模块：


from langchain.prompts import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
    AIMessagePromptTemplate
)

定义模板：

System 模板（可选）：


system_template = "你是一个专业的客服助手，用中文回答用户的问题。"
system_prompt = SystemMessagePromptTemplate.from_template(system_template)

Human 模板（必填）：


human_template = "用户的问题是：{user_input}"
human_prompt = HumanMessagePromptTemplate.from_template(human_template)

AI 模板（可选，用于模拟历史对话）：


ai_template = "助手的回复是：{ai_response}"
ai_prompt = AIMessagePromptTemplate.from_template(ai_template)

组合模板：


chat_prompt = ChatPromptTemplate.from_messages([
    system_prompt,
    human_prompt,
    ai_prompt  # 如果需要模拟历史对话
])

3. 动态填充变量并生成消息

通过 format_messages() 方法动态传入参数，生成模型可识别的消息列表。

示例代码：


# 动态传入参数
messages = chat_prompt.format_messages(
    user_input="如何设置路由器的WiFi密码？",
    ai_response="请登录路由器后台，找到WiFi设置页面..."  # 如果需要模拟历史对话
)

# 输出结果
print(messages)

输出：


[
    SystemMessage(content="你是一个专业的客服助手，用中文回答用户的问题。"),
    HumanMessage(content="用户的问题是：如何设置路由器的WiFi密码？"),
    AIMessage(content="助手的回复是：请登录路由器后台，找到WiFi设置页面...")
]

4. 实际应用场景

场景：客服助手


# 定义模板
system_template = "你是一个专业的客服助手，用中文回答用户的问题。"
human_template = "用户的问题是：{user_input}"
ai_template = "助手的回复是：{ai_response}"

# 创建模板对象
system_prompt = SystemMessagePromptTemplate.from_template(system_template)
human_prompt = HumanMessagePromptTemplate.from_template(human_template)
ai_prompt = AIMessagePromptTemplate.from_template(ai_template)

# 组合模板
chat_prompt = ChatPromptTemplate.from_messages([
    system_prompt,
    human_prompt,
    ai_prompt  # 模拟历史对话
])

# 动态生成消息
messages = chat_prompt.format_messages(
    user_input="我的电脑无法连接WiFi，怎么办？",
    ai_response="请尝试重启路由器和电脑..."  # 历史回复
)

# 调用聊天模型（如 OpenAI 的 ChatCompletion）
# response = chat_model.invoke(messages)

4.3 ChatPromptTemplate的常见方法

以下是 ChatPromptTemplate 的常用方法及其使用示例，结构与 PromptTemplate 类似，但针对聊天模型的多角色对话设计：

4.4 ChatPromptTemplate 的常见方法

方法	说明
`.from_messages(messages)`	通过消息列表（System/Human/AI）创建模板，支持多角色对话
`.format_messages(**kwargs)`	替换变量，生成消息列表（`BaseMessage` 对象），适用于多轮对话场景
`.partial()`	固定部分变量，生成新的 `PartialPromptTemplate`
`.from_template(template_string)`	快捷创建模板对象（仅 Human 消息），适用于单轮对话
`MessagesPlaceholder`	动态插入历史消息或外部消息序列，支持复杂对话流程

4.4.1 `.from_messages(messages)`

作用：通过消息列表（System/Human/AI）创建模板，支持多角色对话。

示例：


from langchain.prompts import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)

# 定义模板
system_prompt = SystemMessagePromptTemplate.from_template("你是一个专业的客服助手，用中文回答用户的问题。")
human_prompt = HumanMessagePromptTemplate.from_template("用户的问题是：{user_input}")

# 创建 ChatPromptTemplate
chat_prompt = ChatPromptTemplate.from_messages([
    system_prompt,
    human_prompt
])

# 生成消息列表
messages = chat_prompt.format_messages(user_input="如何重置路由器密码？")
print(messages)

输出：


[
    SystemMessage(content="你是一个专业的客服助手，用中文回答用户的问题。"),
    HumanMessage(content="用户的问题是：如何重置路由器密码？")
]

4.4.2 `.format_messages(kwargs)`**

作用：替换模板中的变量，生成消息列表（BaseMessage 对象），适用于多轮对话场景。

示例：


from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.schema.messages import HumanMessage, AIMessage

# 定义模板（包含历史对话）
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个客服助手，用中文回答用户的问题。"),
    MessagesPlaceholder("history"),  # 动态插入历史消息
    ("human", "{user_input}")
])

# 模拟历史对话（用户先提问，助手后回复）
history = [
    {"role": "user", "content": "没有解决。"},
    {"role": "assistant", "content": "请尝试重启路由器..."},
]

# 格式化历史消息为消息列表
history_messages = [
    HumanMessage(content=msg["content"]) if msg["role"] == "user" else AIMessage(content=msg["content"])
    for msg in history
]

# 生成完整消息列表
messages = chat_prompt.format_messages(
    history=history_messages,
    user_input="还有其他方法吗？"
)

print(messages)

输出：


[
    SystemMessage(content="你是一个客服助手，用中文回答用户的问题。"),
    HumanMessage(content="没有解决。"),
    AIMessage(content="请尝试重启路由器..."),
    HumanMessage(content="还有其他方法吗？")
]

4.4.3 `.partial()`

作用：固定模板中部分变量，生成新的 PartialPromptTemplate。

示例：


from langchain.prompts import ChatPromptTemplate

# 定义模板
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个客服助手，用中文回答用户的问题。"),
    ("human", "用户的问题是：{user_input}")
])

# 固定 user_input 为默认值
fixed_prompt = chat_prompt.partial(user_input="如何设置WiFi密码？")

# 生成消息列表（无需提供 user_input）
messages = fixed_prompt.format_messages()
print(messages)

输出：


[
    SystemMessage(content="你是一个客服助手，用中文回答用户的问题。"),
    HumanMessage(content="用户的问题是：如何设置WiFi密码？")
]

4.4.4 `.from_template(template_string)`

作用：通过字符串快速创建模板对象（仅 Human 消息），适用于单轮对话。

示例：


from langchain.prompts import ChatPromptTemplate

# 直接通过字符串创建模板
chat_prompt = ChatPromptTemplate.from_template("用户的问题是：{user_input}")

# 生成消息列表
messages = chat_prompt.format_messages(user_input="路由器无法连接WiFi怎么办？")
print(messages)

输出：


[HumanMessage(content="用户的问题是：路由器无法连接WiFi怎么办？")]

4.4.5 `MessagesPlaceholder` 动态插入消息

作用：在模板中预留位置，动态插入历史消息或外部消息序列。

示例：


from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage

# 定义模板（包含历史消息占位符）
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个客服助手，用中文回答用户的问题。"),
    MessagesPlaceholder("history"),  # 插入历史消息
    ("human", "{user_input}")
])

# 模拟历史消息
history = [
    {"role": "user", "content": "如何设置WiFi密码？"},
    {"role": "assistant", "content": "请登录路由器后台..."}
]

# 转换历史消息为消息对象
history_messages = [HumanMessage(content=msg["content"]) if msg["role"] == "user" else AIMessage(content=msg["content"])
                    for msg in history]

# 生成完整消息列表
messages = chat_prompt.format_messages(
    history=history_messages,
    user_input="设置完成后无法连接。"
)
print(messages)

输出：


[
    SystemMessage(content="你是一个客服助手，用中文回答用户的问题。"),
    HumanMessage(content="如何设置WiFi密码？"),
    AIMessage(content="请登录路由器后台..."),
    HumanMessage(content="设置完成后无法连接。")
]

补充说明

.from_messages() vs .from_template()：
.from_messages() 支持多角色消息（System/Human/AI），适合复杂对话。.from_template() 仅支持 Human 消息，适合单轮对话。
消息对象类型：
SystemMessage: 系统指令（如设定角色或规则）。HumanMessage: 用户输入。AIMessage: 助手回复（用于模拟历史对话）。
MessagesPlaceholder 的灵活性：
通过 MessagesPlaceholder("history") 动态插入历史消息，支持多轮对话。可与 Memory 模块结合，自动管理对话历史。
与模型调用的结合：

使用 chat_model.invoke(messages) 直接传入消息列表（BaseMessage 对象）。

示例：


from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4o")
response = model.invoke(messages)
print(response.content)

4.5 使用示例

1. 基础示例：单轮对话模板


from langchain.prompts import ChatPromptTemplate

# 创建一个简单的对话模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个乐于助人的助手。"),
    ("human", "告诉我关于{topic}的知识。")
])

# 使用模板生成提示
formatted_prompt = prompt.format_messages(topic="量子计算")
print(formatted_prompt)

# 输出：
# [SystemMessage(content='你是一个乐于助人的助手。'), 
#  HumanMessage(content='告诉我关于量子计算的知识。')]

2. 多轮对话模板（带历史记录）


from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

# 创建带历史记录的对话模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个客服助手，用中文回答问题。"),
    MessagesPlaceholder(variable_name="history"),  # 插入历史对话
    ("human", "{input}")
])

# 模拟历史对话
history = [
    HumanMessage(content="我的订单号是123456"),
    AIMessage(content="请稍等，我帮您查询订单状态。")
]

# 生成最终提示
final_prompt = prompt.format_messages(history=history, input="订单什么时候能到货？")
print(final_prompt)

3. 与模型链整合示例


from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage

# 初始化模型
model = ChatOpenAI(model_name="gpt-3.5-turbo")

# 创建模板
prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="你是一个编程助手，用Python语言回答问题。"),
    HumanMessage(content="如何用{library}实现{functionality}?")
])

# 创建链并执行
chain = prompt | model
response = chain.invoke({"library": "pandas", "functionality": "数据透视表"})
print(response.content)