LangChain / LLM 开发中：invoke() 与 predict() 的区别

文章当中的1400等等协议内容大家不必在意这是我日常会用到的大家主要了解就可以了

作者：吴佳浩

最后更新：2025-11-25

适用版本：LangChain v1.0+

1. 为什么会有 invoke() 和 predict() 两个方法？

在 LangChain / LCEL / OpenAI ChatModel 开发中，你会看到同一个模型居然能同时调用：

1llm.predict(...)
2llm.invoke(...)
3

predict 与 invoke 功能差异巨大，会影响：

Chain 输出
推理（reasoning）
工具调用（tool_calls）
多轮对话结构
Agent 是否正常运行

2. 一句话区别（核心记忆表）

方法	作用	返回类型	是否包含推理（reasoning）	是否支持工具调用	是否适用 Chain/Agent
predict()	获取模型最终输出的文本	str	否	否	否
invoke()	执行完整一次模型/链/agent 调用	dict / Message / JSON	是	是	是

3. 形象理解：两种调用方式的差异

3.1 predict() 工作流程（仅返回文本）

1flowchart LR
2    A[Input Prompt] --> B[predict]
3    B --> C[LLM Output Text]
4    C --> D[Return str]
5

3.2 invoke() 工作流程（返回结构化对象）

1flowchart LR
2    A[Input Dict or Messages] --> B[invoke]
3    B --> C[Run LLM or Chain or Agent]
4    C --> D{需要工具调用?}
5    D -->|是| E[Generate ToolCalls]
6    D -->|否| F[Generate Messages]
7    E --> G[Return Structured Object]
8    F --> G
9    G --> H[包含 reasoning + metadata]
10

4. 代码对比（最清晰的差异）

4.1 predict() 示例（返回纯文本）

1text = llm.predict("Explain GA/T 1400")
2print(text)
3print(type(text))  # <class 'str'>
4

返回示例：

1GA/T 1400 is a video interface standard...
2<class 'str'>
3

返回类型：str

4.2 invoke() 示例（返回结构化对象）

1result = llm.invoke("Explain GA/T 1400")
2print(result)
3print(type(result))  # <class 'langchain_core.messages.ai.AIMessage'>
4

返回示例：

1{
2  "type": "AIMessage",
3  "content": "GA/T 1400 is a video interface standard...",
4  "tool_calls": [
5    {
6      "name": "query_database",
7      "args": {"table": "standards", "query": "GA/T 1400"},
8      "id": "call_abc123"
9    }
10  ],
11  "response_metadata": {
12    "finish_reason": "tool_calls",
13    "model": "gpt-4",
14    "token_usage": {"prompt_tokens": 45, "completion_tokens": 120}
15  },
16  "id": "run-xyz789"
17}
18

返回类型：AIMessage / dict / JSON

5. 为什么实际项目必须使用 invoke()？

predict() 只输出一段文本，信息量不够。

而 invoke() 可以返回：

JSON 结构化数据
多轮 messages 完整历史
tool_calls 工具调用记录
推理链（reasoning）中间步骤
metadata 元数据（token使用、模型版本等）
Chain / Agent 的完整输出结构

6. 实战案例：GA/T 1400 协议解析对比

6.1 使用 predict() - 信息丢失❌

1from langchain_openai import ChatOpenAI
2
3llm = ChatOpenAI(model="gpt-4")
4
5# 使用 predict
6result = llm.predict("将以下 SIP INVITE 转换为 GA/T 1400 XML格式: INVITE sip:34020000001320000001@...")
7
8print(result)
9# 输出：只有一段XML文本字符串，没有解析状态、没有验证结果、没有错误信息
10

问题：

无法知道转换是否成功
没有中间推理步骤
无法追溯错误原因
不能进行后续工具调用

6.2 使用 invoke() - 完整信息✅

1from langchain_openai import ChatOpenAI
2from langchain_core.tools import tool
3
4@tool
5def validate_gat1400_xml(xml_content: str) -> dict:
6    """验证 GA/T 1400 XML 格式是否符合标准"""
7    # 验证逻辑
8    return {"valid": True, "errors": []}
9
10llm_with_tools = ChatOpenAI(model="gpt-4").bind_tools([validate_gat1400_xml])
11
12# 使用 invoke
13result = llm_with_tools.invoke("将以下 SIP INVITE 转换为 GA/T 1400 XML格式: INVITE sip:34020000001320000001@...")
14
15print(result)
16

输出结构：

1{
2  "content": "<?xml version=\"1.0\"?><Query><CmdType>Catalog</CmdType>...</Query>",
3  "tool_calls": [
4    {
5      "name": "validate_gat1400_xml",
6      "args": {"xml_content": "<?xml version=\"1.0\"?>..."},
7      "id": "call_validate_001"
8    }
9  ],
10  "response_metadata": {
11    "finish_reason": "tool_calls",
12    "reasoning": [
13      "1. 解析 SIP INVITE 头部",
14      "2. 提取设备ID 34020000001320000001",
15      "3. 映射到 GA/T 1400 DeviceID 字段",
16      "4. 构建 XML 结构",
17      "5. 调用验证工具"
18    ]
19  }
20}
21

优势：

✅ 可以追溯每一步转换逻辑

✅ 自动调用验证工具

✅ 包含完整的 metadata

✅ 可以集成到 Agent 工作流

7. 场景选择指南（快速决策）

你只要一句聊天文本 → predict()

例如：

聊天机器人一句回复
简单答疑
快速原型验证

1# 适用场景
2response = llm.predict("今天天气怎么样？")
3

你做实际系统开发 → invoke()

例如：

数据格式转换（XML ↔ JSON）
SQL 自动生成
SIP / GA1400 协议处理
多步骤 LCEL Chain
Agent 工具调用
多轮会话管理

1# 适用场景
2result = llm.invoke([
3    {"role": "system", "content": "你是 GA/T 1400 协议专家"},
4    {"role": "user", "content": "解析这条 SIP 消息"}
5])
6

8. 内部结构差异（类图）

8.1 predict() 输出结构（只有文本）

1classDiagram
2    class PredictOutput {
3        +str content
4    }
5

8.2 invoke() 输出结构（包含完整元信息）

1classDiagram
2    class InvokeOutput {
3        +string content
4        +list tool_calls
5        +dict response_metadata
6        +list messages
7        +string reasoning
8        +string id
9        +dict usage_metadata
10    }
11    
12    class ToolCall {
13        +string name
14        +dict args
15        +string id
16    }
17    
18    class ResponseMetadata {
19        +string finish_reason
20        +string model
21        +dict token_usage
22        +list reasoning_steps
23    }
24    
25    InvokeOutput "1" --> "*" ToolCall
26    InvokeOutput "1" --> "1" ResponseMetadata
27

9. predict() 常踩的坑（必须避免）

❌ 1. 在 Agent 中使用 predict()

1# 错误示例
2agent = create_openai_functions_agent(llm, tools, prompt)
3result = agent.predict("查询数据库")  # 工具调用丢失！
4

后果： Agent 无法调用工具，功能完全失效

2. 在 SQL Chain 中用 predict()

1# 错误示例
2sql_chain = create_sql_query_chain(llm, db)
3query = sql_chain.predict("查询销售额前10的产品")  # reasoning 消失
4

后果： 无法追溯 SQL 生成逻辑，调试困难

3. 多轮 messages 被压成一段文本

1# 错误示例
2history = [
3    {"role": "user", "content": "我叫张三"},
4    {"role": "assistant", "content": "你好张三"},
5    {"role": "user", "content": "我叫什么？"}
6]
7response = llm.predict(str(history))  # 上下文彻底丢失
8

后果： 模型看到的是字符串而不是结构化对话

4. LCEL 链式组合报类型错误

1# 错误示例
2chain = prompt | llm.predict | output_parser  # TypeError!
3

后果： predict() 返回 str 无法兼容 LCEL 管道

正确做法：

1# ✅ 正确示例
2chain = prompt | llm.invoke | output_parser  # 完美运行
3

10. 性能对比

维度	predict()	invoke()
执行速度	略快（5-10ms）	标准
内存占用	低	中等
可调试性	差	优秀
生产环境适用性	不推荐	强烈推荐

11. 最终总结（4 句话记住）

predict = 文本
invoke = 对象
聊天用 predict
做项目用 invoke

🔥 我再唠叨一句

在实际的SQL 自动生成、多模型推理、LLM API 开发 中：

100% 都必须使用 invoke()

12. 快速决策流程图

1flowchart TD
2    A[需要调用 LLM] --> B{只要一句回复?}
3    B -->|是| C[predict]
4    B -->|否| D{需要以下任一功能?}
5    D --> E[工具调用]
6    D --> F[推理步骤]
7    D --> G[多轮对话]
8    D --> H[Chain/Agent]
9    E --> I[invoke]
10    F --> I
11    G --> I
12    H --> I
13    C --> J[返回 str]
14    I --> K[返回 AIMessage]
15

附录：完整代码模板

A. predict() 模板（简单聊天）

1from langchain_openai import ChatOpenAI
2
3llm = ChatOpenAI(model="gpt-4")
4response = llm.predict("你好，介绍一下自己")
5print(response)
6

B. invoke() 模板（生产系统）

1from langchain_openai import ChatOpenAI
2from langchain_core.messages import HumanMessage, SystemMessage
3
4llm = ChatOpenAI(model="gpt-4")
5
6messages = [
7    SystemMessage(content="你是 GA/T 1400 协议专家"),
8    HumanMessage(content="解析这条 SIP INVITE 消息")
9]
10
11result = llm.invoke(messages)
12
13# 访问完整结构
14print(f"内容: {result.content}")
15print(f"工具调用: {result.tool_calls}")
16print(f"元数据: {result.response_metadata}")
17

参考资源：

LangChain 官方文档

《LangChain / LLM 开发中：invoke() 与 predict() 的区别》是转载文章，点击查看原文。