【LangChain】：零基础快速上手，链式执行

Yechiel

422人浏览 · 2026-05-23 20:25:40

Yechiel · 2026-05-23 20:25:40 发布

【本部分知识地图】

环境准备 → 六步流程 → 两个核心概念（Runnable + LCEL）
                              ↓
                    后续所有组件都是 Runnable，
                    后续所有编排都靠 LCEL

【学习目标】

用 LangChain 接入大模型并完成一次对话
理解 Runnable 统一接口——这是整个 LangChain 的基石
理解 LCEL 链式编排——用 | 串联组件
能写出第一条 LangChain 链式调用代码

1.1 为什么需要 LangChain？

大模型（LLM）单独使用时面临这些实际问题：

问题	具体表现
幻觉	简单 Prompt 经常"一本正经地胡说八道"
Prompt 不规范	每个人写法不同，没有统一结构
模型绑定	换模型（OpenAI→DeepSeek）需要大量改代码
输出非结构化	模型返回文本，但程序需要 JSON / 对象
知识陈旧	训练数据有截止日期，无法获取实时信息
无法调工具	模型不能主动查数据库、调 API、做数学计算

LangChain 的应对思路：将 LLM 交互流程拆解为标准化组件，组件都遵循同一套接口，可以自由组合、高效定制。

1.2 环境准备

Python：3.13

核心包（当前阶段只需这两个）：

pip install -U langchain-openai langchain

API Key 配置（以 OpenAI 为例）：
```
export OPENAI_API_KEY="sk-..."
```
为什么放环境变量？API Key 是敏感信息，写在代码中容易泄露。通过环境变量读取，既安全又方便切换。

1.3 六步快速上手流程

步骤 1：申请 API Key 并配置环境变量

platform.openai.com → Settings → API Keys → Create new secret key → 保存到环境变量。

步骤 2：定义大模型

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-5-mini")

这里 model 就是一个 Runnable 实例——记住这个词，后面一切围绕它展开。

步骤 3：定义消息列表

from langchain_core.messages import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="Translate the following from English into Chinese"),
    HumanMessage(content="hi!"),
]

两个关键消息类型：

SystemMessage（系统角色）：放在消息列表最前面，用来设定 AI 的行为、身份、语气。比如"你是翻译助手"。
HumanMessage（用户角色）：代表用户输入。

步骤 4：调用大模型

result = model.invoke(messages)
print(result)

返回的是 AIMessage 对象，包含四个关键字段：

字段	用途	举例
`content`	回复的文本	`"你好!"`
`response_metadata`	响应本身的元信息（模型名、请求 ID、finish_reason…）	用于调试和日志
`usage_metadata`	资源消耗量化信息（input/output/total tokens）	用于成本计算和监控
`additional_kwargs`	附加数据（如 tool_calls 等提供商特定信息）	用于工具调用

辨析：response_metadata 关注"这是谁回复的、怎么回复的"；usage_metadata 关注"花了多少 token/钱"。

步骤 5：输出解析

如果只想要纯文本字符串而不是整个 AIMessage 对象：

from langchain_core.output_parsers import StrOutputParser

parser = StrOutputParser()
print(parser.invoke(result))  # 输出: 你好!

注意：parser 也是一个 Runnable 实例——它也能 .invoke()。

步骤 6：链式执行（LCEL 初体验）

前五步每一步都要手动调 .invoke()，太繁琐。LangChain 提供链式执行——用 |（管道符）把组件串起来，一次调用：

chain = model | parser
result = chain.invoke(messages)
print(result)  # 输出: 你好!

完整代码（你的第一个 LangChain 程序）：

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.output_parsers import StrOutputParser

model = ChatOpenAI(model="gpt-5-mini")
messages = [
    SystemMessage(content="Translate the following from English into Chinese"),
    HumanMessage(content="hi!"),
]
parser = StrOutputParser()
chain = model | parser
result = chain.invoke(messages)
print(result)  # 你好!

1.4 核心概念一：Runnable 接口

这可能是整个 LangChain 最重要的概念

Runnable 是所有 LangChain 组件（语言模型、输出解析器、检索器、LangGraph 图等）遵循的统一接口。它提供了五种标准能力：

能力	方法	说明
Invoke（调用）	`invoke(input, config?)`	单输入 → 单输出
Batch（批处理）	`batch(inputs)`	多输入并行处理
Stream（流式）	`stream(input)`	边生成边返回，逐块产出
Inspect（检查）	获取输入/输出/配置的模式信息
Compose（组合）	`\|` 运算符	多个 Runnable 串联成链

验证：你会发现所有组件都可以用同样的方式调用：

# model 是 Runnable
model = ChatOpenAI(model="gpt-5-mini")
result = model.invoke(messages)        # ✓

# parser 是 Runnable
parser = StrOutputParser()
parser.invoke(result)                  # ✓

# chain 是 Runnable
chain = model | parser
chain.invoke(messages)                 # ✓

核心思想：在 LangChain 中，“一切都是 Runnable，一切都能用同样的方式调用”。

1.5 核心概念二：LCEL（LangChain Expression Language）

LCEL 是 LangChain 的声明式编排语言。通过 | 运算符将两个 Runnable 串联，生成一个新的 RunnableSequence。

三种等价的串联方式

# 方式 1：| 运算符（最常用、最推荐）
chain = model | parser

# 方式 2：显式构造 RunnableSequence
from langchain_core.runnables import RunnableSequence
chain = RunnableSequence(first=model, last=parser)

# 方式 3：.pipe() 方法
chain = model.pipe(parser)

| 和 .pipe() 的概念来自 Unix/Linux 管道：前一个进程的输出 → 后一个进程的输入。LangChain 把同样的思想迁移到了组件编排上。

数据流动示意

输入(messages)  →  model.invoke()  →  AIMessage  →  parser.invoke()  →  "你好!"
                      ↑                                ↑
                   Runnable                         Runnable
                      └────────── | 串联 ──────────────┘
                                  = RunnableSequence（本身也是 Runnable）

关键理解

RunnableSequence 本身也实现了 Runnable 接口，所以：

它也能 .invoke()、.stream()、.batch()
它可以继续被 | 串联到更长的链中
这就是 LangChain 整个组件体系的"统一语言"

【第一部分自查清单】

知识点	能说清楚吗？
LangChain 解决了原生 LLM 的哪些问题？	□
六步流程分别做了什么？	□
Runnable 有哪五种能力？	□
`	` 运算符的本质是什么？
RunnableSequence 为什么也是 Runnable？	□