一文吃透 LangChain&LangGraph：设计理念、框架结构与内部组件全拆解

在大模型应用开发领域，LangChain 与 LangGraph 已成为构建复杂 AI 系统的双子星框架。LangChain 以组件化思想 提供标准化的 LLM 应用开发抽象，而 LangGraph 则以图结构 + 显式状态管理实现复杂工作流的精准编排。本文将从设计理念、框架结构、核心组件三个维度深度拆解这两个框架，并揭示它们如何协同构建下一代智能 Agent 系统。

一、设计理念：从组件化到图编排的演进

1.1 LangChain：可组合的 LLM 应用抽象层

LangChain 的核心设计理念是 **"面向 LLM 应用的可组合抽象层"**，旨在解决大模型开发中的三大痛点：

模型碎片化：提供统一接口兼容 OpenAI、Anthropic、Google 等主流 LLM，实现 "一键切换"
流程复杂化：通过标准化组件封装重复工作，让开发者专注业务逻辑而非底层实现
能力局限化：通过工具集成与检索增强 (Retrieval Augmented Generation) 突破模型原生能力边界

其设计遵循四大原则：

模块化：将 LLM 应用拆分为 Model I/O、Retrieval、Chains、Memory、Agents 等独立模块
可组合性：通过 LCEL (LangChain Expression Language) 实现组件间的 "管道式" 连接
无厂商锁定：核心抽象层与具体实现分离，支持自由替换模型与工具
生产级扩展：通过 LangSmith 实现调试、监控与评估，确保应用可运维

1.2 LangGraph：有状态图结构的智能编排引擎

LangGraph 的设计理念是 **"状态图驱动的复杂工作流编排"**，填补了 LangChain 在复杂流程控制上的空白：

显式状态管理：维护中央状态对象，所有节点共享访问，解决 LangChain 隐式状态传递的混乱问题
图结构灵活性：用有向图替代线性链条，天然支持循环、分支、并行等复杂逻辑
持久化执行：通过 Checkpointer 实现状态快照与恢复，支持断点续跑与长期运行任务
人机协作增强：内置 Human-in-the-Loop 支持，可在关键节点插入人工审核与干预

1.3 二者关系：互补而非替代

维度	LangChain	LangGraph
核心定位	LLM 应用开发工具箱，提供组件与抽象	智能体运行时，提供图编排与状态管理
状态管理	隐式传递，依赖 Memory 组件	显式中央状态，全局共享访问
流程控制	线性为主，支持有限分支	图结构，支持任意复杂度流程
适用场景	快速原型、简单 RAG、单轮工具调用	复杂 Agent、多智能体协作、长流程任务
依赖关系	可独立使用，生态丰富	可独立使用，与 LangChain 无缝集成

关键结论：LangChain 是构建 AI 应用的 "骨架"，LangGraph 是赋予其复杂行为的 "肌肉"，LangSmith 则是提供洞察的 "神经系统"。在 LangChain 1.0 架构中，LangGraph 已成为 Agent 的默认运行时，实现了从 "链" 到 "图" 的底层升级。

二、LangChain 框架结构：分层设计与核心模块

2.1 四层架构体系

LangChain 采用清晰的分层架构，各层职责明确且可独立使用：

text 复制代码

应用层：基于LangGraph的Agent编排、状态管理、工作流
组件层：langchain包（Chains、Agents、Retrieval等）
集成层：langchain-community包（第三方模型、工具、向量库）
核心层：langchain-core包（基础抽象、LCEL、Runnable接口）

2.1.1 核心层 (langchain-core)：框架基石

提供最基础的抽象接口与运行时能力，是 LangChain 生态的 "协议层"：

Runnable 接口 ：统一所有组件的调用范式，支持invoke()、batch()、stream()等操作
LCEL：LangChain 表达式语言，实现组件的声明式组合，支持链式调用、分支、并行等操作
Base 抽象类：定义 LLM、Embeddings、Retriever、Tool 等核心组件的标准接口
Message 类型：统一对话消息格式，支持 HumanMessage、AIMessage、ToolMessage 等
序列化协议：支持组件与状态的序列化，便于持久化与跨进程通信

2.1.2 集成层 (langchain-community)：生态扩展

提供第三方服务的集成实现，目前已支持：

模型集成：OpenAI、Anthropic、Google Gemini、Cohere 等 20 + 主流 LLM
工具集成：搜索引擎、数据库、API、文件系统等 100 + 工具
向量库集成：Pinecone、Chroma、FAISS、Milvus 等 30 + 向量存储
文档加载器：PDF、Word、Markdown、网页等 50 + 数据源

2.1.3 组件层 (langchain)：应用构建模块

封装常见的 LLM 应用模式，提供开箱即用的组件：

Model I/O：模型调用、提示词模板、输出解析的完整流程
Retrieval：文档加载、分割、嵌入、检索的端到端解决方案
Chains：预定义的组件组合，如 LLMChain、RetrievalQAChain 等
Memory：对话历史管理，支持多种记忆策略
Agents：基于 LLM 的决策系统，支持工具调用与自主规划

2.1.4 应用层 (LangGraph)：复杂流程编排

基于图结构的智能体运行时，提供生产级能力：

状态图管理：定义节点、边与状态转换规则
持久化执行：支持断点续跑与长期运行任务
流式输出：实时返回部分结果，提升用户体验
人机协作：在关键节点插入人工审核与干预

2.2 六大核心模块详解

2.2.1 Model I/O：模型输入输出管理

负责 LLM 的输入构建、调用与输出解析，是连接应用与模型的桥梁：

组件	作用	核心实现
LLMs/LLM	基础语言模型接口	OpenAI、Anthropic、HuggingFace 等
ChatModels	对话模型接口	ChatOpenAI、ChatAnthropic 等
Embeddings	文本嵌入生成	OpenAIEmbeddings、HuggingFaceEmbeddings 等
Prompts	提示词模板管理	PromptTemplate、ChatPromptTemplate 等
OutputParsers	输出结构化解析	PydanticOutputParser、RegexParser 等

核心能力：通过提示词模板实现动态内容注入，通过输出解析将 LLM 的自然语言输出转换为结构化数据，降低应用开发复杂度。

2.2.2 Retrieval：检索增强能力

解决 LLM"知识过期" 与 "事实性错误" 问题，是构建知识库应用的核心模块：

文档加载：从多种数据源获取文档，支持 PDF、Word、网页等
文档分割：将长文档拆分为适合模型处理的小块，如 RecursiveCharacterTextSplitter
嵌入生成：将文本块转换为向量表示
向量存储：存储向量并支持相似度搜索
检索器：封装检索逻辑，提供统一查询接口，如 VectorDBRetriever、BM25Retriever

典型应用：构建企业知识库、智能问答系统、文档摘要工具等，通过 "检索 - 生成" 流程提升回答准确性。

2.2.3 Chains：组件组合与流程封装

将多个组件按特定逻辑组合，形成可复用的工作流，避免重复编码：

基础链：LLMChain (LLM+Prompt)、SimpleSequentialChain (线性执行多个链)
复合链：SequentialChain (带多输入输出的线性链)、RouterChain (动态路由到不同链)
专用链：RetrievalQAChain (检索 + 生成问答)、ConversationalRetrievalChain (带记忆的检索问答)

核心优势：通过 LCEL 实现声明式组合，支持链式调用、分支、并行等复杂逻辑，如：

ini 复制代码

chain = prompt | llm | output_parser

2.2.4 Memory：对话状态管理

实现多轮对话中的上下文保持，解决 LLM"无记忆" 问题：

记忆类型	适用场景	核心实现
短期记忆	单轮对话、简单上下文	ConversationBufferMemory、ConversationSummaryMemory
长期记忆	多轮对话、复杂上下文	VectorStoreRetrieverMemory、EntityMemory
实体记忆	需要追踪特定实体信息	EntityMemory、KnowledgeGraphMemory

关键特性：记忆组件会自动将对话历史注入提示词，或通过检索获取相关上下文，确保模型了解对话背景。

2.2.5 Agents：自主决策与工具调用

赋予 LLM 自主决策能力，使其能够根据任务需求选择合适工具并执行，是构建智能体的核心模块：

Agent 类型：
1. Action Agent：基于 ReAct 等框架，通过 "思考 - 行动 - 观察" 循环完成任务
2. Plan-and-Execute Agent：先规划任务步骤，再逐一执行
3. OpenAI Functions Agent：利用 OpenAI 函数调用能力，简化工具调用流程
核心组件：
1. AgentExecutor：负责运行 Agent 的主循环
2. Tool：工具接口，封装外部能力
3. Toolkit：相关工具的集合，如 PythonREPLToolkit、SearchToolkit
LangChain 1.0 新特性：
1. 统一的create_agent抽象，简化 Agent 创建流程
2. 基于 LangGraph 的默认运行时，支持更复杂的决策流程
3. Middleware 机制，支持人审、会话总结、PII 脱敏等功能

2.2.6 Callbacks：事件监听与扩展

提供应用执行过程中的钩子机制，支持日志记录、监控、调试等功能：

内置回调：LLMCallbackHandler、ChainCallbackHandler、AgentCallbackHandler 等
自定义回调：继承 BaseCallbackHandler 实现特定逻辑，如性能统计、错误监控
异步支持：支持异步环境下的回调处理，不阻塞主线程

典型应用：集成 LangSmith 进行调试与评估，或自定义日志系统记录关键信息。

三、LangGraph 框架结构：图结构与状态管理核心

3.1 四大核心概念

LangGraph 的设计围绕四个核心概念展开，它们共同构成了复杂工作流的基础：

3.1.1 State (状态)：全局共享的数据结构

定义：表示应用程序的当前快照，通常是 TypedDict 或 Pydantic BaseModel
特性：所有节点共享访问，可读取和更新，状态变更驱动流程推进

示例：

python 复制代码

   from typing import TypedDict, List
   from langchain_core.messages import BaseMessage

   class AgentState(TypedDict):
       messages: List[BaseMessage]  # 对话历史
       intermediate_steps: List[tuple]  # 工具调用记录
       final_answer: str  # 最终答案

3.1.2 Nodes (节点)：执行单元

定义：编码代理逻辑的 Python 函数，接收当前 State 作为输入，执行计算或副作用，返回新的状态片段
类型：
- 函数节点：封装普通 Python 函数，执行具体操作
- LLM 节点：调用大语言模型，完成语义理解、推理等任务
- 工具节点：调用外部工具，获取实时信息或执行操作
- 子图节点：嵌套其他图结构，实现模块化复用

示例：

arduino 复制代码

 def llm_node(state: AgentState):
     messages = state["messages"]
     response = llm.invoke(messages)
     return {"messages": messages + [response]}
 ```

3.1.3 Edges (边)：状态转移路径

定义：连接节点的有向连接，定义执行顺序与路由规则
类型：
- 普通边 ：直接从一个节点到下一个节点，如add_edge("node_a", "node_b")
- 条件边 ：根据状态动态选择下一节点，如add_conditional_edges("source", routing_func)
- 入口点 ：图的起始节点，如set_entry_point("start_node")
- 出口点 ：图的终止节点，如set_finish_point("end_node")

3.1.4 Checkpointer (检查点)：状态持久化

定义：负责保存和恢复图的状态，支持断点续跑与长期运行任务
实现：InMemorySaver (内存存储)、SqliteSaver (本地数据库)、RedisSaver (分布式存储) 等
核心价值：解决 LLM 应用 "运行中断" 问题，支持长时间运行的任务，如多轮对话、复杂数据分析

3.2 图结构与流程控制

LangGraph 的核心优势在于其灵活的流程控制能力，支持多种复杂逻辑：

3.2.1 条件分支

根据当前状态动态选择执行路径，实现 "智能路由"：

python 复制代码

def should_continue(state: AgentState):
    messages = state["messages"]
    last_message = messages[-1]
    if "FINAL ANSWER" in last_message.content:
        return "end"
    return "continue"

workflow.add_conditional_edges(
    source="llm_node",
    path=should_continue,
    path_map={
        "continue": "tool_node",
        "end": "final_answer_node"
    }
)

3.2.2 循环迭代

支持节点间的循环调用，实现 "反复优化" 或 "多轮处理" 逻辑：

python 复制代码

# 实现"思考-行动-观察"循环
workflow.add_edge("llm_node", "should_continue")
workflow.add_conditional_edges(
    source="should_continue",
    path=lambda state: "tool_node" if state["needs_tool"] else "end",
    path_map={"tool_node": "tool_node", "end": "end"}
)
workflow.add_edge("tool_node", "llm_node")

3.2.3 并行执行

支持多个节点同时执行，提升任务处理效率：

python 复制代码

# 并行调用多个工具
workflow.add_parallel_edges(
    source="start",
    targets=["tool1", "tool2", "tool3"]
)
# 等待所有并行节点完成
workflow.add_edge("tool1", "join")
workflow.add_edge("tool2", "join")
workflow.add_edge("tool3", "join")

3.2.4 子图嵌套

将复杂图结构拆分为多个子图，实现模块化设计与复用：

python 复制代码

# 创建子图
subgraph = StateGraph(SubGraphState)
subgraph.add_node("sub_node1", sub_node1_func)
subgraph.add_node("sub_node2", sub_node2_func)
subgraph.add_edge("sub_node1", "sub_node2")
subgraph.set_entry_point("sub_node1")
subgraph.set_finish_point("sub_node2")

# 在主图中使用子图
main_graph.add_node("subgraph", subgraph.compile())

3.3 与 LangChain 的无缝集成

LangGraph 与 LangChain 共享核心抽象，可无缝集成使用：

组件复用：LangChain 的 LLM、工具、提示词模板等组件可直接作为 LangGraph 的节点使用
Agent 迁移：LangChain 1.0 的 Agent 默认基于 LangGraph 实现，可直接使用图的状态管理与流程控制能力
记忆增强：LangGraph 的显式状态可与 LangChain 的 Memory 组件结合，实现更灵活的上下文管理
工具调用：LangChain 的 Tool 接口可直接在 LangGraph 的工具节点中使用，无需额外适配

四、实战案例：构建基于 LangChain+LangGraph 的智能问答 Agent

下面通过一个完整案例展示如何结合 LangChain 与 LangGraph 构建复杂智能体系统：

4.1 系统架构设计

我们将构建一个具备以下能力的智能问答 Agent：

接收用户问题
判断是否需要调用工具 (搜索、计算器等)
执行工具调用获取外部信息
整合信息生成最终答案
支持多轮对话与上下文保持

4.2 代码实现

python 复制代码

from typing import TypedDict, List
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.tools import DuckDuckGoSearchRun, PythonREPLTool
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import InMemorySaver

# 1. 定义状态结构
class AgentState(TypedDict):
    messages: List[BaseMessage]  # 对话历史
    intermediate_steps: List[tuple]  # 工具调用记录

# 2. 初始化组件
llm = ChatOpenAI(model="gpt-4o", temperature=0)
search = DuckDuckGoSearchRun()
python_repl = PythonREPLTool()
tools = [search, python_repl]

# 3. 定义节点函数
def llm_node(state: AgentState):
    """调用LLM生成响应"""
    messages = state["messages"]
    # 绑定工具到LLM
    llm_with_tools = llm.bind_tools(tools)
    response = llm_with_tools.invoke(messages)
    return {"messages": messages + [response]}

def tool_node(state: AgentState):
    """执行工具调用"""
    messages = state["messages"]
    last_message = messages[-1]
    tool_calls = last_message.tool_calls
    tool_outputs = []
    
    for tool_call in tool_calls:
        tool_name = tool_call["name"]
        tool_input = tool_call["args"]
        # 查找对应的工具
        tool = next(t for t in tools if t.name == tool_name)
        output = tool.run(tool_input)
        tool_outputs.append(ToolMessage(
            content=output,
            tool_call_id=tool_call["id"],
            name=tool_name
        ))
    
    return {
        "messages": messages + tool_outputs,
        "intermediate_steps": state["intermediate_steps"] + [(tool_calls, tool_outputs)]
    }

def should_continue(state: AgentState):
    """判断是否需要继续执行工具调用"""
    messages = state["messages"]
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tool"
    return "end"

# 4. 构建图结构
workflow = StateGraph(AgentState)
workflow.add_node("llm", llm_node)
workflow.add_node("tool", tool_node)
workflow.set_entry_point("llm")
workflow.add_conditional_edges(
    source="llm",
    path=should_continue,
    path_map={
        "tool": "tool",
        "end": END
    }
)
workflow.add_edge("tool", "llm")

# 5. 配置检查点(支持记忆)
checkpointer = InMemorySaver()
app = workflow.compile(checkpointer=checkpointer)

# 6. 运行Agent
def run_agent(user_input: str, thread_id: str = "default"):
    initial_state = {
        "messages": [HumanMessage(content=user_input)],
        "intermediate_steps": []
    }
    result = app.invoke(initial_state, config={"configurable": {"thread_id": thread_id}})
    return result["messages"][-1].content

# 测试
print(run_agent("2026年世界杯冠军是谁？需要搜索最新信息"))
print(run_agent("他们在决赛中以多少比分获胜？", thread_id="default"))

4.3 核心亮点解析

显式状态管理：通过 AgentState 清晰定义系统状态，包含对话历史与工具调用记录
图结构流程：使用条件边实现 "LLM→判断→工具→LLM" 的循环，完美契合 ReAct 框架
持久化执行：通过 InMemorySaver 保存状态，支持多轮对话的上下文保持
无缝集成：直接复用 LangChain 的 LLM、工具与消息类型，降低开发成本

五、总结

LangChain 与 LangGraph 的组合代表了大模型应用开发的主流方向：LangChain 提供标准化组件解决 "构建什么" 的问题，LangGraph 提供图编排能力解决 "如何构建复杂流程" 的问题。随着 LangChain 1.0 的发布，这两个框架的整合更加紧密，为开发者提供了从快速原型到生产级部署的完整解决方案。

未来发展趋势：

多智能体协作：LangGraph 将进一步增强多智能体编排能力，支持智能体间的通信与协作
更强大的状态管理：引入更复杂的状态更新机制，支持事务与回滚操作
低代码可视化：提供图形化界面，让非技术人员也能设计复杂的智能体流程
深度集成 LangSmith：实现开发、调试、监控、评估的全流程闭环

对于开发者而言，掌握 LangChain 与 LangGraph 的核心思想与使用方法，将大幅提升构建复杂 AI 系统的效率与质量，为企业数字化转型注入强大动力。