【LangChain】—— Prompt、Model、Chain与多模型执行链

花间相见2026-01-29 19:39

LangChain核心组件全解析：Prompt/Model/Chain输入输出+解析器与多模型链实战

作为LangChain初学者，你是否经常困惑：PromptTemplate、ChatModel、Chain这些核心组件的输入输出到底是什么格式？为什么有时候拼接的提示词模型不认？为什么模型返回的结果没法直接用？

其实LangChain的核心是「数据流」------用户输入经过Prompt模板格式化，传给Model生成结果，再通过Chain串联整个流程，而格式匹配 是串联的关键。本文不仅会系统梳理Prompt、Model、Chain三大核心组件的输入输出格式，还会补充实战中高频使用的JsonOutputParser、StrOutputParser解析器用法，并手把手教你构建多模型链，让你彻底搞懂LangChain的数据流逻辑。

一、前置准备：环境与依赖

先安装必备依赖并配置API Key（以OpenAI为例），确保所有示例可直接运行：

bash 复制代码 
# 安装核心依赖
pip install langchain langchain-openai python-dotenv

创建.env文件配置API Key：

env 复制代码 
OPENAI_API_KEY="你的OpenAI API密钥"

二、核心组件：输入输出格式全梳理

LangChain的数据流核心链路是：用户输入 → Prompt模板（格式化） → Model（调用模型） → Chain（串联流程） → 最终输出，每个组件的输入输出严格适配前后环节。

2.1 Prompt家族：把用户输入变成模型能懂的格式

Prompt模板的核心作用是将「动态参数」和「固定提示词」拼接成模型可识别的格式，分为3类核心模板：

（1）PromptTemplate（基础文本模板）
  • 定位：专为LLM（文本模型）设计的基础模板
  • 输入 ：
    • 定义阶段：带{变量名}占位符的字符串 + 输入变量列表（可选）；
    • 调用阶段（invoke）：字典（key=变量名，value=变量值）。
  • 输出：纯字符串（拼接后的完整提示词）。
python 复制代码 
from langchain_core.prompts import PromptTemplate
from dotenv import load_dotenv
load_dotenv()  # 加载API Key

# 1. 定义模板
template = "请用{language}写一句关于{topic}的简短标语"
prompt_template = PromptTemplate(
    template=template,
    input_variables=["language", "topic"]  # 自动识别占位符，可选
)

# 2. 调用模板（输入：字典）
prompt = prompt_template.invoke({"language": "中文", "topic": "AI学习"})

# 3. 查看输出
print("输出类型：", type(prompt))  # <class 'str'>
print("输出内容：", prompt)        # 请用中文写一句关于AI学习的简短标语
（2）FewShotTemplate（少样本模板）
  • 定位：带示例的模板，通过案例引导模型输出（适合需要参考的场景）
  • 输入 ：
    • 定义阶段：示例列表 + 子PromptTemplate + 前缀/后缀文本 + 输入变量；
    • 调用阶段：字典（key=最终变量名，value=变量值）。
  • 输出：纯字符串（包含示例+固定文本+动态参数的完整提示词）。
python 复制代码 
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate

# 1. 定义示例（参考案例）
examples = [
    {"input": "1+1", "output": "2"},
    {"input": "3+5", "output": "8"},
    {"input": "9-2", "output": "7"}
]

# 2. 定义单个示例的格式
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="输入：{input}\n输出：{output}"
)

# 3. 定义少样本模板
few_shot_template = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    prefix="请按照以下示例计算数学题：",
    suffix="输入：{new_input}\n输出：",
    input_variables=["new_input"]
)

# 4. 调用模板（输入：字典）
prompt = few_shot_template.invoke({"new_input": "8+6"})

# 5. 查看输出
print("输出类型：", type(prompt))
print("输出内容：\n", prompt)
# 输出结果：
# 请按照以下示例计算数学题：
# 输入：1+1
# 输出：2
# 输入：3+5
# 输出：8
# 输入：9-2
# 输出：7
# 输入：8+6
# 输出：
（3）ChatPromptTemplate（对话模板）
  • 定位：专为ChatModel（GPT-3.5/4等对话模型）设计，最常用的模板
  • 输入 ：
    • 定义阶段：MessageTemplate列表（指定system/human/ai角色 + 带占位符的内容）；
    • 调用阶段：字典（key=变量名，value=变量值）。
  • 输出 ：BaseMessage列表（SystemMessage/HumanMessage组合）。
python 复制代码 
from langchain_core.prompts import ChatPromptTemplate

# 1. 定义对话模板（指定角色）
chat_template = ChatPromptTemplate.from_messages([
    ("system", "你是{role}，回答必须不超过10个字"),  # 系统角色
    ("human", "请介绍{topic}")                      # 人类角色
])

# 2. 调用模板（输入：字典）
messages = chat_template.invoke({"role": "科普助手", "topic": "Python"})

# 3. 查看输出
print("输出类型：", type(messages))  # <class 'list'>
for msg in messages:
    print(f"角色：{msg.role}，内容：{msg.content}")
# 输出结果：
# 角色：system，内容：你是科普助手，回答必须不超过10个字
# 角色：human，内容：请介绍Python

2.2 Model家族：模型层的输入输出

Model是LangChain的核心执行层，接收Prompt输出的格式，调用大模型/嵌入模型并返回结果，分为3类核心模型：

（1）LLMs（文本大模型，旧版）
  • 定位：处理纯文本输入的模型（如text-davinci-003），已逐步被ChatModel替代
  • 输入：纯字符串（PromptTemplate/FewShotTemplate的输出）
  • 输出：纯字符串（模型生成的文本）
python 复制代码 
from langchain_openai import OpenAI

# 1. 初始化LLM
llm = OpenAI(model="text-davinci-003", temperature=0.0)

# 2. 输入：纯字符串
input_text = "请用一句话介绍Python"

# 3. 调用模型
output = llm.invoke(input_text)

# 4. 查看输出
print("输出类型：", type(output))  # <class 'str'>
print("输出内容：", output.strip())  # Python是易读易写的解释型编程语言。
（2）ChatModel（对话大模型，主流）
  • 定位：处理对话消息的模型（GPT-3.5/4、文心一言等），实战首选
  • 输入 ：BaseMessage列表（ChatPromptTemplate的输出）
  • 输出 ：AIMessage对象（核心属性：content=文本内容、role=assistant、metadata=元数据）
python 复制代码 
from langchain_openai import ChatOpenAI

# 1. 初始化ChatModel
chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)

# 2. 输入：Message列表（来自ChatPromptTemplate）
chat_template = ChatPromptTemplate.from_messages([("human", "请介绍Python，不超过10个字")])
input_messages = chat_template.invoke({})

# 3. 调用模型
output = chat_model.invoke(input_messages)

# 4. 查看输出
print("输出类型：", type(output))  # <class 'langchain_core.messages.ai.AIMessage'>
print("核心文本：", output.content)  # Python：易上手的解释型语言
print("角色标识：", output.role)    # assistant
print("元数据：", output.metadata)  # 包含模型版本、耗时等信息
（3）Embedding（嵌入模型）
  • 定位：将文本转为数值向量（用于相似度计算、检索、知识库等场景）
  • 输入 ：
    • 单文本：纯字符串；
    • 多文本：字符串列表。
  • 输出 ：
    • 单文本：List[float]（浮点型向量，如ada-002是1536维）；
    • 多文本：List[List[float]]（向量列表的列表）。
python 复制代码 
from langchain_openai import OpenAIEmbeddings

# 1. 初始化Embedding模型
embeddings = OpenAIEmbeddings()

# 2. 场景1：单文本输入
single_text = "Python编程学习"
single_embedding = embeddings.embed_query(single_text)
print("单文本输出类型：", type(single_embedding))  # <class 'list'>
print("向量维度：", len(single_embedding))        # 1536（ada-002固定维度）

# 3. 场景2：多文本输入
multi_texts = ["Python编程", "Java编程", "AI开发"]
multi_embeddings = embeddings.embed_documents(multi_texts)
print("多文本输出类型：", type(multi_embeddings))  # <class 'list'>
print("向量数量：", len(multi_embeddings))          # 3（对应3个文本）

2.3 Chain家族：串联组件的链路层

Chain的核心是用LCEL语法（|）串联Prompt、Model、解析器等组件，实现端到端数据流，输入输出格式由链路的首尾组件决定。

基础示例：ChatPromptTemplate + ChatModel
python 复制代码 
# 1. 定义组件
chat_template = ChatPromptTemplate.from_messages([("human", "请用{adjective}的语气介绍{topic}")])
chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)

# 2. 构建链（Prompt → Model）
chain = chat_template | chat_model

# 3. 输入：字典（匹配Prompt的变量）
input_data = {"adjective": "幽默", "topic": "编程"}

# 4. 输出：AIMessage对象（ChatModel的输出格式）
output = chain.invoke(input_data)
print("链输出内容：", output.content)
# 输出示例：编程这事儿嘛，就像拆盲盒------看似复杂，拆开来全是有趣的小逻辑～

三、实战必备：输出解析器（JsonOutputParser/StrOutputParser）

ChatModel默认返回AIMessage对象，LLM返回字符串，但实战中我们常需要纯字符串 或结构化字典，这时候就需要输出解析器。

3.1 StrOutputParser：统一转为纯字符串

  • 作用 ：将AIMessage对象、字符串等统一转为纯字符串，解决ChatModel返回对象不好直接使用的问题。
  • 输入 ：字符串 / AIMessage对象
  • 输出：纯字符串
python 复制代码 
from langchain_core.output_parsers import StrOutputParser

# 1. 定义组件
chat_template = ChatPromptTemplate.from_messages([("human", "请介绍{topic}，不超过20字")])
chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)
str_parser = StrOutputParser()  # 字符串解析器

# 2. 构建链（Prompt → Model → 解析器）
chain = chat_template | chat_model | str_parser

# 3. 调用链
output = chain.invoke({"topic": "LangChain"})

# 4. 查看输出
print("输出类型：", type(output))  # <class 'str'>
print("输出内容：", output)        # LangChain：串联AI组件的Python框架

3.2 JsonOutputParser：强制返回结构化JSON

  • 作用：让模型严格按照指定格式返回JSON，解析成Python字典，方便后续数据处理。
  • 输入 ：AIMessage对象 / 字符串（模型生成的JSON文本）
  • 输出：Python字典
python 复制代码 
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field

# 1. 定义结构化数据模型（指定JSON格式）
class ProductIntro(BaseModel):
    name: str = Field(description="产品名称")
    advantage: str = Field(description="产品核心优势")
    scenario: str = Field(description="适用场景")

# 2. 初始化JSON解析器
json_parser = JsonOutputParser(pydantic_object=ProductIntro)

# 3. 定义Prompt（告知模型输出格式）
chat_template = ChatPromptTemplate.from_messages([
    ("system", f"请严格按照以下格式输出JSON：{json_parser.get_format_instructions()}"),
    ("human", "请介绍产品：{product}")
])

# 4. 构建链
chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)
chain = chat_template | chat_model | json_parser

# 5. 调用链
output = chain.invoke({"product": "LangChain"})

# 6. 查看输出
print("输出类型：", type(output))  # <class 'dict'>
print("结构化输出：")
print(f"产品名称：{output['name']}")
print(f"核心优势：{output['advantage']}")
print(f"适用场景：{output['scenario']}")
# 输出示例：
# 产品名称：LangChain
# 核心优势：灵活串联AI组件，快速构建大模型应用
# 适用场景：智能问答、知识库、自动化创作

四、进阶实战：多模型链的构建

多模型链是串联多个不同类型模型的链路（如Embedding+ChatModel、LLM+ChatModel），解决复杂场景下的任务拆分问题。

示例1：Embedding+ChatModel（文本向量化→相似度匹配→智能回答）

python 复制代码 
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import numpy as np

# 步骤1：定义知识库文本并向量化
knowledge_texts = [
    "LangChain是一个用于构建大语言模型应用的Python框架",
    "LangChain支持Prompt模板、模型调用、链串联等核心功能",
    "LangChain的核心优势是组件化、可扩展、易集成"
]
embeddings = OpenAIEmbeddings()
knowledge_embeddings = embeddings.embed_documents(knowledge_texts)

# 步骤2：定义相似度匹配函数
def get_similar_text(query: str) -> str:
    # 1. 查询文本向量化
    query_embedding = embeddings.embed_query(query)
    # 2. 计算余弦相似度
    similarities = [
        np.dot(query_embedding, emb) / (np.linalg.norm(query_embedding) * np.linalg.norm(emb))
        for emb in knowledge_embeddings
    ]
    # 3. 返回最相似的文本
    most_similar_idx = np.argmax(similarities)
    return knowledge_texts[most_similar_idx]

# 步骤3：构建多模型链
def build_multi_model_chain():
    # 1. 定义Prompt（融入相似文本）
    chat_template = ChatPromptTemplate.from_messages([
        ("system", "基于以下信息回答问题：{context}"),
        ("human", "{query}")
    ])
    # 2. 定义模型和解析器
    chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)
    str_parser = StrOutputParser()
    # 3. 构建链（先匹配相似文本，再生成回答）
    def chain_func(inputs):
        context = get_similar_text(inputs["query"])
        return (chat_template | chat_model | str_parser).invoke({
            "context": context,
            "query": inputs["query"]
        })
    return chain_func

# 步骤4：调用多模型链
multi_chain = build_multi_model_chain()
output = multi_chain({"query": "LangChain的核心优势是什么？"})

print("多模型链输出：", output)
# 输出示例：LangChain的核心优势是组件化、可扩展、易集成。

示例2：LLM+ChatModel（草稿生成→优化润色）

python 复制代码 
from langchain_openai import OpenAI, ChatOpenAI
from langchain_core.prompts import PromptTemplate, ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 步骤1：定义组件
# 组件1：LLM生成草稿
llm = OpenAI(model="text-davinci-003", temperature=0.7)
draft_template = PromptTemplate(template="写一篇关于{topic}的简短草稿（50字以内）", input_variables=["topic"])
draft_chain = draft_template | llm | StrOutputParser()

# 组件2：ChatModel优化润色
chat_model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)
polish_template = ChatPromptTemplate.from_messages([
    ("human", "请优化以下草稿，使其更流畅：{draft}")
])
polish_chain = polish_template | chat_model | StrOutputParser()

# 步骤2：串联多模型链
def multi_model_chain(inputs):
    # 1. 生成草稿
    draft = draft_chain.invoke({"topic": inputs["topic"]})
    print("草稿：", draft)
    # 2. 优化润色
    polished = polish_chain.invoke({"draft": draft})
    return polished

# 步骤3：调用链
output = multi_model_chain({"topic": "Python学习"})
print("优化后：", output)
# 输出示例：
# 草稿：Python易上手，能做数据分析、Web开发，适合零基础学习。
# 优化后：Python语言简洁易上手，可应用于数据分析、Web开发等场景，非常适合零基础入门学习。

五、核心要点总结

  1. Prompt层 ：
    • PromptTemplate/FewShotTemplate：输入=字典，输出=纯字符串（适配LLM）；
    • ChatPromptTemplate：输入=字典，输出=Message列表（适配ChatModel）。
  2. Model层 ：
    • LLMs：输入=字符串，输出=字符串；
    • ChatModel：输入=Message列表，输出=AIMessage对象；
    • Embedding：输入=字符串/字符串列表，输出=向量列表。
  3. 解析器层 ：
    • StrOutputParser：统一转为纯字符串，解决ChatModel返回对象的问题；
    • JsonOutputParser：强制模型返回JSON，解析成字典，适配结构化场景。
  4. Chain层 ：
    • 输入格式由链的第一个组件决定（通常是字典）；
    • 输出格式由链的最后一个组件决定；
    • 多模型链可拆分复杂任务，通过函数/LCEL串联不同模型。

掌握这些核心格式和组合方式，你就能灵活搭建任意复杂度的LangChain应用，再也不用被「格式不匹配」的问题困扰！

相关推荐
lichenyang4532 小时前
从零开始构建 React 文档系统 - 完整实现指南
前端·javascript·react.js
比特森林探险记2 小时前
Hooks、状态管理
前端·javascript·react.js
landonVM3 小时前
Linux 上搭建 Web 服务器
linux·服务器·前端
css趣多多3 小时前
路由全局守卫
前端
AI视觉网奇3 小时前
huggingface-cli 安装笔记2026
前端·笔记
比特森林探险记3 小时前
组件通信 与 ⏳ 生命周期
前端·javascript·vue.js
2301_792580003 小时前
xuepso
java·服务器·前端
海绵宝龙3 小时前
Vue中nextTick
前端·javascript·vue.js
天生欧皇张狗蛋4 小时前
前端部署path问题
前端
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Clawdbot 中文汉化版 接入微信、飞书04【网络安全测试】Burp Suite工具使用说明、配置及常见问题（有关必回）05Claude Code Skills 实用使用手册06一种新的LCA算法07在Trae中使用Pencil MCP08零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程09struts2 XML外部实体注入漏洞复现（CVE-2025-68493）10UV安装并设置国内源