LangChain 系统性科普：从入门到架构设计

一、引言：为什么需要 LangChain？

在 ChatGPT 引爆大语言模型（LLM）应用开发后，开发者很快发现：直接调用 OpenAI 或 Claude 的 API 只能完成最简单的问答任务。一旦涉及多轮对话、外部知识库、工具调用、复杂业务流程编排，纯 API 调用就会让代码迅速膨胀为难以维护的"意大利面条"。

LangChain 正是为解决这一痛点而生的开发框架。它由 Harrison Chase 于 2022 年 10 月创建，迅速成为 Python/TypeScript 生态中最流行的 LLM 应用开发框架之一。其核心定位是：将语言模型与应用程序的其他部分连接起来，构建具备上下文感知能力和推理能力的 AI 应用。

---

二、LangChain 是什么？核心定位解析

2.1 官方定义

LangChain 是一个用于开发由语言模型驱动的应用程序的框架。它本身不提供模型，而是提供编排、连接、管理模型的能力。

2.2 解决的核心问题

痛点	LangChain 的解决方案
提示词管理混乱	结构化 Prompt Template
多轮对话无状态	Memory 组件持久化对话历史
模型输出不可控	Output Parser 结构化解析
无法访问私有数据	Document Loader + RAG 检索增强
复杂任务需多步推理	Agent + Tool 自主决策执行
调用链难以调试	LangSmith 可视化追踪

2.3 与直接调用 API 的区别

# 直接调用 API（简单但脆弱）
import openai
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "讲个笑话"}]
)

# LangChain 方式（模块化、可扩展）
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_template("讲一个关于{topic}的笑话")
chain = prompt | llm  # 使用 LCEL 语法组合
result = chain.invoke({"topic": "程序员"})

---

三、核心架构：六大组件详解

LangChain 的架构围绕六个抽象层展开，理解它们是掌握框架的关键。

3.1 Model I/O（模型交互层）

这是与 LLM 交互的最基础层，包含三个子组件：

Model

支持多种模型后端，统一接口：

• ChatOpenAI / AzureChatOpenAI（OpenAI 系列）
• ChatAnthropic（Claude 系列）
• ChatGoogleGenerativeAI（Gemini）
• Ollama（本地开源模型）
• HuggingFacePipeline（HuggingFace 模型）

Prompt Template

将动态变量注入提示词，避免字符串拼接：

from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate

# 基础模板
template = PromptTemplate.from_template(
    "请将以下文本翻译成{language}：{text}"
)

# 少样本学习模板
examples = [
    {"input": "开心", "output": "happy"},
    {"input": "难过", "output": "sad"}
]
few_shot_prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=PromptTemplate.from_template("输入：{input}\n输出：{output}"),
    prefix="你是一个翻译专家，请将中文翻译成英文：",
    suffix="输入：{input}\n输出：",
    input_variables=["input"]
)

Output Parser

将模型输出的非结构化文本转换为结构化数据：

from langchain_core.output_parsers import JsonOutputParser, PydanticOutputParser
from pydantic import BaseModel, Field

class Joke(BaseModel):
    setup: str = Field(description="笑话铺垫")
    punchline: str = Field(description="包袱")

parser = PydanticOutputParser(pydantic_object=Joke)
prompt = PromptTemplate(
    template="回答用户的请求。\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

3.2 Retrieval（检索层）

解决 LLM 知识截止和幻觉问题的核心机制------RAG（Retrieval-Augmented Generation）。

Document Loaders

从各种数据源加载文档：

• 文件系统：TextLoader, PDFLoader, CSVLoader
• 网络：WebBaseLoader（爬取网页）
• 数据库：SQLDatabaseLoader
• 云存储：S3FileLoader, GoogleDriveLoader

Text Splitters

将长文档切分为适合嵌入的块（Chunk）：

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # 每块最大字符数
    chunk_overlap=200,    # 块间重叠，保持上下文连贯
    separators=["\n\n", "\n", "。", "！", "？"]
)
chunks = text_splitter.split_documents(documents)

Vector Stores & Embeddings

将文本转为向量并存储，实现语义检索：

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 相似度检索
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
docs = retriever.invoke("什么是 LangChain？")

3.3 Chains（链式调用）

Chain 是 LangChain 早期最核心的抽象，表示一系列组件的有序组合。

传统 Chain 写法

from langchain.chains import LLMChain, SimpleSequentialChain

# 单链
chain = LLMChain(llm=llm, prompt=prompt)

# 顺序链（上一个输出作为下一个输入）
overall_chain = SimpleSequentialChain(
    chains=[chain1, chain2],
    verbose=True
)

LCEL（LangChain Expression Language）⭐

这是 LangChain 0.1+ 版本推荐的现代写法，使用管道符 | 组合组件，更加直观、支持流式传输和并行：

from langchain_core.runnables import RunnablePassthrough, RunnableParallel

# 基础管道
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | parser
)

# 并行执行（同时调用多个模型）
parallel_chain = RunnableParallel(
    joke=llm | parser,
    summary=summary_chain,
    keywords=keyword_chain
)

3.4 Memory（记忆层）

LLM 本身无状态，Memory 组件为对话系统提供历史上下文管理。

from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory

# 全量记忆（适合短对话）
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 滑动窗口记忆（只保留最近 K 轮，节省 Token）
memory = ConversationBufferWindowMemory(k=5)

# 向量记忆（通过语义检索相关历史）
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)

Memory 的底层原理 ：在每次调用时，Memory 将历史消息注入 Prompt 的 chat_history 变量中，模型据此生成上下文相关的回复。

3.5 Agents（智能代理）

如果说 Chain 是"固定流程"，Agent 就是"自主决策"。Agent 让 LLM 决定何时、调用何种工具来完成复杂任务。

核心架构：ReAct（Reasoning + Acting）

思考（Thought）→ 行动（Action）→ 观察（Observation）→ 思考...

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool

tools = [
    Tool(
        name="Search",
        func=search_engine.run,
        description="用于搜索实时信息"
    ),
    Tool(
        name="Calculator",
        func=calculator.run,
        description="用于数学计算"
    )
]

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

agent_executor.invoke({
    "input": "2024年诺贝尔物理学奖得主是谁？他今年多少岁？"
})

执行流程解析：

1. LLM 分析任务，输出思考过程（Thought）
2. 决定调用工具（Action）及输入参数
3. 框架执行工具，获取结果（Observation）
4. 将结果反馈给 LLM，继续思考或给出最终答案

3.6 Callbacks（回调系统）

用于日志记录、监控、流式输出等：

from langchain.callbacks import StreamingStdOutCallbackHandler

llm = ChatOpenAI(
    streaming=True,
    callbacks=[StreamingStdOutCallbackHandler()]
)

---

四、进阶架构：从单体到分布式

4.1 RAG 完整架构实战

一个生产级 RAG 系统的完整数据流：

[PDF/网页/数据库] 
    ↓
Document Loader
    ↓
Text Splitter（分块策略优化）
    ↓
Embedding Model（向量化）
    ↓
Vector Store（Chroma/Pinecone/Milvus）
    ↓
Retriever（相似度检索/MMR/多查询）
    ↓
Re-ranker（精排，如 Cohere Rerank）
    ↓
Prompt Engineering（上下文注入）
    ↓
LLM（生成回答）
    ↓
Output Parser（结构化输出）

代码示例：高级 RAG 管道

from langchain.retrievers import MultiQueryRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.retrievers import ContextualCompressionRetriever

# 多查询检索：生成多个查询变体，召回更多相关文档
multi_query_retriever = MultiQueryRetriever.from_llm(
    retriever=base_retriever, llm=llm
)

# 上下文压缩：让 LLM 过滤掉检索文档中的无关内容
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=multi_query_retriever
)

# 最终 RAG 链
rag_chain = (
    {"context": compression_retriever, "question": RunnablePassthrough()}
    | ChatPromptTemplate.from_template("""
        基于以下上下文回答问题。如果上下文不包含答案，请说"我不知道"。
        上下文：{context}
        问题：{question}
        """)
    | llm
    | StrOutputParser()
)

4.2 Agent 的进化：从 ReAct 到 Plan-and-Execute

对于复杂多步骤任务，ReAct 可能效率低下。更高级的 Agent 模式：

模式	特点	适用场景
ReAct	单步思考，逐步执行	简单工具调用
Plan-and-Execute	先制定计划，再逐步执行	复杂任务分解
Self-Ask	自问自答，逐步细化	多跳问答
Corrective RAG	检索质量自检，动态切换策略	高要求 RAG

from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner

planner = load_chat_planner(llm)
executor = load_agent_executor(llm, tools, verbose=True)
agent = PlanAndExecute(planner=planner, executor=executor)

---

五、LangChain 生态系统

LangChain 不仅是框架，更是一个完整的 LLM 应用开发平台。

5.1 LangSmith（可观测性平台）

生产环境调试 LLM 应用的必备工具：

• Tracing：可视化查看每次调用的完整链路（Prompt → LLM → Output → Tool Calls）
• Monitoring：追踪延迟、Token 消耗、错误率
• Testing：批量运行测试集，对比不同 Prompt/模型的效果
• Annotation：人工标注和反馈，持续优化

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls-xxx"

5.2 LangServe（服务化部署）

将 LangChain Chain 快速部署为 REST API：

from langserve import add_routes
from fastapi import FastAPI

app = FastAPI()
add_routes(app, rag_chain, path="/rag")

# 自动生成 API 文档和客户端 SDK
# 访问 /rag/invoke, /rag/stream, /rag/batch

5.3 LangGraph（状态机工作流）

用于构建复杂、有循环逻辑的多 Agent 系统。相比简单 Chain，LangGraph 支持：

• 循环和条件分支：Agent 可以反复思考直到满足条件
• 持久化状态：支持人机协同（Human-in-the-loop）
• 多 Agent 协作：多个 Agent 共享状态，协同完成任务

from langgraph.graph import StateGraph, END

# 定义状态结构
class AgentState:
    messages: list
    next_step: str

# 构建状态机
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_agent)
workflow.add_node("action", call_tool)
workflow.add_conditional_edges("agent", should_continue, {
    "continue": "action",
    "end": END
})
workflow.add_edge("action", "agent")
app = workflow.compile()

---

六、最佳实践与性能优化

6.1 Prompt 工程优化

• 使用 MessagePlaceholder 管理动态历史：避免 Token 爆炸
• System Prompt 固化角色：减少每次重复描述
• Few-shot 示例选择：使用 SemanticSimilarityExampleSelector 动态选择最相关的示例

6.2 检索优化

• 分块策略：根据内容类型选择（代码按函数分、论文按章节分）
• 元数据过滤 ：在向量检索前用 where 条件过滤（如只查某作者论文）
• 混合检索：BM25 关键词 + Dense 向量，兼顾精确匹配和语义理解

6.3 成本控制

• 模型路由：简单任务用 GPT-3.5，复杂任务用 GPT-4
• 缓存 ：使用 LangChainCache 缓存相同查询的结果
• Token 监控：通过 LangSmith 追踪每个组件的 Token 消耗

6.4 常见陷阱

1. 过度依赖 Agent：简单任务用 Chain 更高效，Agent 的多次 LLM 调用成本高
2. 忽略错误处理：Tool 调用可能失败，需设置重试和降级策略
3. Prompt 注入风险：对用户输入做过滤，避免恶意指令覆盖 System Prompt

---

七、总结：LangChain 的学习路径

阶段	目标	重点内容
入门	跑通第一个 Chain	Model I/O、Prompt Template、基础 Chain
进阶	构建 RAG 应用	Document Loader、Splitter、Vector Store、Retriever
熟练	开发 Agent 系统	Tool 定义、ReAct 机制、AgentExecutor
精通	生产级架构	LCEL 高级语法、LangGraph、LangSmith 监控、LangServe 部署

LangChain 的价值不在于"封装 API"，而在于建立 LLM 应用开发的标准抽象和最佳实践。随着多模态模型和 Agent 技术的演进，LangChain 生态系统（特别是 LangGraph）正在成为构建复杂 AI 工作流的事实标准。

对于初学者，建议从 LCEL 语法 入手，理解管道式编程思维；对于架构师，需要深入掌握 Retrieval 策略 和 Agent 设计模式，以构建可靠、可扩展的企业级 LLM 应用。