LangChain 在 2023 年几乎成了 AI 应用开发的代名词。但到了 2026 年，很多人已经从 LangChain 迁移到 LangGraph——因为 LangGraph 更适合构建真正的生产级 Agent。

这两个框架该怎么选？

一、核心定位差异

LangChain：AI 应用开发的工具箱

提供大量现成的"链"（Chain）和组件

快速组合 LLM + 工具 + 数据源

适合快速 MVP 和简单的 RAG 应用

LangGraph：有状态的 Agent 工作流框架

把 Agent 行为建模为有向图（节点 + 边）

支持循环、分支、并行执行

适合复杂的多步 Agent，需要精确控制流程

简单说：LangChain 帮你快速开始，LangGraph 帮你走到生产。

二、代码对比：同一个任务，两种实现

任务：根据用户问题，自动选择搜索或计算工具

#### LangChain 实现（简洁但控制少）

python
from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import tool
@tool
def search(query: str) -> str:
    """搜索互联网获取最新信息"""
    return web_search(query)
@tool
def calculator(expression: str) -> str:
    """计算数学表达式"""
    return eval(expression)
llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, tools=[search, calculator], prompt=...)
executor = AgentExecutor(agent=agent, tools=[search, calculator])
result = executor.invoke({"input": "苹果公司最新股价是多少，乘以 100 是多少？"})

#### LangGraph 实现（复杂但可控）

python
from langgraph.graph import StateGraph, END
from typing import TypedDict, List
class AgentState(TypedDict):
    messages: List[dict]
    tool_calls: List[dict]
    final_answer: str
def call_llm(state: AgentState) -> AgentState:
    """调用 LLM 决策下一步"""
    response = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [response]}
def execute_tools(state: AgentState) -> AgentState:
    """执行工具调用"""
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = tools[tool_call["name"]].invoke(tool_call["args"])
        results.append({"role": "tool", "content": result})
    return {"messages": state["messages"] + results}
def should_continue(state: AgentState) -> str:
    """决定是继续调用工具还是结束"""
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END
构建图
graph = StateGraph(AgentState)
graph.add_node("llm", call_llm)
graph.add_node("tools", execute_tools)
graph.add_edge("tools", "llm")
graph.add_conditional_edges("llm", should_continue)
graph.set_entry_point("llm")
app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "..."}]})

LangGraph 的代码更多，但你对每一步都有完全的控制。

三、什么时候选哪个

选 LangChain 的情况

快速构建 RAG 应用（文档问答）

需要大量现成的集成（数据库、向量存储等）

简单的工具调用（1-2 个工具）

学习和原型阶段

选 LangGraph 的情况

Agent 需要循环（工具失败时重试）

需要并行执行多个子任务

要求精确的错误处理和回滚

多 Agent 协作

生产环境，需要可观测性

2026 年推荐的组合

RAG / 知识库 → LangChain + Chroma/Pinecone

简单 Agent → LangChain LCEL

复杂 Agent → LangGraph

多 Agent 系统 → LangGraph 多图

四、LangGraph 核心概念

状态（State）

python
class MyState(TypedDict):
    messages: List[BaseMessage]  # 对话历史
    next_step: str               # 下一步要做什么
    attempts: int                # 重试次数
    result: Optional[str]        # 最终结果

状态是 LangGraph 最核心的概念——整个 Agent 的执行都围绕状态的变化进行。

条件边（Conditional Edges）

python
def route(state) -> str:
    if state["attempts"] > 3:
        return "give_up"
    elif state["has_tool_calls"]:
        return "execute_tools"
    else:
        return "end"
graph.add_conditional_edges("llm_node", route)

条件边让你可以实现复杂的分支逻辑，比简单的 if-else 更清晰。

五、持久化和断点续传

LangGraph 支持把中间状态存到数据库，允许 Agent 被中断后继续：

python
from langgraph.checkpoint.sqlite import SqliteSaver
把 checkpoint 存到 SQLite
memory = SqliteSaver.from_conn_string("checkpoints.db")
app = graph.compile(checkpointer=memory)
第一次运行
thread = {"configurable": {"thread_id": "task_001"}}
result = app.invoke(input_data, config=thread)
下次继续（从上次中断的地方）
result = app.invoke(None, config=thread)

这对长时间运行的 Agent（如自动化研究、批量处理）非常重要。

---

延伸阅读

AI Agent 提示词工程实战

AutoGen 多智能体教程

AI Agent 工作流自动化