LangChain 全面介绍：大模型应用开发框架，从"手搓 API"到"搭积木"

如果你还在用 requests.post() 一行一行地调大模型，那你一定感受过那种"代码越写越散、越写越难维护"的绝望。LangChain 就是来救场的——它把大模型应用开发变成了搭乐高，你只需要关心"把哪块积木拼到哪"，而不是"怎么造这块积木"。本文带你从零认识这个框架，一文讲透它的核心思想和全家桶组件。

---

一、先来个灵魂拷问：没有 LangChain 的日子长什么样？

不妨回忆一下，你平时是怎么调大模型的：

import requests
import json

# 每次都要手写这套"八股文"
headers = {
    "Authorization": "Bearer sk-xxxxxxxxxxxxx",
    "Content-Type": "application/json"
}

data = {
    "model": "gpt-4",
    "messages": [
        {"role": "system", "content": "你是一个有用的助手"},
        {"role": "user", "content": "帮我写一首诗"}
    ]
}

resp = requests.post(
    "https://api.openai.com/v1/chat/completions",
    headers=headers,
    json=data
)
print(resp.json()["choices"][0]["message"]["content"])

这还只是"问一句话"。当你开始做点正经事的时候，麻烦就来了：

你想做的事	裸调 API 有多痛苦
换个模型（比如从 OpenAI 换到通义千问）	请求格式完全不一样，代码几乎重写
做个提示词模板，支持变量替换	字符串手拼，改一处漏一处
让模型记住上一轮对话	自己维护消息列表，还得处理超长截断
读取 PDF / 网页 / 数据库	解析、清洗、分割，全部自己写
做一个多步推理任务	没有"流水线"概念，全靠 if-else 硬串

这些痛点，正是 LangChain 存在的理由。

---

二、LangChain 到底是个啥？

LangChain 是一个开源的、用于构建大语言模型（LLM）应用的标准开发框架，同时提供 Python 和 JavaScript/TypeScript 双语言支持。

它由 Harrison Chase 于 2022 年 10 月创建，一经推出就迅速成为 LLM 应用开发领域的事实标准。截至目前，GitHub 上已经积累了超过 10 万 Star。

但 LangChain 自己并不开发大模型——它不跟 OpenAI 抢生意，也不跟 Anthropic 卷模型。它的核心使命就一句话：

“把大模型相关的各种组件，封装成统一的、可复用的、可拼接的标准接口，让开发者像搭积木一样构建复杂应用。”

想理解这个框架，你只需要记住三个关键词：

• 组件化：模型调用、提示词模板、记忆、文档加载器……每种能力都是一个独立组件
• 可组合：组件之间用管道符 | 拼接，数据像水流一样从上游流到下游
• 统一接口：不管底层是 OpenAI 还是通义千问还是本地 Ollama，上层调用方式一模一样

---

三、一张图看懂 LangChain 全家桶

LangChain 的组件生态非常丰富，但梳理清楚后其实很清晰：

┌─────────────────────────────────────────────────────────┐
│                    LangChain 全家桶                        │
├───────────────┬───────────────────┬─────────────────────┤
│   核心组件     │     数据层        │      智能体层        │
├───────────────┼───────────────────┼─────────────────────┤
│ Models        │ Document Loaders │ Agents              │
│ (模型调用)    │ (文档加载器)      │ (智能体)            │
│               │                   │                     │
│ Prompts       │ Text Splitters   │ Tools               │
│ (提示词模板)  │ (文本分割器)      │ (工具)              │
│               │                   │                     │
│ Chains        │ Vector Stores    │ Middleware           │
│ (链/流水线)   │ (向量存储)        │ (中间件)            │
│               │                   │                     │
│ Memory        │ Embeddings       │ Callbacks           │
│ (记忆系统)    │ (嵌入模型)        │ (回调系统)          │
│               │                   │                     │
│ Output Parsers│ Retrievers       │                     │
│ (输出解析器)  │ (检索器)          │                     │
└───────────────┴───────────────────┴─────────────────────┘

下面逐个认识一下这些"积木块"：

3.1 Models（模型）—— 统一大模型调用入口

LangChain 把"调模型"这件事抽象成一个统一接口，不管你背后是 OpenAI GPT-4、Anthropic Claude、阿里通义千问、百度文心一言，还是本地 Ollama 跑的 Llama，上层代码写法完全一样：

from langchain_openai import ChatOpenAI

# 换模型？只需要改这一行，其他代码纹丝不动
llm = ChatOpenAI(
    model="qwen-plus",                              # 通义千问
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="your-api-key"
)

response = llm.invoke("你好，介绍一下你自己")
print(response.content)

3.2 Prompts（提示词模板）—— 告别字符串硬拼

用模板来管理提示词，把"可变部分"抽成变量，模板本身干干净净：

from langchain.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ("system", "你是一位{role}，擅长{skill}。"),
    ("user", "请帮我{task}"),
])

# 填入变量，生成最终提示词
prompt = template.format_messages(
    role="资深Python工程师",
    skill="代码审查",
    task="review这段代码的性能问题"
)

3.3 Chains（链）—— 把组件串成流水线

这是 LangChain 的灵魂。用管道符 | 把多个组件串起来，数据自动流转：

from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# 定义模板
prompt = ChatPromptTemplate.from_template("给一个关于{topic}的冷笑话")

# 定义模型
llm = ChatOpenAI(model="gpt-4o-mini")

# 用管道符串成链
chain = prompt | llm | StrOutputParser()

# 一行调用
print(chain.invoke({"topic": "程序员"}))
# 输出："为什么程序员分不清万圣节和圣诞节？因为 Oct 31 == Dec 25"

这套用 | 拼接的语法，就是 LangChain 的杀手锏——LCEL（LangChain Expression Language）。

3.4 Memory（记忆）—— 让模型"记住"上一轮对话

大模型本身是无状态的——每次调用都是"初次见面"。Memory 组件帮你在多次对话之间保留上下文：

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context(
    {"input": "我叫张三"},
    {"output": "你好张三！"}
)
memory.save_context(
    {"input": "我喜欢吃火锅"},
    {"output": "火锅确实很棒！"}
)

# 加载记忆
print(memory.load_memory_variables({}))
# {'history': 'Human: 我叫张三\nAI: 你好张三！\nHuman: 我喜欢吃火锅\nAI: 火锅确实很棒！'}

3.5 Document Loaders（文档加载器）—— 喂数据给大模型

支持 CSV、JSON、PDF、TXT、网页、数据库……几乎所有你能想到的数据源：

from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader

# 加载 PDF
pdf_loader = PyPDFLoader("报告.pdf")
docs = pdf_loader.load()

# 加载网页
web_loader = WebBaseLoader("https://example.com/article")
docs = web_loader.load()

3.6 Vector Stores（向量存储）—— 知识库的"记忆宫殿"

把文档转成向量存起来，检索时按语义相似度匹配——这就是 RAG（检索增强生成）的核心：

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# 创建向量存储
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings()
)

# 语义检索
results = vectorstore.similarity_search("人工智能的发展趋势", k=3)

3.7 Agents（智能体）—— 让模型自己"思考+行动"

这是 LangChain 最强大的能力。Agent 不是被动地一问一答，而是自己决定调用什么工具、按什么顺序、怎么组合来完成一个复杂任务：

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

# 定义工具
def search_web(query: str) -> str:
    """搜索互联网获取最新信息"""
    # ... 搜索逻辑
    return f"搜索结果：{query}..."

def calculate(expression: str) -> str:
    """执行数学计算"""
    return str(eval(expression))

# 创建 Agent
agent = create_agent(
    model="gpt-4o",
    tools=[search_web, calculate],
    system_prompt="你是一个全能的助手，能用工具解决问题。"
)

# Agent 自己决定先搜还是先算
result = agent.invoke({
    "messages": [{"role": "user", "content": "2024年全球AI市场规模是多少？如果增长35%，2025年是多少？"}]
})

---

四、LCEL：LangChain 的"通用语言"

LCEL（LangChain Expression Language）是 LangChain 官方推荐的标准写法，从 0.3 版本开始成为主流。

4.1 什么是 LCEL？

一句话：用管道符 | 把组件串起来。左边的输出自动变成右边的输入，就像 Unix 管道一样：

# 没有 LCEL 的旧写法（已过时，不推荐）
from langchain.chains import LLMChain
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(topic="AI")

# LCEL 新写法（推荐）
chain = prompt | llm | StrOutputParser()
result = chain.invoke({"topic": "AI"})

4.2 LCEL 的四大超能力

超能力	说明
异步支持	chain.ainvoke() 异步调用，不阻塞主线程
批处理	chain.batch([...]) 一次处理多条数据
流式输出	chain.stream() 一个字一个字地往外蹦，像 ChatGPT 打字效果
自动重试	调用失败自动重试，省去手写 try-except 的麻烦

4.3 一个 LCEL 实战示例

from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# 第一步：翻译成英文
translate_prompt = ChatPromptTemplate.from_template(
    "将以下中文翻译成英文：{text}"
)

# 第二步：对英文结果做摘要
summary_prompt = ChatPromptTemplate.from_template(
    "用一句话概括以下英文内容：{english_text}"
)

llm = ChatOpenAI(model="gpt-4o-mini")

# 两条链各自独立，可复用
translate_chain = translate_prompt | llm | StrOutputParser()
summary_chain = summary_prompt | llm | StrOutputParser()

# 组合使用
text = "LangChain 是一个强大的大模型应用开发框架"
english = translate_chain.invoke({"text": text})
summary = summary_chain.invoke({"english_text": english})

print(f"原文：{text}")
print(f"翻译：{english}")
print(f"摘要：{summary}")

---

五、LangChain 1.0：2025 年的重大里程碑

2025 年，LangChain 正式发布了 1.0 版本，这是一次重大升级，核心变化有三个：

5.1 create_agent —— 全新的 Agent 创建方式

旧的 create_react_agent 已经成为历史，新的 create_agent 统一了 Agent 创建入口：

from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[search_web, analyze_data, send_email],
    system_prompt="你是一个专业的研究助手"
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "调研 AI 安全的最新趋势"}]
})

5.2 Middleware（中间件）—— 给 Agent 装上"拦截器"

这是一个革命性的设计。中间件可以在 Agent 的每个关键节点插入自定义逻辑，像"管道过滤器"一样：

from langchain.agents import create_agent
from langchain.agents.middleware import (
    PIIMiddleware,              # 敏感信息过滤
    SummarizationMiddleware,    # 长对话自动摘要
    HumanInTheLoopMiddleware    # 关键操作人工确认
)

agent = create_agent(
    model="gpt-4o",
    tools=[read_email, send_email],
    middleware=[
        PIIMiddleware("email", strategy="redact"),       # 自动脱敏邮箱
        SummarizationMiddleware(trigger={"tokens": 500}), # 超过500 token自动摘要
        HumanInTheLoopMiddleware(                         # 发邮件前必须人工确认
            interrupt_on={"send_email": {
                "allowed_decisions": ["approve", "edit", "reject"]
            }}
        ),
    ]
)

中间件的意义：你不用再把这些"横切关注点"散落在业务代码里，而是统一挂载到 Agent 上，干净、可复用、可测试。

5.3 与 LangGraph 深度整合

LangChain 1.0 与 LangGraph（LangChain 生态中的"有状态工作流引擎"）无缝配合：

• LangChain：负责定义"组件"和"链"
• LangGraph：负责编排"复杂多步骤流程"（带条件分支、循环、状态管理）

两者搭配，你既能用 LangChain 快速搭建简单链路，又能用 LangGraph 构建复杂的 Agent 工作流。

---

六、LangChain 生态全景

LangChain 不是一个孤立的框架，它有一个完整的生态家族：

                    ┌──────────────┐
                    │  LangChain   │  ← 核心框架（组件 + 链 + Agent）
                    └──────┬───────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
┌───────▼──────┐  ┌───────▼──────┐  ┌───────▼──────┐
│  LangGraph   │  │  LangSmith   │  │  LangServe   │
│  工作流引擎   │  │  调试+监控   │  │  API 部署     │
└──────────────┘  └──────────────┘  └──────────────┘
        │
┌───────▼──────┐
│  LangChain   │
│  Community   │  ← 社区集成（几百种第三方工具）
└──────────────┘

成员	定位	一句话解释
LangChain	核心框架	组件、链、Agent 的主体
LangGraph	工作流引擎	编排复杂多步骤流程，支持条件分支和循环
LangSmith	开发运维平台	调试、测试、监控 LLM 应用的"全家桶"
LangServe	部署工具	把 LangChain 链一键部署成 REST API
LangChain Community	社区集成	几百种第三方工具和服务的集成包

---

七、快速上手：5 分钟跑通第一个 LangChain 应用

7.1 安装

pip install langchain langchain-community langchain-openai

7.2 Hello World

from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# 1. 定义提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个幽默风趣的助手，喜欢用比喻解释技术概念。"),
    ("user", "请用一句话解释什么是{concept}"),
])

# 2. 创建模型（这里用通义千问，换成 OpenAI 也只需改一行）
llm = ChatOpenAI(
    model="qwen-plus",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="your-api-key"  # 建议用环境变量
)

# 3. 组装链
chain = prompt | llm | StrOutputParser()

# 4. 运行
result = chain.invoke({"concept": "LangChain"})
print(result)

输出示例：

LangChain 就像是给大模型装了一个"乐高底座"，
你可以把各种功能模块像积木一样拼在一起，
搭出你想要的 AI 应用，而不用每次都从零开始造轮子。

---

八、LangChain 适合谁？不适合谁？

✅ 适合你，如果你：

• 需要快速搭建 LLM 应用原型
• 项目里要频繁切换不同模型厂商
• 想做 RAG 知识库、Agent 智能体等复杂应用
• 团队需要统一的 LLM 开发规范

❌ 可能不适合你，如果你：

• 只是偶尔调一次 API，不需要复杂编排
• 对性能和延迟有极致要求（框架层有一定开销）
• 项目非常简单，引入框架反而增加复杂度

一句话：简单场景直接裸调 API，做复杂应用上 LangChain。 框架的价值随项目复杂度指数级增长。

---

九、总结

要点	核心思想
LangChain 是什么	大模型应用开发框架，核心是"组件化 + 可组合"
LCEL	用管道符 `
核心组件	Models、Prompts、Chains、Memory、Loaders、Vector Stores、Agents
1.0 新特性	create_agent 统一入口、Middleware 中间件、LangGraph 深度整合
生态	LangChain + LangGraph + LangSmith + LangServe 四位一体

框架的本质是"把重复的事情标准化，让开发者把精力花在真正创造价值的地方"。 LangChain 做到了这一点——它不帮你写业务逻辑，但它让"跟大模型打交道"这件事，从体力活变成了脑力活。

---

参考资料

• LangChain 官方文档
• LangChain 1.0 发布说明
• LangChain Expression Language (LCEL) 介绍

---