# LangChain V1.0 30日学习计划 --- Day 3：Prompt + Model + Message + OutputParser 工业写法

1. PromptTemplate

1.1 导包方式

LangChain v1.0.2 的 PromptTemplate 统一在 langchain_core.prompts 包下：

from langchain_core.prompts import PromptTemplate

PromptTemplate 生成结构化的 PromptMessage 给 Model 使用，是整条链的第一块砖。

1.2 工业级写法

参数解析：

• template：模板字符串，可以写任意自然语言，但必须包含占位符(变量)，占位符格式为：{占位符}

  示例：

  template = "请将下面文字总结成一句话：{text}"
  

  注意： 占位符 {text} 必须和 input_variables 对得上

• input_variables：告诉 PromptTemplate 这个模板会用到哪些变量

  示例：

  input_variables = ["text"]
  

  模板里出现什么占位符，就必须在 input_variables 中列出来
  多一个不行，少一个也不行

• partial_variables（可选参数）：提前写好一些不变的变量，用作常量

  partial_variables = {"常量名": "值"}
  

完整示例：

from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate(
    template = "请将下面文字总结成一句话：{text}",
    input_variables = ["text"],
    validate_template = True  # 开启自动验证
)

工业化模板管理：

# 使用配置化的模板管理
TEMPLATE_REGISTRY = {
    "summarization": "请总结以下内容：{text}，要求{format}",
    "translation": "将{source_lang}翻译成{target_lang}：{text}",
    # ... 更多提示词模板
}

def get_prompt(template_name, **kwargs):
    return PromptTemplate(
        # 通过模板名称调用相应模板
        template = TEMPLATE_REGISTRY[template_name],
        # 自动推断 input_variables，不用手写 "text", "format"
        input_variables = list(kwargs.keys())
    )

• TEMPLATE_REGISTRY 是"提示模板字典"，像仓库一样存储常用 prompt
• get_prompt(template_name, **kwargs) 是"模板工厂"，自动创建完整的 PromptTemplate

1.3 PromptTemplate 的子类

ChatPromptTemplate（对话格式）

当 Prompt 需要多轮对话角色时使用，包含 3 个标准角色：

• system：设定模型的"底层行为方式"

  • 角色设定
  • 输出格式约束
  • 行为限制或风格要求
  • 安全规约

• user：用户输入的内容（指令、问题）

  • “现在我要你做啥?”
  • 每次调用模型都会构造一个 user message

• assistant：模型上一轮的回答（用于多轮对话 context）

示例：

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是翻译专家，翻译时要简洁准确。"),
    ("user", "请翻译：{text}"),
])

自定义角色

ChatPromptTemplate 允许自定义角色：

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("planner", "你的任务是先分析需求，再给出步骤。"),
    ("critic", "你的任务是审查 planner 的方案是否合理。"),
    ("user", "现在开始处理：{text}")
])

模型会根据角色名推断"这个角色说话的风格/职责"，最终根据上下文决定输出。

2. Model

2.1 LangChain v1 的 Model 概念

在 LangChain V1 中，所有模型都是 Runnable

流程：PromptTemplate → ChatModel → Parser

2.2 使用方法

导包：

from langchain_openai import ChatOpenAI

构造：

model = ChatOpenAI(
    model = "str",           # 要调用的模型标识
    temperature = 0.7,       # 控制输出随机性；工业默认常设为 0
    max_tokens = 1000,       # 控制生成长度上限
    stop = list[str],        # 指定终止序列
    timeout = 30,            # 超时设置
    max_retries = 2,         # 重试机制
    streaming = True,        # 流式输出（生产环境推荐）
)

2.3 Model 层工业级写法

完整的 ChatOpenAI 配置

from langchain_openai import ChatOpenAI

# 工业级配置：包含超时、重试、流式输出
model = ChatOpenAI(
    model = "gpt-3.5-turbo",
    temperature = 0.7,       # 控制创造性
    max_tokens = 1000,
    timeout = 30,            # 超时设置
    max_retries = 2,         # 重试机制
    streaming = True,        # 流式输出（生产环境推荐）
)

模型配置管理

from dataclasses import dataclass

# 定义模型配置类
@dataclass
class ModelConfig:
    model_name: str = "gpt-3.5-turbo"
    temperature: float = 0.7
    max_tokens: int = 1000
    timeout: int = 30

def create_model(config: ModelConfig):
    # 自动解包，将一个字典解包成关键字参数
    return ChatOpenAI(**config.__dict__)

工程建议：模型工厂模式

1. 配置文件 (config.yaml)

# 默认使用的提供商名称
provider: openai 

openai:
  model: gpt-4o-mini
  temperature: 0

azure:
  model: gpt-4o-mini
  deployment: my-deployment
  base_url: https://xxx.openai.azure.com/
  api_key: YOUR_AZURE_KEY

local:
  model: qwen2:7b
  base_url: http://localhost:8000/v1

openrouter:
  model: deepseek-chat
  base_url: https://openrouter.ai/api/v1
  api_key: YOUR_OPENROUTER_KEY

2. 工厂函数

import yaml
from langchain_openai import ChatOpenAI, AzureChatOpenAI
from langchain_core.language_models.chat_models import BaseChatModel

def load_config(path = "配置文件路径"):
    """加载 YAML 配置文件"""
    with open(path, "r", encoding = "utf-8") as f:
        return yaml.safe_load(f)  # 返回字典

def create_model(config) -> BaseChatModel:
    """根据配置动态创建模型节点"""
    provider = config["provider"]
    
    if provider == "openai":
        cfg = config["openai"]
        return ChatOpenAI(
            model = cfg["model"],
            temperature = cfg["temperature"]
        )
    elif provider == "azure":
        cfg = config["azure"]
        return AzureChatOpenAI(
            model = cfg["model"],
            deployment_id = cfg["deployment"],
            base_url = cfg["base_url"],
            api_key = cfg["api_key"],
            temperature = 0
        )
    elif provider == "local":
        cfg = config["local"]
        return ChatOpenAI(
            model = cfg["model"],
            base_url = cfg["base_url"],
            temperature = 0
        )
    elif provider == "openrouter":
        cfg = config["openrouter"]
        return ChatOpenAI(
            model = cfg["model"],
            base_url = cfg["base_url"],
            api_key = cfg["api_key"],
            temperature = 0
        )
    else:
        raise ValueError(f"Unknown provider: {provider}")

3. 配置化 PromptTemplate 工厂

from langchain_core.prompts import PromptTemplate

TEMPLATE_REGISTRY = {
    "summarization": "请总结以下内容：{text}，要求{format}",
    "translation": "将{source_lang}翻译成{target_lang}：{text}"
}

def get_prompt(name, **kwargs):
    template = TEMPLATE_REGISTRY[name]
    return PromptTemplate(
        template = template,
        input_variables = list(kwargs.keys())
    )

4. 整合链路

from langchain_core.output_parsers import StrOutputParser

def build_pipeline(config):
    """构建模型和解析器"""
    model = create_model(config)
    parser = StrOutputParser()
    return model, parser

# 使用示例
config = load_config()
model, parser = build_pipeline(config)

# 构建提示词模板
prompt = get_prompt("summarization", text = "秦总今天学习模型工厂", format = "一句话总结")

# 构建链
chain = prompt | model | parser

result = chain.invoke({
    "text": "秦总今天学习模型工厂",
    "format": "一句话总结"
})

print(result)

3. Message

3.1 什么是 Message？

Message = 一条带角色的对话内容

它是 ChatModel 的最小输入单位，模型不吃纯字符串，它吃的是「多条 message」

3.2 Message 类型

from langchain_core.messages import (
    SystemMessage,
    HumanMessage,
    AIMessage,
    ToolMessage
)

• SystemMessage：告诉模型"你是谁、你应该怎么做"

  SystemMessage(content = "你是翻译专家。")
  

• HumanMessage：用户的输入

  HumanMessage(content = "请翻译：你好世界")
  

• AIMessage：模型生成的回答

  AIMessage(content = "Hello world")
  

• ToolMessage：工具返回给模型的内容（做 Agent 时才用）

3.3 为什么大多数时候不手写这些类？

因为 ChatPromptTemplate 会自动帮你创建对应类型。

当你在写：

("system", "你是翻译专家")
("user", "请翻译：{text}")

底层实际上是：

• system → SystemMessage
• user → HumanMessage
• assistant → AIMessage

流程：Message 列表 → 模型 → AIMessage

ChatPromptTemplate 就是一个 Message 工厂

4. OutputParser

4.1 Parser 的作用

Model 的输出是 "AIMessage"对象，但真正需要的是：结构化数据。

Parser = 把模型的"话"变成产品能用的数据

4.2 导包

from langchain_core.output_parsers import XXXOutputParser

4.3 Parser 的类别

4.3.1 StrOutputParser

功能： 把 AIMessage → 解析成纯字符串

from langchain_core.output_parsers import StrOutputParser

parser = StrOutputParser()

# 构建链路
chain = prompt | model | parser

4.3.2 JsonOutputParser

功能： 令模型直接输出结构化数据（工业最常用）

from langchain_core.output_parsers import JsonOutputParser

parser = JsonOutputParser()

完整示例：

# Step 1：创建稳健的 system message
from langchain_core.prompts import ChatPromptTemplate

json_prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "你是信息抽取专家。所有输出必须是严格可解析的 JSON。"
        "只输出 JSON，不要出现自然语言、注释、解释，也不要输出 ```json 代码块格式。"
        "输出字段：姓名、事件。"
    ),
    ("user", "请抽取信息：{text}")
])

# Step 2：创建 JSON Parser
from langchain_core.output_parsers import JsonOutputParser

parser = JsonOutputParser()

# Step 3：创建模型节点
from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model = "gpt-4o-mini",
    temperature = 0
)

# Step 4：组成链
chain = json_prompt | model | parser

# 执行链
result = chain.invoke({
    "text": "张三今天去买了瓶酱油，然后遇到超市抽奖，中了五百万"
})

4.3.3 PydanticOutputParser（强类型数据类）

功能： 抽取出的字段必须是满足需求的"数据类结构"

特点：

• 字段不允许多
• 字段不允许少
• 字段类型必须对（str / int / list / bool …）
• 模型如果乱写，直接报错，避免脏数据流入

使用步骤：

1. 定义数据类的 schema

from pydantic import BaseModel, Field

class Info(BaseModel):  # 继承 BaseModel
    # Field 提供字段的元信息
    # description：字段描述，告诉 LLM 这个字段应该填什么内容
    name: str = Field(description = "人物姓名")
    event: str = Field(description = "发生的事件")

2. 创建 PydanticOutputParser

from langchain_core.output_parsers import PydanticOutputParser

# 给 parser 一个"数据类"
parser = PydanticOutputParser(pydantic_object = Info)

# 获取格式说明
format_instructions = parser.get_format_instructions()

3. 把 format_instructions 注入 Prompt

from langchain_core.prompts import ChatPromptTemplate

json_prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "你是信息抽取专家，只输出 JSON，不要输出解释、注释、自然语言。"
    ),
    (
        "user", 
        "请从下面内容中抽取信息。\n\n内容：{text}\n\n格式要求：{format_instructions}"
    )
])

4. 构建完整链路

chain = json_prompt | model | parser

# 调用链
result = chain.invoke({
    "text": "张三今天去买了瓶酱油，然后遇到超市抽奖，中了五百万",
    "format_instructions": parser.get_format_instructions()
})

print(result)
# 输出：Info(name='张三', event='去买了瓶酱油，然后遇到超市抽奖，中了五百万')

总结

• PromptTemplate / ChatPromptTemplate —— 负责把变量灌进提示词
• Model（ChatOpenAI、Ollama、DeepSeek 等） —— 负责推理
• OutputParser —— 负责结构化输出（尤其 JSON / Pydantic）
• Runnable 链符号：| —— 像管道一样把节点串起来
• invoke() —— 喂数据、启动链路流动
• 输出就是强类型 Python 对象（适合自动化系统）