简单来说就三步：拼提示词 -> 调大模型 -> 把结果整理成程序能用的格式

LangChain 是一个开发大模型应用的框架，而 Model I/O 是其中最基础、最核心的模块。它的名字听起来很技术，实际上只做三件简单的事情：

• 输入（Input）

  ：把用户的原始问题，加上你对模型的指令（比如"你是一个客服"），组合成一个完整的提示词（Prompt）

• 处理（Model）

  ：把这个提示词发给大模型，等待模型返回结果

• 输出（Output）

  ：把模型返回的文本，解析成你的程序可以直接使用的数据结构（比如字典、列表、对象）

如果没有 Model I/O，你需要手动拼接字符串、手动处理 API 请求、手动用正则表达式提取结果------不仅代码重复、容易出错，而且换一个模型就要重写一大片。

一个通俗的类比：假设你开了一家餐厅。

• 顾客（用户）说"我要一份宫保鸡丁"------这是原始输入。
• 但后厨的大厨（大模型）只看得懂标准化的菜单指令。于是你（Model I/O）把顾客的话翻译成"鸡丁 200g、花生米 50g、干辣椒 10g......"这样的标准格式------这就是 输入处理。
• 然后你把菜单递给大厨，大厨开始炒菜------这就是 模型调用。
• 大厨炒完菜，你把它装盘、摆成统一的样式端给顾客------这就是 输出解析。

Model I/O 就是帮你把这套流程标准化、自动化、可维护化。

目前有很多平台提供大模型 API 服务。你不需要自己买显卡、搭环境，只需注册账号、获取 API-Key，就能用代码调用他们部署好的模型。常见平台有：

• CloseAI

  ：OpenAI 兼容接口，价格相对便宜

  API-Key 管理：https://platform.closeai-asia.com/developer/api

  模型列表：https://platform.closeai-asia.com/pricing

• OpenRouter

  ：聚合多家模型，一个 Key 调用多种模型

  API-Key 管理：https://openrouter.ai/settings/keys

  模型列表：https://openrouter.ai/models

• 阿里云百炼

  ：通义千问系列，国内访问稳定

  API-Key 管理：https://bailian.console.aliyun.com/?tab=model#/api-key

  模型市场：https://bailian.console.aliyun.com/?tab=model#/model-market/all

• 百度千帆

  ：文心一言系列，生态完整

  API-Key 管理：https://console.bce.baidu.com/qianfan/apis/console/apiKey

  模型中心：https://console.bce.baidu.com/qianfan/modelcenter/model/buildIn/list

• 硅基流动

  ：国产算力平台，性价比高

  API-Key 管理：https://cloud.siliconflow.cn/me/account/ak

  模型列表：https://cloud.siliconflow.cn/me/models

这些平台都遵循 OpenAI 定义的 API 规范，所以调用方式几乎一模一样。

OpenAI 的 GPT 系列模型影响力极大，以至于几乎所有其他模型厂商都主动兼容它的调用格式。因此，下面这段代码只需更换 base_url 和 api_key，就能调用不同平台的模型。

 
    
    
      
 
       
# 安装依赖：pip install openai 
 
       
from openai import OpenAI
 
       
创建客户端，指定平台地址和你的密钥
 
       
client = OpenAI(
 
       
base_url="https://openrouter.ai/api/v1", # 平台提供的 URL api_key="sk-你的密钥", # 平台提供的 API-Key 
 
       
)
 
       
发起一次对话
 
       
completion = client.chat.completions.create(
 
       
model="openai/gpt-oss-20b:free", # 模型名称，不同平台有不同命名规则 messages=[ {"role": "user", "content": "把'你好'翻译成意大利语"} ], 
 
       
)
 
       
从返回结果中提取模型输出的文字
 
       
print(completion.choices[0].message.content)
 
      

 
参数说明：
 

• base_url：API 服务的入口地址，由平台提供。
• api_key：身份凭证，相当于密码，需要保密。
• model：具体使用哪个模型，不同平台提供的模型名称不同。
• messages：对话历史，是一个列表。每个元素包含 role（角色）和 content（内容）。角色可以是 system（系统指令）、user（用户）、assistant（AI 的回复）。

初学者最容易犯的错误是把 API-Key 直接写在代码里。一旦代码上传到 GitHub，别人就能看到你的密钥，然后用它来调用模型，扣除你的费用。

推荐做法：把密钥放在 .env 文件中，代码只读取这个文件。

首先，在项目根目录创建一个 .env 文件（注意这个文件要加入 .gitignore，不要提交到版本库）：

 
    
    
      
 
       
OPENAI_API_KEY="sk-你的真实密钥" 
 
       
OPENAI_BASE_URL="https://openrouter.ai/api/v1"
 
      

 
然后在代码中使用 python-dotenv 加载：
 
    
    
      
 
       
# pip install python-dotenv 
 
       
import os from openai import OpenAI from dotenv import load_dotenv
 
       
加载 .env 文件中的变量到环境变量
 
       
load_dotenv()
 
       
从环境变量中读取
 
       
client = OpenAI(
 
       
base_url=os.getenv("OPENAI_BASE_URL"), api_key=os.getenv("OPENAI_API_KEY"), 
 
       
)
 
       
后续调用不变…
 
      

 
如果你更简洁，也可以利用 OpenAI 客户端的默认行为------它会自动从环境变量中查找 OPENAI_API_KEY 和 OPENAI_BASE_URL：
 
    
    
      
 
       
load_dotenv() 
 
       
client = OpenAI() # 不需要显式传递参数
 
      

 
三种管理方式的对比：
 

OpenAI SDK 已经很方便了，但如果你今天用 OpenAI，明天想换成国产模型，后天又想用本地 Ollama，代码结构还是略有差异。LangChain 提供了 init_chat_model 函数，让你用完全相同的代码初始化任何模型。

 
    
    
      
 
       
import os 
 
       
from langchain.chat_models import init_chat_model
 
       
无论用哪家模型，写法都一样
 
       
llm = init_chat_model(
 
       
model="openai/gpt-oss-20b:free", # 模型名称 model_provider="openai", # 模型提供商（openai/anthropic/google等） base_url="https://openrouter.ai/api/v1", api_key=os.getenv("OPENROUTER_API_KEY"), 
 
       
)
 
       
调用方式也完全一样
 
       
response = llm.invoke("把’你好’翻译成意大利语") print(response.content) # response 是 AIMessage 对象，.content 取文本
 
      

 
如果你想换成阿里云的通义千问，只需修改 model 和 base_url，其他代码不用动。这就是统一接口的好处。
 

调用模型时，除了指定模型名称，还可以调整一些参数来控制模型的行为。这些参数在 init_chat_model 中可以直接设置。

示例：

 
    
    
      
 
       
llm = init_chat_model( model="...", model_provider="...", base_url="...", api_key="...", temperature=0.7, # 中等创意 max_tokens=500, # 回答最多 500 token timeout=30, # 30 秒超时 max_retries=2, # 失败后最多重试 2 次 
 
       
)
 
      

Token 是大模型处理文本的最小单位。它不是字符，也不是单词，而是一种介于两者之间的粒度。

• 1 个中文汉字 ≈ 1 ~ 1.8 个 Token
• 1 个英文单词 ≈ 3 ~ 4 个字母，平均分成 1~2 个 Token

例如，"Hello world" 可能被拆成 "Hello" 和 " world" 两个 Token。"你好世界" 可能被拆成 "你"、"好"、"世界" 三个 Token。

模型提供方通常按 Token 数量收费，同时也用 Token 数量限制一次请求的输入+输出总长度。你可以使用 OpenAI 提供的在线 Tokenizer 工具来查看任意文本会消耗多少 Token。

在多轮对话中，每条消息都有一个角色（role），告诉模型这句话是谁说的。LangChain 中常用的消息类型有：

代码中可以使用类，也可以使用字典，两种方式等价：

 
    
    
      
 
       
# 方式一：使用类（类型提示更清晰） 
 
       
from langchain.messages import SystemMessage, HumanMessage messages = [
 
       
SystemMessage("你是一个诗人"), HumanMessage("写一首关于春天的诗"), 
 
       
]
 
       
方式二：使用字典（更接近 OpenAI 原始格式）
 
       
messages = [
 
       
{"role": "system", "content": "你是一个诗人"}, {"role": "user", "content": "写一首关于春天的诗"}, 
 
       
]
 
      

LangChain 的聊天模型提供了四种调用方法，适用不同场景：

 
    
    
      
 
       
response = llm.invoke("你好，介绍一下你自己") 
 
       
print(response.content) # 等待全部生成完后一次性打印
 
      

 
    
    
      
 
       
# stream 返回一个生成器，每次吐出一个 token 
 
       
for chunk in llm.stream("写一首关于秋天的诗"):
 
       
# end="" 表示不换行，flush=True 表示立即输出到屏幕 print(chunk.content, end="", flush=True)
 
      
 
效果就是 AI 一个字一个字地"打"出来，用户体验非常自然。尤其对于长回答，用户不需要等待 10 秒后突然看到一大段文字。
 

当你有一批相互独立的请求时，batch 会使用线程池并行执行多个 invoke，总耗时接近单个请求的耗时（而不是逐个累加）。

 
    
    
      
 
       
# 准备多个独立的对话 
 
       
questions = [
 
       
[{"role": "user", "content": "写一首关于春天的诗"}], [{"role": "user", "content": "写一首关于夏天的诗"}], [{"role": "user", "content": "写一首关于秋天的诗"}], 
 
       
]
 
       
批量调用，返回结果列表
 
       
results = llm.batch(questions) for r in results:
 
       
print(r.content)
 
      
 
假设每个请求需要 6 秒，串行需要 18 秒，batch 并行只需要约 6 秒。
 

当你的程序需要同时做多件事情（比如一边调模型，一边读文件，一边发网络请求），同步调用会卡住整个程序。异步调用允许你"同时"发起多个请求，在等待模型返回时继续执行其他任务。

 
    
    
      
 
       
import asyncio 
 
       
from langchain.chat_models import init_chat_model
 
       
llm = init_chat_model(…)
 
       
async def ask(question):
 
       
return await llm.ainvoke(question) 
 
       
async def main():
 
       
# 同时发起三个请求 tasks = [ask("写一首关于春天的诗"), ask("写一首关于夏天的诗"), ask("写一首关于秋天的诗")] results = await asyncio.gather(*tasks) for r in results: print(r.content) 
 
       
运行异步主函数
 
       
asyncio.run(main())
 
      

 
asyncio.gather 会并发执行所有任务。如果每个请求 6 秒，三个同时进行，总耗时仍然约 6 秒。
 

同步 vs 异步对比：

• 同步：任务 A 完成 → 任务 B 开始 → 任务 B 完成 → 任务 C 开始。总时间 = 各任务时间之和。
• 异步：任务 A、B、C 同时开始，谁先完成谁先返回。总时间 ≈ 最慢的那个任务的时间。

Ollama 是一个开源工具，目标是在你自己的电脑上运行大模型。你不需要联网，不需要付费，数据也不会离开你的机器。

你可以把它理解为"大模型版的 Docker"------你只需要敲一行命令，它就会自动下载模型、配置环境、启动服务，完全不用操心底层细节。

Ollama 的主要优势：

• 免费：没有 API 调用费用，不限次数。
• 隐私：所有数据都在本地，不会上传到任何服务器。
• 简单：一条命令就能跑起来。
• 跨平台：支持 Windows、macOS、Linux。

官方地址：https://ollama.com

GitHub 开源地址：https://github.com/ollama/ollama

模型仓库：https://ollama.com/search

根据你的操作系统选择安装方式：

• Windows

  ：访问 https://ollama.com/download，下载 .exe 安装包，双击安装。

• macOS

  ：下载 .dmg 文件，拖到 Applications 文件夹。

• Linux

  ：打开终端，执行以下命令：

  curl -fsSL https://ollama.com/install.sh | sh

安装完成后，在终端输入 ollama --version，如果能显示版本号，说明安装成功。

Ollama 支持大量开源模型，如 DeepSeek、Qwen、Llama 等。以 DeepSeek-R1 的 70 亿参数版本（7b 表示 7 billion，即 70 亿参数）为例：

 
     
    
       
 
        
ollama run deepseek-r1:7b
 
       
 
     
    
       
 
       

常用 Ollama 命令：

如果 C 盘空间紧张，可以修改模型存储目录：在 Ollama 设置（Settings）中找到 "Model location"，改为其他盘符的路径。

Ollama 启动后默认在 http://localhost:11434 开启一个 API 服务。LangChain 提供了 ChatOllama 类来连接这个服务。

 
     
    
       
 
        
# 安装依赖：pip install langchain-ollama 
 
        
from langchain_ollama import ChatOllama
 
        
连接本地 Ollama 服务
 
        
ollama_llm = ChatOllama(model="deepseek-r1:7b")
 
        
调用方式与在线模型完全一致
 
        
response = ollama_llm.invoke("你好，请介绍一下你自己") print(response.content)
 
       

 
如果你的 Ollama 运行在另一台机器上（例如你有一台专门跑模型的 Linux 服务器），可以指定 IP 和端口：
 
     
    
       
 
        
ollama_llm = ChatOllama( model="deepseek-r1:7b", base_url="http://192.168.1.100:11434", # 改为你服务器的地址 
 
        
)
 
       

 
注意：本地模型的性能取决于你的硬件（尤其是显存）。7B 参数模型大约需要 4-6GB 显存，如果没有独立显卡，CPU 也能运行但速度较慢。
 

假设你正在做一个智能客服，用户问"这个商品多少钱"，你需要加上系统指令"你是一个客服，态度要友好"。没有模板时，你可能这样写：

 
      
    
        
 
         
product = "手机" 
 
         
user_question = "这个多少钱" prompt = f"你是一个客服。用户的问题是：{user_question}，商品是{product}"
 
        

 
一两个地方还好，当你有几十个不同的场景，每个场景的提示词结构都不一样时，维护起来就是灾难。改一个字可能要翻遍所有代码。
 

使用模板的好处：

• 提示词的结构集中在一个地方，修改一处全局生效。
• 业务代码中只需要传变量，不用关心格式细节。
• 可以把提示词单独存成文件（JSON/YAML），方便非技术人员调整。

LangChain 的 PromptTemplate 底层使用的是 Python 字符串的 format 方法。先快速回顾一下：

 
      
    
        
 
         
# 最简单的：按顺序替换 
 
         
"Hello, {}".format("张三") # 输出: Hello, 张三
 
         
用数字指定位置
 
         
"Name: {0}, Age: {1}".format("李四", 25) # Name: 李四, Age: 25
 
         
用变量名（推荐，可读性最好）
 
         
"Name: {name}, Age: {age}".format(name="王五", age=30)
 
         
从字典中解包
 
         
person = {"name": "赵六", "age": 35} "Name: {name}, Age: {age}".format(person)
 
        

PromptTemplate 是最简单的提示模板，用于构建包含变量的字符串。

方式一：使用构造函数

 
      
    
        
 
         
from langchain_core.prompts import PromptTemplate 
 
         
template = PromptTemplate(
 
         
template="请评价{product}的优缺点，包括{aspect1}和{aspect2}。", input_variables=["product", "aspect1", "aspect2"], 
 
         
)
 
         
填充变量
 
         
prompt1 = template.format(product="智能手机", aspect1="电池续航", aspect2="拍照质量") print(prompt1)
 
         
输出：请评价智能手机的优缺点，包括电池续航和拍照质量。
 
         
prompt2 = template.format(product="笔记本电脑", aspect1="处理速度", aspect2="便携性") print(prompt2)
 
         
输出：请评价笔记本电脑的优缺点，包括处理速度和便携性。
 
        

 
方式二：使用 from_template 类方法（更简洁）
 
      
    
        
 
         
template = PromptTemplate.from_template("请给我一个关于{topic}的{type}解释。") 
 
         
prompt = template.format(type="详细", topic="量子力学") print(prompt)
 
         
输出：请给我一个关于量子力学的详细解释。
 
        

 
from_template 会自动解析花括号中的变量名，不需要手动指定 input_variables。
 

有些变量在很多次调用中都是一样的（比如固定的系统指令）。你可以提前把这些变量填好，生成一个"半成品"模板，后面每次调用只需要填剩下的变量。

方式一：在构造函数中指定 partial_variables

 
      
    
        
 
         
template = PromptTemplate( template="foo {bar}", input_variables=["bar"], # 注意：foo 已被预填充，不需要出现在 input_variables 中 partial_variables={"foo": "hello"}, # 预先填充 foo 
 
         
)
 
         
prompt = template.format(bar="world") print(prompt) # hello world
 
        

 
方式二：使用 partial 方法
 
      
    
        
 
         
template = PromptTemplate.from_template("foo {bar}") 
 
         
partial_template = template.partial(foo="hello") # 预填充 foo prompt = partial_template.format(bar="world") print(prompt) # hello world
 
        

如果你的应用涉及多轮对话（有系统消息、用户消息、AI 消息），PromptTemplate 就不够用了。这时候需要用 ChatPromptTemplate。

 
      
    
        
 
         
from langchain_core.prompts import ChatPromptTemplate 
 
         
template = ChatPromptTemplate.from_messages([
 
         
("system", "你是一个 AI 开发工程师，你的名字是{name}。"), ("human", "你能帮我做什么？"), ("ai", "我能开发很多{thing}。"), ("human", "{user_input}"), 
 
         
])
 
         
填充所有变量
 
         
prompt = template.format_messages(
 
         
name="小谷AI", thing="AI应用", user_input="你好" 
 
         
)
 
         
print(prompt)
 
         
输出是一个消息列表：
 
         
[SystemMessage(content="你是一个 AI 开发工程师，你的名字是小谷AI。"),
 
         
HumanMessage(content="你能帮我做什么？"),
 
         
AIMessage(content="我能开发很多AI应用。"),
 
         
HumanMessage(content="你好")]
 
        

 
format_messages 返回的是消息对象列表，可以直接传给模型的 invoke 方法。
 

在聊天机器人中，用户会连续说很多句话。你不可能在模板里写死 10 个 HumanMessage 占位符。MessagesPlaceholder 就像一个"插槽"，你可以在运行时把整个对话历史塞进去。

 
      
    
        
 
         
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder 
 
         
定义一个模板，预留一个位置给历史消息
 
         
template = ChatPromptTemplate.from_messages([
 
         
("system", "你是一个友好的助手。"), MessagesPlaceholder(variable_name="history"), # 历史消息放在这里 ("human", "{input}"), 
 
         
])
 
         
运行时，把历史消息列表传进去
 
         
prompt = template.format_messages(
 
         
history=[ ("human", "你好！"), ("ai", "你好！有什么可以帮你的？"), ("human", "我想学 Python"), ("ai", "太好了，Python 很容易上手。"), ], input="从哪里开始学？" 
 
         
)
 
        

 
为什么不能用普通变量 {history}？
 

如果直接写 {history}，传入列表时会被转换成字符串，变成类似 "[('human', '你好'), ...]" 的乱码，模型无法理解。MessagesPlaceholder 会保持消息的结构，让模型正确识别每条消息的角色。

把 Prompt 写在代码里，改的时候需要重新部署。更好的做法是把 Prompt 单独存成 JSON 或 YAML 文件，代码只负责加载。这样产品经理或运营人员也可以直接修改提示词。

JSON 文件示例（prompts/prompt.json）：

 
      
    
        
 
         
{ "_type": "prompt", "input_variables": ["name", "what"], "template": "请{name}讲一个{what}的故事" 
 
         
}
 
        

 
YAML 文件示例（prompts/prompt.yaml）：
 
      
    
        
 
         
_type: "prompt" 
 
         
input_variables: ["name", "what"] template: "请{name}讲一个{what}的故事"
 
        

 
加载代码：
 
      
    
        
 
         
from langchain_core.prompts import load_prompt 
 
         
加载 JSON 文件
 
         
template = load_prompt("prompts/prompt.json", encoding="utf-8") print(template.format(name="张三", what="搞笑的"))
 
         
加载 YAML 文件
 
         
template = load_prompt("prompts/prompt.yaml", encoding="utf-8") print(template.format(name="年轻人", what="滑稽"))
 
        

大模型返回的是一个字符串，例如："北京今天的天气是晴天，气温25度"。但你的程序可能需要的是这样的数据：

 
      
    
        
 
         
{"city": "北京", "weather": "晴天", "temperature": 25}
 
        
 
如果没有解析器，你就得自己写正则表达式去匹配"天气是"后面跟什么、"气温"后面跟什么，非常麻烦且容易出错。输出解析器自动完成这个转换。
 

模型返回的是一个 AIMessage 对象，它包含 content、additional_kwargs 等字段。很多时候你只需要 content 这个字符串。StrOutputParser 就是帮你提取它。

 
      
    
        
 
         
from langchain_core.output_parsers import StrOutputParser 
 
         
response = llm.invoke("你好") print(type(response)) # 
          
 
         
parser = StrOutputParser() text = parser.invoke(response) print(type(text)) # 
          
            print(text) # "你好！有什么我可以帮忙的吗？" 
            
          
 
        

如果你希望模型返回 JSON 格式的数据（例如在数据提取、结构化输出场景），可以使用 JsonOutputParser。通常需要配合 Pydantic 模型来定义期望的结构，解析器会自动验证。

 
      
    
        
 
         
from pydantic import BaseModel, Field 
 
         
from langchain_core.output_parsers import JsonOutputParser from langchain.chat_models import init_chat_model
 
         
1. 定义期望的数据结构
 
         
class Prime(BaseModel):
 
         
prime: list[int] = Field(description="素数列表") count: list[int] = Field(description="小于该素数的素数个数") 
 
         
2. 创建解析器，并获取格式说明指令
 
         
parser = JsonOutputParser(pydantic_object=Prime) format_instructions = parser.get_format_instructions()
 
         
3. 把格式说明放进系统提示词中
 
         
llm = init_chat_model(…) messages = [
 
         
{"role": "system", "content": format_instructions}, {"role": "user", "content": "生成5个1000到之间的素数，并标出小于每个素数的素数个数"}, 
 
         
]
 
         
response = llm.invoke(messages)
 
         
4. 解析响应
 
         
result = parser.invoke(response) print(result)
 
         
输出类似：
 
         
{‘prime’: [1009, 2003, 3001, 4001, 5003], ‘count’: [168, 303, 430, 584, 669]}
 
        

 
注意：get_format_instructions() 会生成一段很长的指令文本（例如 "The output should be formatted as a JSON instance..."）。你必须把它放在系统消息或用户消息中，否则模型不知道应该输出 JSON。
 

with_structured_output 是比 OutputParser 更高级的方法。两者的区别：

• OutputParser

  ：模型先以自由文本回答，然后你在外部用解析器处理。模型可能会在 JSON 前后加一些解释文字，导致解析失败。

• with_structured_output

  ：在调用时就告诉模型"你必须用这个格式回答"，模型直接按格式生成，不会有多余文字。可靠性更高。

from typing import TypedDict, Annotated from langchain.chat_models import init_chat_model class Animal(TypedDict): animal: Annotated[str, "动物名称"] emoji: Annotated[str, "对应表情"] class AnimalList(TypedDict): animals: Annotated[list[Animal], "动物列表"] llm = init_chat_model(...) structured_llm = llm.with_structured_output(AnimalList) result = structured_llm.invoke("生成三种动物和它们的表情符号") print(result) # {'animals': [{'animal': '猫', 'emoji': '🐱'}, {'animal': '狗', 'emoji': '🐶'}, {'animal': '熊猫', 'emoji': '🐼'}]}

TypedDict 只提供类型提示，不进行运行时验证。如果模型返回的数据类型不对，不会报错。

Pydantic 会自动校验字段类型，如果模型返回的数据不符合定义，会抛出异常。同时可以通过 Field(description=...) 给字段添加描述，帮助模型理解每个字段的含义。

 
       
    
         
 
          
from pydantic import BaseModel, Field 
 
          
class Animal(BaseModel):
 
          
animal: str = Field(description="动物名称") emoji: str = Field(description="动物的表情符号") 
 
          
class AnimalList(BaseModel):
 
          
animals: list[Animal] = Field(description="动物与表情的列表") 
 
          
structured_llm = llm.with_structured_output(AnimalList) result = structured_llm.invoke("生成三种动物和它们的表情符号")
 
          
result 是一个 Pydantic 对象，可以直接用 . 访问属性
 
          
for animal in result.animals:
 
          
print(f"{animal.animal}: {animal.emoji}")
 
         
 
为什么推荐 Pydantic？
 

• 类型安全：字段类型不匹配时会报错。
• 自带验证：可以添加自定义验证器（例如检查字符串长度、数值范围）。
• 字段描述：通过 description 帮助模型更准确地生成内容。
• 嵌套结构：轻松定义复杂的嵌套数据模型。

如果你需要与现有 API 对接，或者对输出格式有极致的控制要求，可以直接传入一个 JSON Schema 字典。设置 include_raw=True 可以同时返回原始响应和解析后的结果，便于调试。

 
       
    
         
 
          
schema = { "type": "array", "items": { "type": "object", "properties": { "animal": {"type": "string", "description": "动物名称"}, "emoji": {"type": "string", "description": "表情符号"}, }, "required": ["animal", "emoji"], }, 
 
          
}
 
          
structured_llm = llm.with_structured_output(schema, include_raw=True) result = structured_llm.invoke("生成三种动物和表情符号")
 
          
print(result["parsed"]) # 解析后的结构化数据 print(result["raw"]) # 模型的原始输出（包含可能的前言后语）
 
         

 
include_raw=True 返回的字典包含以下字段：
 

• parsed：解析成功后的结构化数据
• raw：原始的 AIMessage 对象
• parsing_error：如果解析失败，这里会有错误信息

Model I/O 是 LangChain 中最基础也最重要的模块。掌握它，你就掌握了与大模型对话的标准流程。

三个核心组件回顾：

1. Prompt Template（提示词模板）

• 把固定结构和可变内容分开，提高代码可维护性。
• PromptTemplate：用于简单字符串提示。
• ChatPromptTemplate：用于多角色、多轮对话。
• MessagesPlaceholder：用于动态插入对话历史。
• 可以从外部 JSON/YAML 文件加载，方便非技术人员调整。

2. Model（模型调用）

• init_chat_model 统一了所有在线和本地模型的初始化方式。
• invoke：一次一问，等待完整结果（最常用）。
• stream：逐字输出，适合聊天机器人。
• batch：批量并行处理，适合大量独立请求。
• ainvoke：异步调用，不阻塞主线程。
• Ollama 让你在本地免费、离线、隐私地运行大模型。

3. Output Parser（输出解析）

• StrOutputParser：提取纯文本内容。
• JsonOutputParser：将模型输出解析为字典/列表，常与 Pydantic 配合。
• with_structured_output：更可靠的结构化输出，推荐使用 Pydantic 模型。

一条学习建议：

刚开始学习时，建议先用 invoke + StrOutputParser 跑通最基础的流程，理解输入输出的基本模式。等你对 Prompt 调优有感觉了，再尝试 stream（提升用户体验）和结构化输出（让数据更规范）。Model I/O 玩熟了，LangChain 的大门才算真正打开——后面还有 Chain（链式调用）、RAG（检索增强生成）、Agent（智能体）等更精彩的内容等着你去探索。