提示词模板与消息

# 门一：按「多条消息」建模板（本章主角，接受元组/对象/占位符的混合列表）
ChatPromptTemplate.from_messages(
    messages: Sequence[MessageLikeRepresentation],
    template_format: str = "f-string",   # 也支持 "mustache" 等
) -> ChatPromptTemplate

# 门二：按「单条消息」建模板（人类那一方，省事写法）
ChatPromptTemplate.from_template(template: str) -> ChatPromptTemplate

# 渲染：填空 → 得到一个 ChatPromptValue
tpl.invoke(values: Mapping[str, Any]) -> ChatPromptValue

from langchain_core.prompts import ChatPromptTemplate

tpl = ChatPromptTemplate.from_messages([
    ("human", "我是{member}，请用{mood}的口吻给我推荐一本书"),
])

# 变量是自动识别的，不用像声明函数参数那样先登记
print(tpl.input_variables)   # ['member', 'mood']

pv = tpl.invoke({"member": "老周", "mood": "温暖"})
print(type(pv).__name__)     # ChatPromptValue
print(pv.messages)
# [HumanMessage(content='我是老周，请用温暖的口吻给我推荐一本书')]
print(pv.to_string())
# Human: 我是老周，请用温暖的口吻给我推荐一本书

tpl = ChatPromptTemplate.from_template("给我推荐一本{genre}书")
print(tpl.invoke({"genre": "科幻"}).to_string())
# Human: 给我推荐一本科幻书

tpl = ChatPromptTemplate.from_messages([
    ("human", "{{answer}} 字段示例：请按 {{\"score\": 5}} 的格式回答{question}"),
])
print(tpl.invoke({"question": "这条书评该打几分"}).to_string())
# Human: {answer} 字段示例：请按 {"score": 5} 的格式回答这条书评该打几分

tpl.partial(**kwargs: str | Callable[[], str]) -> ChatPromptTemplate
# 返回一个新模板（原模板不动）；
# 值可以是字符串，也可以是「零参数的可调用对象」——渲染时才现取

from langchain_core.prompts import ChatPromptTemplate

tpl = ChatPromptTemplate.from_messages([
    ("system", "你是{shop}的资深店员，用{lang}回答"),
    ("human", "{question}"),
])

half = tpl.partial(shop="拾光书屋", lang="中文")
print(half.input_variables)   # ['question'] —— 腌进去的两个不再算欠的
print(half.invoke({"question": "有什么新书"}).to_string())
# System: 你是拾光书屋的资深店员，用中文回答
# Human: 有什么新书

from datetime import date

tpl = ChatPromptTemplate.from_messages([
    ("system", "今天是{date}，你是拾光书屋的当值店员"),
    ("human", "{question}"),
])

half = tpl.partial(date=lambda: date.today().isoformat())
print(half.invoke({"question": "今天有读书会吗"}).to_string())
# System: 今天是2026-08-28，你是拾光书屋的当值店员
# Human: 今天有读书会吗

ChatPromptTemplate.from_messages([
    ("system", "模板字符串，可含 {变量}"),   # 或 "user"，同一意思
    ("ai", "模板字符串"),                    # 或 "assistant"
    ("human", "模板字符串"),
])

from langchain_core.prompts import ChatPromptTemplate

tpl = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的资深店员，用{tone}的口吻说话，荐书不超过三本"),
    ("human", "{question}"),
])

pv = tpl.invoke({"tone": "温和", "question": "想找一本睡前能读的散文"})
for m in pv.messages:
    print(f"{m.type:8} | {m.content}")
# system  | 你是拾光书屋的资深店员，用温和的口吻说话，荐书不超过三本
# human   | 想找一本睡前能读的散文

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

tpl = ChatPromptTemplate.from_messages([
    SystemMessage(content="你是拾光书屋的资深店员"),
    AIMessage(content="欢迎光临！今天想看点什么？"),
    HumanMessage(content="有没有看一晚上能哭出来的书"),
])
print(tpl.invoke({}).messages)   # 没有变量，传空字典

tpl = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的资深店员，用{tone}的口吻说话"),
    AIMessage(content="欢迎光临！"),
    ("human", "{question}"),
])

from langchain_core.messages import convert_to_messages

msgs = convert_to_messages([
    ("system", "你是拾光书屋的店员"),
    {"role": "user", "content": "你好"},      # OpenAI 风格的 dict 也认识
    ("ai", "欢迎光临"),
])
print([m.type for m in msgs])   # ['system', 'human', 'ai']

FewShotChatMessagePromptTemplate(
    examples: list[dict[str, Any]] | None,   # 示范数据：一个 dict 就是一张示范卡
    example_prompt: ChatPromptTemplate,      # 每张卡片渲染成哪几条消息
) -> FewShotChatMessagePromptTemplate

from langchain_core.prompts import (
    ChatPromptTemplate,
    FewShotChatMessagePromptTemplate,
)

# 一张示范卡 = 一问一答两条消息
card = ChatPromptTemplate.from_messages([
    ("human", "书评：{review}"),
    ("ai", "评分：{score}"),
])

few = FewShotChatMessagePromptTemplate(
    examples=[
        {"review": "一晚上看完，舍不得睡。", "score": "5"},
        {"review": "开头精彩，结尾仓促。", "score": "3"},
        {"review": "书脊开胶了，内容还行。", "score": "3"},
    ],
    example_prompt=card,
)

final = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的评分助手，先看示范再打分。"),
    few,
    ("human", "书评：{review}"),
])

print(final.invoke({"review": "通勤路上读完了大半"}).to_string())
# System: 你是拾光书屋的评分助手，先看示范再打分。
# Human: 书评：一晚上看完，舍不得睡。
# AI: 评分：5
# Human: 书评：开头精彩，结尾仓促。
# AI: 评分：3
# Human: 书评：书脊开胶了，内容还行。
# AI: 评分：3
# Human: 书评：通勤路上读完了大半

AIMessage(
    content: str | Sequence[ContentBlock] = "",   # 正文：纯文本或内容块列表（多模态）
    additional_kwargs: dict[str, Any] = {},       # 各家 API 的扩展抽屉
    response_metadata: dict[str, Any] = {},       # 模型返回时自动附的元信息
    tool_calls: list[ToolCall] = [],               # 模型请求的工具调用
    id: str | None = None,                        # 消息运单号
    name: str | None = None,                      # 发言人名字（多角色时有用）
)

from langchain_core.messages import AIMessage, HumanMessage, ToolMessage

hm = HumanMessage(content=[
    {"type": "text", "text": "这张封面图里的书还有货吗"},
    # {"type": "image", ...}  图片块同理，qwen3:4b 是文本模型就先不放了
])
print(hm.content_blocks)   # [{'type': 'text', 'text': '这张封面图里的书还有货吗'}]
print(hm.text)            # 这张封面图里的书还有货吗 —— 从内容块里抽出纯文本

ai = AIMessage(
    content="还有最后一本，给你留到打烊。",
    additional_kwargs={"foo": "bar"},
    response_metadata={"model_name": "qwen3:4b"},
    id="ai-001",
)
print(ai.type)                 # ai
print(ai.additional_kwargs)    # {'foo': 'bar'}
print(ai.response_metadata)    # {'model_name': 'qwen3:4b'}
print(ai.tool_calls)           # [] 模型没请求工具时就是空列表
print(ai.text)                 # 还有最后一本，给你留到打烊。

tm = ToolMessage(content="库存查询：剩 1 本", tool_call_id="call-001")
print(tm.type)                  # tool

ai = AIMessage(content="", tool_calls=[
    {"name": "search_book", "args": {"genre": "科幻"}, "id": "call-001"},
])
print(ai.tool_calls)
# [{'name': 'search_book', 'args': {'genre': '科幻'}, 'id': 'call-001', 'type': 'tool_call'}]

("human", "你好")                        # 元组：写模板时最顺手
HumanMessage(content="你好")             # 对象：构造、传递、类型判断时用
{"role": "user", "content": "你好"}       # dict：跟 OpenAI 系 API 打交道时用

from langchain_core.messages import (
    HumanMessage, convert_to_messages, messages_from_dict, messages_to_dict,
)

msgs = convert_to_messages([("human", "你好"), {"role": "assistant", "content": "欢迎光临"}])
# [HumanMessage(content='你好'), AIMessage(content='欢迎光临')]

d = messages_to_dict(msgs)          # 转成可 JSON 序列化的 dict 列表（存库、走网络）
back = messages_from_dict(d)        # 再转回对象（读库、收网络）
print(type(back[0]).__name__)      # HumanMessage

MessagesPlaceholder(
    variable_name: str,          # 坑位名，invoke 时按这个名字喂消息列表
    optional: bool = False,     # True 时允许不喂（新对话的第一轮就用得上）
)
# 等价简写（塞元组时）：
("placeholder", "{history}")

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

tpl = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的店员，记得住会员聊过的话题，回答要接得上前文"),
    MessagesPlaceholder("history"),          # 「回忆插页」插在这儿
    ("human", "{question}"),
])

pv = tpl.invoke({
    "history": [
        HumanMessage(content="上次你推荐我读《小王子》"),
        AIMessage(content="对呀！读完感觉怎么样？"),
    ],
    "question": "类似风格的还有吗",
})
for m in pv.messages:
    print(f"{m.type:8} | {m.content}")
# system  | 你是拾光书屋的店员，记得住会员聊过的话题，回答要接得上前文
# human   | 上次你推荐我读《小王子》
# ai      | 对呀！读完感觉怎么样？
# human   | 类似风格的还有吗

tpl_first = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的店员"),
    MessagesPlaceholder("history", optional=True),   # 允许缺席
    ("human", "{question}"),
])
print([m.type for m in tpl_first.invoke({"question": "你好"}).messages])
# ['system', 'human'] —— history 悄悄略过，不炸

tpl2 = ChatPromptTemplate.from_messages([
    ("system", "你是拾光书屋的店员"),
    ("placeholder", "{history}"),     # 与 MessagesPlaceholder("history") 等价
    ("human", "{question}"),
])