4. 使用模板设计可复用的提示词

from langchain_core.prompts import PromptTemplate
 
# 使用占位符定义模板
template = PromptTemplate.from_template(
    "Translate {content} from {source_lang} to {target_lang}"
)
 
# 使用字典填充占位符
result = template.invoke({
    "content": "Hello world",
    "source_lang": "English", 
    "target_lang": "Korean"
})
 
print(result.text)

Translate Hello world from English to Korean

# PromptTemplate - 单字符串输出
from langchain_core.prompts import PromptTemplate
 
template1 = PromptTemplate.from_template("Summarize: {content}")
result1 = template1.invoke({"content": "LangChain is a framework..."})  
print(result1)

text='Summarize: LangChain is a framework...'

# ChatPromptTemplate - 基于角色的消息
from langchain_core.prompts import ChatPromptTemplate
 
template2 = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    ("user", "{question}")
])
result2 = template2.invoke({"question": "What is LangChain?"})
print(result2)

messages=[SystemMessage(content='You are a helpful assistant'), HumanMessage(content='What is LangChain?')]

# 硬编码方法(第 3 章风格)
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-4o-mini")
 
user_input = "Explain quantum computing"
# 提示词逻辑与代码混合
prompt = f"You are a helpful assistant. Answer this question: {user_input}"
 
response = llm.invoke(prompt)
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# 模板单独定义
template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{user_input}")
])
 
# 应用逻辑 - 分步执行
llm = ChatOpenAI(model="gpt-4o-mini")
 
user_input = "Explain quantum computing"
 
# 步骤 1: 将模板渲染为消息
messages = template.invoke({"user_input": user_input})
 
# 步骤 2: 将消息发送到 LLM
response = llm.invoke(messages)
print(response.content)

messages = template.invoke(inputs)  # 步骤 1: 渲染模板
response = llm.invoke(messages)     # 步骤 2: 发送到 LLM

template = PromptTemplate.from_template("Summarize: {text}")
 
# 这将失败 - 缺少 'text' 键
try:
    template.invoke({"content": "Some text"})  # 错误的键名
except KeyError as e:
    print(f"Template error: {e}")

Template error: "Input to PromptTemplate is missing variables {'text'}.  Expected: ['text'] Received: ['content']

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
template = ChatPromptTemplate.from_messages([
    ("user", "What is Python?")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({})
response = llm.invoke(messages)
print(response.content)

Python is a high-level, interpreted programming language known for its readability and simplicity. 
It was created by Guido van Rossum and first released in 1991. 
Python emphasizes code readability, allowing programmers to express concepts in fewer lines of code compared to languages such as C++ or Java.
 
Key features of Python include:
...

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# 使用系统消息控制角色和输出风格
template = ChatPromptTemplate.from_messages([
    ("system", """你是一位拥有 15 年教学经验的高级 Python 讲师。
你的学生是从未编程过的完全初学者。
 
教学风格:
- 使用简单的日常类比
- 避免技术术语
- 展示日常生活中的实际例子
- 鼓励和耐心"""),
    ("user", "What is Python?")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({})
response = llm.invoke(messages)
print(response.content)

Great question! Think of Python like a really helpful tool in your toolbox. 
Just like a hammer or a screwdriver helps you build or fix things around the house, Python helps you create software or automate tasks on a computer.
 
Imagine you wanted to bake a cake. 
You need a recipe to follow, right? In this analogy, Python is like that recipe. 
It tells the computer what steps to take to achieve a goal, whether it's doing math, organizing files, or even running a game.
...

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "{question}")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({"question": "How do I read a CSV?"})
response = llm.invoke(messages)

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "How does it work?")  # "it" = ???
])

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "What's the pandas library?"),
    ("assistant", "Pandas is a data analysis library."),
    ("user", "How does it work?")  # 现在 "it" = pandas
])

llm = ChatOpenAI(model="gpt-4o-mini")
 
def chat_with_history(user_input: str, history: list):
    messages = [("system", "You are a Python expert.")]
    
    # 添加历史
    for msg in history:
        messages.append((msg["role"], msg["content"]))
    
    # 添加当前输入
    messages.append(("user", user_input))
    
    # 使用 mustache 格式避免内容包含 {花括号} 时出错
    template = ChatPromptTemplate.from_messages(messages, template_format="mustache")
    
    formatted = template.format()
    response = llm.invoke(formatted)
    return response.content
 
# 使用
history = []
 
# 第 1 轮
resp1 = chat_with_history("What's a Python dictionary?", history)
print(resp1)
 
history.append({"role": "user", "content": "What's a Python dictionary?"})
history.append({"role": "assistant", "content": resp1})
 
# 第 2 轮 - 使用上下文
resp2 = chat_with_history("Show an example.", history)
print(resp2)

# System + 单个 User
[("system", "..."), ("user", "...")]
 
# System + 对话
[("system", "..."), ("user", "..."), ("assistant", "..."), ("user", "...")]

# Assistant 在 User 之前 - AI 对上下文感到困惑
[("system", "..."), ("assistant", "..."), ("user", "...")]
# AI 看到一个没有问题的响应。它可能会虚构这是在回答什么问题,
# 导致不相关或混乱的响应。

# 两条连续的 User 消息 - 缺少 AI 响应
[("system", "..."), ("user", "..."), ("user", "...")]
# AI 不知道要响应哪条 User 消息,或者可能会笨拙地合并它们。
# 失去对话流程。

# 以 Assistant 结束 - 没有什么可以响应的
[("system", "..."), ("user", "..."), ("assistant", "...")]
# 对话已完成。AI 没有什么可以生成的,因为没有待处理的 User 问题。
# 可能会产生错误或空响应。

messages = [
    ("system", "You are a Python expert."),
    ("user", "What's a dictionary?"),
    ("assistant", "A dictionary is a key-value data structure."),
    ("user", "Show an example.")
]

messages = [
    ("system", "You are a Python expert."),
    ("user", """上下文: 用户之前询问了 Python 字典,并了解到它们是键值结构。
 
任务: 提供一个演示字典用法的代码示例。""")
]

# prompts/system_prompt.yaml
_type: prompt
input_variables: []
template: |
  You are a helpful assistant.
  Please answer in a friendly and encouraging tone.

# prompts/user_prompt.yaml
_type: prompt
input_variables:
  - user_input
template: |
  User question: {user_input}
  Please provide a clear answer.

from langchain_core.prompts import load_prompt, ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# 从 YAML 文件加载提示词
system_prompt_template = load_prompt("prompts/system_prompt.yaml")
user_prompt_template = load_prompt("prompts/user_prompt.yaml")
 
# 将加载的提示词组合成聊天模板
chat_template = ChatPromptTemplate.from_messages([
    ("system", system_prompt_template.template),
    ("user", user_prompt_template.template)
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
 
# 步骤 1: 使用运行时值渲染模板
messages = chat_template.invoke({"user_input": "What is LangChain?"})
 
# 步骤 2: 发送到 LLM
response = llm.invoke(messages)
print(response.content)

from langchain_core.prompts import load_prompt
 
# 加载模板
user_prompt_template = load_prompt("prompts/user_prompt.yaml")
 
# 检查它期望什么变量
print("Input variables:", user_prompt_template.input_variables)
 
# 查看模板文本
print("Template:", user_prompt_template.template)

Input variables: ['user_input']
Template: User question: {user_input}
Please provide a clear answer.

_type: prompt
input_variables:
- user_input      # 错误: 列表项应该缩进
  - question      # 错误: 混合缩进级别

_type: prompt
input_variables:
  - user_input    # 正确: 两个项目在同一缩进级别
  - question

input_variables:
  - user_input
template: "Question: {question}"  # 'question' 不在 input_variables 中!

input_variables:
  - user_input
template: "Question: {user_input}"

from langchain_core.prompts import ChatPromptTemplate
 
template = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}."),
    ("user", "{user_input}")
])
 
# 预览模板结构
print("Input variables:", template.input_variables)
print("Message count:", len(template.messages))
 
# 使用示例数据预览
prompt_value = template.invoke({
    "role": "Python programming expert",
    "user_input": "What is Python?"
})
 
print("\nPreview:")
for msg in prompt_value.to_messages():
    print(f"{msg.type}: {msg.content}")

Input variables: ['role', 'user_input']
Message count: 2
 
Preview:
system: You are a Python programming expert.
human: What is Python?

from langchain_core.prompts import ChatPromptTemplate
 
def preview_template(template: ChatPromptTemplate, inputs: dict):
    """使用给定的输入预览模板,捕获错误。"""
    try:
        prompt_value = template.invoke(inputs)
        
        print("TEMPLATE PREVIEW")
        print("=" * 60)
        
        for i, msg in enumerate(prompt_value.to_messages(), 1):
            print(f"Message {i} ({msg.type.upper()}):")
            print(msg.content)
            print("-" * 60)
                
    except KeyError as e:
        print(f"ERROR: {e}")
        print(f"Required variables: {template.input_variables}")
 
# 使用
template = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}."),
    ("user", "{user_input}")
])
 
# 有效输入
preview_template(template, {
    "role": "Python programming expert",
    "user_input": "What is Python?"
})
 
# 缺失变量
preview_template(template, {
    "user_input": "What is Python?"  # 缺少 'role'
})

TEMPLATE PREVIEW
============================================================
Message 1 (SYSTEM):
You are a Python programming expert.
------------------------------------------------------------
Message 2 (HUMAN):
What is Python?
------------------------------------------------------------
 
ERROR: "Input to ChatPromptTemplate is missing variables {'role'}.
Expected: ['role', 'user_input'] Received: ['user_input']
...
Required variables: ['role', 'user_input']