本文基于 LangGraph 与 LangChain 官方源码进行分析，深入剖析两者的技术边界、依赖关系与协作模式，为开发者理清 LangChain 生态的架构脉络提供参考。

一、背景

在 LangChain 生态中，LangGraph 与 LangChain 的关系一直是开发者困惑的焦点。两者是什么关系？用 LangChain 还是 LangGraph？能否独立使用？

随着 LangChain v1 的发布，这一问题有了明确的答案。通过源码分析，可以清晰地看到：LangGraph 是底层编排引擎，LangChain v1 是上层应用框架。两者已从早期的"可选组合"演变为"深度融合"的依赖关系。

---

二、LangGraph 定位分析

2.1 官方定义

从 LangGraph 官方 README 可以看到其核心定位：

LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.

关键词：low-level（底层）、orchestration（编排）、stateful（有状态）。

这意味着 LangGraph 的设计目标是提供 Agent 运行的基础设施，而非面向终端开发者的应用层 API。

2.2 核心能力

LangGraph 提供以下核心能力：

能力	说明
状态图（StateGraph）	基于节点和边定义工作流，支持分支、循环、条件跳转
持久化检查点（Checkpoint）	支持状态快照与恢复，实现长时任务和故障恢复
中断与恢复（Interrupt）	支持 Human-in-the-loop 工作流
流式输出（Streaming）	多种流模式：values、updates、messages、custom 等
Channel 机制	节点间状态传递与聚合的底层机制

2.3 模块结构

langgraph-main/libs/
├── langgraph/              # 核心库：StateGraph、Channel、Pregel 引擎
├── prebuilt/               # 预构建组件：create_react_agent、ToolNode
├── checkpoint/             # 检查点抽象
├── checkpoint-postgres/    # PostgreSQL 检查点实现
├── checkpoint-sqlite/      # SQLite 检查点实现
├── sdk-py/                 # Python SDK
└── cli/                    # 命令行工具

值得注意的是，langgraph-prebuilt 包含了 create_react_agent、ToolNode 等预构建组件，这些是面向应用层的封装。

---

三、依赖关系分析

3.1 LangChain v1 对 LangGraph 的依赖

查看 LangChain v1 的 pyproject.toml：

dependencies = [
    "langchain-core>=1.2.7,<2.0.0",
    "langgraph>=1.0.7,<1.1.0",      # 核心依赖
    "pydantic>=2.7.4,<3.0.0",
]

LangChain v1 强制依赖 LangGraph，这意味着安装 langchain 时会自动安装 langgraph。

3.2 LangGraph 对 LangChain 的依赖

查看 LangGraph 的 pyproject.toml：

dependencies = [
    "langchain-core>=0.1",          # 仅依赖 langchain-core
    "langgraph-checkpoint>=2.1.0,<5.0.0",
    "langgraph-sdk>=0.3.0,<0.4.0",
    "langgraph-prebuilt>=1.0.7,<1.1.0",
    ...
]

LangGraph 仅依赖 langchain-core，不依赖 langchain 主包。这意味着 LangGraph 可以独立于 LangChain 使用。

3.3 依赖关系图

                    ┌─────────────────────────────────────┐
                    │         langchain (v1)              │
                    │  - create_agent()                   │
                    │  - Middleware 系统                   │
                    │  - 结构化输出                        │
                    └─────────────────┬───────────────────┘
                                      │ 依赖
                                      ▼
┌─────────────────────────────────────────────────────────────────────┐
│                          langgraph                                   │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────────┐  │
│  │   StateGraph    │  │    Checkpoint   │  │      Prebuilt       │  │
│  │   (状态图)       │  │    (检查点)      │  │  (create_react_agent)│  │
│  └─────────────────┘  └─────────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────┬───────────────────────────┘
                                          │ 依赖
                                          ▼
                    ┌─────────────────────────────────────┐
                    │           langchain-core            │
                    │  - BaseChatModel                    │
                    │  - BaseMessage                      │
                    │  - BaseTool                         │
                    └─────────────────────────────────────┘

---

四、源码层面的融合分析

4.1 LangChain v1 对 LangGraph 的引用

通过 grep 分析 LangChain v1 的 agents 模块，可以看到大量对 LangGraph 的直接引用：

# langchain_v1/langchain/agents/factory.py
from langgraph.constants import END, START
from langgraph.graph.state import StateGraph
from langgraph.prebuilt.tool_node import ToolCallWithContext, ToolNode
from langgraph.types import Command, Send
from langgraph.runtime import Runtime
from langgraph.store.base import BaseStore
from langgraph.types import Checkpointer

这表明 LangChain v1 的 create_agent() 函数本质上是对 LangGraph StateGraph 的封装。

4.2 共享的核心类型

两个项目共享以下核心类型：

类型	来源	说明
StateGraph	langgraph	状态图定义
Runtime	langgraph	运行时上下文
Command	langgraph	控制流命令
interrupt	langgraph	中断机制
Checkpointer	langgraph	检查点接口
ToolNode	langgraph.prebuilt	工具执行节点

4.3 create_agent 与 create_react_agent 的关系

LangGraph 的 langgraph-prebuilt 包提供了 create_react_agent，而 LangChain v1 提供了 create_agent。两者的关系如下：

LangGraph create_react_agent（位于 langgraph.prebuilt）：

• 直接基于 StateGraph 构建
• 提供基础的 ReAct 模式实现
• 面向熟悉 LangGraph 的开发者

LangChain v1 create_agent（位于 langchain.agents）：

• 在 create_react_agent 基础上增加中间件系统
• 提供更高层的抽象（如 response_format、middleware）
• 面向应用开发者

从源码可以看到，LangChain v1 的核心创新在于 Middleware 系统，这是 LangGraph 原生不具备的能力。

---

五、运行时架构

5.1 Runtime 类

LangGraph 定义了 Runtime 类作为运行时上下文的统一抽象：

@dataclass
class Runtime(Generic[ContextT]):
    """运行时上下文，注入到节点和中间件中"""

    context: ContextT       # 静态上下文（如 user_id、db_conn）
    store: BaseStore | None # 持久化存储
    stream_writer: StreamWriter  # 流式输出写入器
    previous: Any           # 上一次执行的返回值

LangChain v1 的中间件系统完全基于这个 Runtime 类进行设计，所有的 before_model、after_model 等钩子都接收 Runtime 作为参数。

5.2 Channel 机制

LangGraph 的 Channel 机制是状态管理的核心。LangChain v1 直接复用了这些 Channel 类型：

# 在 langchain v1 中间件中使用 LangGraph 的 Channel
from langgraph.channels.ephemeral_value import EphemeralValue
from langgraph.channels.untracked_value import UntrackedValue

这些 Channel 用于实现中间件的状态隔离和生命周期管理。

---

六、两种使用方式对比

6.1 直接使用 LangGraph

适用场景：需要完全控制图结构、自定义节点逻辑、非标准工作流。

from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict

class State(TypedDict):
    messages: list

def agent_node(state: State):
    # 自定义逻辑
    return {"messages": state["messages"] + ["response"]}

graph = StateGraph(State)
graph.add_node("agent", agent_node)
graph.add_edge(START, "agent")
graph.add_edge("agent", END)

app = graph.compile()
result = app.invoke({"messages": ["hello"]})

6.2 使用 LangChain v1

适用场景：标准 Agent 模式、需要中间件能力、快速开发。

from langchain.agents import create_agent
from langchain.agents.middleware import ModelRetryMiddleware

agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[ModelRetryMiddleware(max_retries=3)],
)

result = agent.invoke({"messages": [{"role": "user", "content": "hello"}]})

6.3 对比总结

维度	LangGraph	LangChain v1
抽象层级	底层	高层
灵活性	高（完全自定义）	中（标准模式）
开发效率	低（需要理解图结构）	高（开箱即用）
中间件支持	无原生支持	完整中间件系统
学习曲线	陡峭	平缓
适用场景	复杂/非标准工作流	标准 Agent 应用

---

七、架构演进分析

7.1 历史演进

1. 早期阶段：LangChain 和 LangGraph 是两个独立项目，LangGraph 作为可选的编排层
2. 融合阶段：LangChain v1 将 LangGraph 作为核心依赖，create_agent 内部基于 StateGraph 实现
3. 当前状态：形成清晰的分层架构——LangGraph 负责编排，LangChain 负责应用层封装

7.2 设计哲学

这种分层设计体现了明确的职责划分：

• LangGraph：解决"如何编排"的问题——状态管理、检查点、中断恢复等基础设施
• LangChain v1：解决"如何构建"的问题——中间件、结构化输出、工具管理等应用层能力

7.3 官方文档的印证

LangGraph README 中明确指出：

To quickly build agents with LangChain’s create_agent (built on LangGraph), see the LangChain Agents documentation.

这直接表明了两者的定位差异：LangGraph 是基础设施，create_agent 是基于其上构建的快速开发接口。

---

八、开发者选型建议

8.1 使用 LangChain v1 create_agent 的场景

• 构建标准的对话式 Agent
• 需要使用中间件能力（重试、限流、人机协作、摘要等）
• 追求快速开发和开箱即用
• 不需要深度定制工作流程

8.2 直接使用 LangGraph 的场景

• 构建复杂的多 Agent 协作系统
• 需要自定义节点间的状态流转逻辑
• 工作流包含复杂的分支、循环、并行结构
• 需要对编排层有完全控制

8.3 混合使用

两者并非互斥。可以使用 LangChain v1 快速构建主 Agent，同时使用 LangGraph 构建复杂的子图：

from langchain.agents import create_agent
from langgraph.graph import StateGraph

# 使用 LangGraph 构建复杂子图
sub_graph = StateGraph(...)
sub_graph.add_node(...)
compiled_sub_graph = sub_graph.compile()

# 将子图作为工具提供给主 Agent
def complex_workflow_tool(input: str) -> str:
    return compiled_sub_graph.invoke({"input": input})

agent = create_agent(
    model="openai:gpt-4o",
    tools=[complex_workflow_tool],
)

---

九、将 Agent 暴露给前端交互

无论使用 LangChain v1 还是 LangGraph 构建 Agent，最终都需要将其暴露为服务供前端调用。LangGraph 生态提供了完整的部署方案。

9.1 LangGraph Server 架构

LangGraph 提供了一套完整的服务端基础设施：

langgraph-main/libs/
├── cli/        # langgraph-cli：命令行工具，用于启动/部署服务
├── sdk-py/     # langgraph-sdk：Python 客户端 SDK
└── sdk-js/     # JavaScript 客户端 SDK

核心组件：

• LangGraph Server：基于 Starlette 的 HTTP 服务，提供 REST API
• langgraph-cli：命令行工具，用于本地开发和 Docker 部署
• langgraph-sdk：客户端 SDK，支持 Python 和 JavaScript

9.2 使用 langgraph-cli 启动服务

安装

pip install langgraph-cli
# 开发模式（支持热重载）
pip install "langgraph-cli[inmem]"

配置文件 langgraph.json

{
  "dependencies": [
    "langchain",
    "langchain_openai",
    "./my_agent"
  ],
  "graphs": {
    "my_agent": "./my_agent/graph.py:agent"
  },
  "env": ".env"
}

启动开发服务器

# 开发模式（支持热重载）
langgraph dev --port 2024

# Docker 部署模式
langgraph up --port 8123

服务启动后，Agent 会自动暴露为 REST API。

9.3 REST API 结构

LangGraph Server 提供以下核心 API：

端点	方法	说明
/assistants	GET/POST	管理 Assistant（Agent 配置）
/threads	GET/POST	管理对话线程
/threads/{id}/runs	POST	创建运行
/threads/{id}/runs/stream	POST	创建流式运行
/threads/{id}/state	GET/POST	获取/更新线程状态
/store/items	GET/POST	管理持久化存储

9.4 前端集成方式

方式一：使用 langgraph-sdk（推荐）

Python 客户端

from langgraph_sdk import get_client

client = get_client(url="http://localhost:2024")

# 获取 Agent
assistants = await client.assistants.search()
agent = assistants[0]

# 创建对话线程
thread = await client.threads.create()

# 流式调用
input_msg = {"messages": [{"role": "user", "content": "你好"}]}
async for chunk in client.runs.stream(
    thread["thread_id"],
    agent["assistant_id"],
    input=input_msg
):
    print(chunk)

JavaScript 客户端

import { Client } from "@langchain/langgraph-sdk";

const client = new Client({ apiUrl: "http://localhost:2024" });

// 创建线程
const thread = await client.threads.create();

// 流式调用
const stream = client.runs.stream(
    thread.thread_id,
    assistantId,
    { input: { messages: [{ role: "user", content: "你好" }] } }
);

for await (const chunk of stream) {
    console.log(chunk);
}

方式二：直接调用 REST API

// 创建线程
const thread = await fetch("http://localhost:2024/threads", {
    method: "POST",
    headers: { "Content-Type": "application/json" }
}).then(r => r.json());

// 流式调用（SSE）
const eventSource = new EventSource(
    `http://localhost:2024/threads/${thread.thread_id}/runs/stream`
);

eventSource.onmessage = (event) => {
    const data = JSON.parse(event.data);
    console.log(data);
};

方式三：自定义 FastAPI/Starlette 封装

如果需要更大的控制权，可以自行封装：

from fastapi import FastAPI
from langchain.agents import create_agent

app = FastAPI()
agent = create_agent(model="openai:gpt-4o", tools=[...])

@app.post("/chat")
async def chat(message: str, thread_id: str):
    result = agent.invoke(
        {"messages": [{"role": "user", "content": message}]},
        config={"configurable": {"thread_id": thread_id}}
    )
    return result

@app.post("/chat/stream")
async def chat_stream(message: str, thread_id: str):
    from fastapi.responses import StreamingResponse

    async def generate():
        async for chunk in agent.astream(
            {"messages": [{"role": "user", "content": message}]},
            config={"configurable": {"thread_id": thread_id}}
        ):
            yield f"data: {json.dumps(chunk)}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

9.5 Human-in-the-Loop 场景

对于需要人工审批的场景，LangGraph 的 interrupt 机制与前端交互如下：

# 后端：Agent 执行时遇到中断
from langgraph.types import interrupt

def sensitive_action(state):
    # 触发中断，等待人工确认
    decision = interrupt({
        "action": "delete_file",
        "file_path": "/important/data.txt",
        "message": "确认删除此文件？"
    })

    if decision["approved"]:
        # 执行删除
        pass
    return state

// 前端：处理中断
const stream = client.runs.stream(threadId, assistantId, { input });

for await (const chunk of stream) {
    if (chunk.event === "interrupt") {
        // 显示确认对话框
        const approved = await showConfirmDialog(chunk.data);

        // 恢复执行
        await client.runs.stream(threadId, assistantId, {
            command: { resume: { approved } }
        });
    }
}

9.6 部署架构建议

                    ┌─────────────────────────────────────┐
                    │            前端应用                  │
                    │   (React/Vue/小程序等)               │
                    └─────────────────┬───────────────────┘
                                      │ HTTP/WebSocket
                                      ▼
                    ┌─────────────────────────────────────┐
                    │         LangGraph Server            │
                    │   langgraph dev / langgraph up      │
                    │   (REST API + SSE 流式)             │
                    └─────────────────┬───────────────────┘
                                      │
                    ┌─────────────────┼───────────────────┐
                    │                 │                   │
                    ▼                 ▼                   ▼
            ┌───────────┐    ┌───────────────┐    ┌───────────┐
            │ Checkpoint│    │   LLM API     │    │   Store   │
            │ (Postgres)│    │ (OpenAI等)    │    │ (Redis等) │
            └───────────┘    └───────────────┘    └───────────┘

9.7 生产环境部署

对于生产环境，LangGraph 提供以下部署选项：

1. Docker 自托管

   langgraph build -t my-agent:latest
   docker run -p 8123:8123 my-agent:latest
   

2. LangSmith Deployment（托管服务）

   • 官方提供的托管部署平台
   • 内置可观测性、监控、自动扩缩容
   • 支持 LangGraph Studio 可视化调试

3. Kubernetes 部署

   langgraph dockerfile ./Dockerfile
   # 然后使用标准 K8s 部署流程
   

---

十、总结

LangGraph 与 LangChain v1 的关系可以概括为：

1. 分层架构：LangGraph 是底层编排引擎，LangChain v1 是上层应用框架
2. 单向依赖：LangChain v1 依赖 LangGraph，反之则不成立
3. 能力互补：LangGraph 提供灵活性，LangChain v1 提供便捷性
4. 共享核心：两者共享 Runtime、Checkpoint、Channel 等核心抽象
5. 统一部署：无论使用哪种方式构建 Agent，都可以通过 LangGraph Server 暴露服务

对于大多数应用开发者，推荐从 LangChain v1 的 create_agent 入手。当遇到标准模式无法满足的复杂场景时，再深入 LangGraph 进行定制开发。在部署层面，使用 langgraph-cli 和 langgraph-sdk 可以快速将 Agent 暴露为前端可调用的服务。

---

参考资料：

• LangGraph 源码：https://github.com/langchain-ai/langgraph
• LangChain 源码：https://github.com/langchain-ai/langchain