LangGraph 与 LangChain：关系与定位

概述

LangGraph 和 LangChain 都属于 LangChain 生态系统，但它们的定位和使用场景有明显区别。本文档详细阐述两者的关系、差异和选择建议。

---

一、核心定位

LangGraph：底层编排框架

LangGraph 是非常底层 的框架，完全专注于代理编排（Agent Orchestration）。

特点：

• 🔧 提供基础构建块，而非完整解决方案
• 🎯 完全控制工作流的每个细节
• 🏗️ 需要手动定义节点、边和状态

类比：

LangGraph = 建筑材料和工具（需要自己搭建）

LangChain Agents：高级抽象框架

LangChain Agents 提供预构建的架构，为常见的 LLM 和工具调用循环提供开箱即用的解决方案。

特点：

• 🚀 快速上手，几行代码即可创建代理
• 📦 预构建的标准代理模式（ReAct、OpenAI Functions 等）
• 🎁 开箱即用的解决方案

类比：

LangChain Agents = 预制房屋（拎包入住）

---

二、代码示例对比

LangChain Agents（高级抽象）

import { createReactAgent } from 'langchain/agents';

// 3 行代码创建一个代理
const agent = await createReactAgent({
  llm,
  tools,
  prompt,
});

// ✓ 简单快速
// ✗ 定制化有限

LangGraph（底层控制）

import { StateGraph } from '@langchain/langgraph';

// 需要手动定义每个节点和边
const workflow = new StateGraph(stateSchema)
  .addNode('analyze', analyzeFunction)
  .addNode('retrieve', retrieveFunction)
  .addNode('decide', decideFunction)
  .addConditionalEdges('decide', shouldContinue)
  .addEdge('analyze', 'retrieve')
  .addEdge('retrieve', 'decide')
  .compile();

// ✓ 完全控制
// ✗ 需要更多代码

---

三、代理编排（Agent Orchestration）

什么是代理编排？

管理多个步骤、决策和工具调用的复杂流程。

典型的代理流程

用户问题
  ↓
[规划] 分解任务
  ↓
[执行步骤 1] 调用工具 A
  ↓
[评估] 是否需要更多信息？
  ├─ 是 → [执行步骤 2] 调用工具 B
  └─ 否 → [生成] 返回最终答案

LangGraph 的优势： 让你可以精确控制每一步的逻辑和状态。

---

四、LangGraph 的核心能力

1. 持久化执行（Durable Execution）

解决的问题： 长时间运行的代理可能中断，需要保存和恢复状态。

// 保存状态到数据库
const checkpointer = new PostgresSaver(connectionString);

const app = workflow.compile({ checkpointer });

// 执行可以暂停和恢复
const result = await app.invoke(input, {
  configurable: { thread_id: 'user-123' },
});

// 如果中断，可以从检查点恢复
const resumed = await app.invoke(null, {
  configurable: { thread_id: 'user-123' },
});

应用场景：

• 长时间运行的任务
• 需要跨会话保持状态
• 防止意外中断导致进度丢失

---

2. 流式处理（Streaming）

实时输出每个步骤的结果

for await (const chunk of await app.stream(input, {
  streamMode: 'updates',
})) {
  console.log('当前步骤:', chunk);
  // 实时显示进度给用户
}

应用场景：

• 提升用户体验（显示进度）
• 调试和监控
• 实时 UI 更新

---

3. 人机协同（Human-in-the-Loop）

在关键决策点暂停，等待人类输入

const workflow = new StateGraph(State)
  .addNode('analyze', analyzeNode)
  .addNode('human_approval', humanApprovalNode) // 人工审批节点
  .addNode('execute', executeNode)
  .addEdge('analyze', 'human_approval')
  .addEdge('human_approval', 'execute')
  .compile();

// 执行会在 human_approval 节点暂停
const state = await app.invoke(input);

// 人工审批后继续
const finalState = await app.invoke({
  ...state,
  approved: true, // 人类的输入
});

应用场景：

• 敏感操作需要人工确认（如删除数据）
• 不确定的决策需要人类判断
• 质量控制和审核流程

---

4. 复杂的状态管理

const AgentState = Annotation.Root({
  messages: Annotation<Message[]>({
    reducer: (current, update) => current.concat(update),
  }),
  documents: Annotation<Document[]>,
  currentStep: Annotation<string>,
  retryCount: Annotation<number>,
  metadata: Annotation<Record<string, any>>,
});

能力：

• 细粒度控制状态如何更新
• 支持复杂的状态合并逻辑
• 跨节点共享状态

---

5. 条件分支和循环

workflow
  .addConditionalEdges('decide', state => {
    if (state.confidence > 0.9) return 'finish';
    if (state.retryCount < 3) return 'retry';
    return 'human_review';
  })
  .addEdge('retry', 'analyze'); // 循环回去

能力：

• 动态决定下一步
• 实现循环和重试逻辑
• 根据状态灵活路由

---

五、使用建议

选择 LangChain Agents 如果：

• ✅ 刚开始学习代理
• ✅ 需要快速原型
• ✅ 使用标准的代理模式（如 ReAct、OpenAI Functions）
• ✅ 不需要复杂的自定义流程

示例：

import { createOpenAIFunctionsAgent } from 'langchain/agents';

// 标准代理，几行代码搞定
const agent = await createOpenAIFunctionsAgent({
  llm,
  tools: [searchTool, calculatorTool],
  prompt,
});

---

选择 LangGraph 如果：

• ✅ 需要完全自定义工作流
• ✅ 需要复杂的条件分支
• ✅ 需要人机协同（human-in-the-loop）
• ✅ 需要持久化和恢复执行
• ✅ 需要精细的状态管理

示例：

import { StateGraph } from '@langchain/langgraph';

// 完全自定义的复杂流程
const workflow = new StateGraph(AgentState)
  .addNode('researcher', researchNode)
  .addNode('analyst', analysisNode)
  .addNode('human_review', humanReviewNode)
  .addConditionalEdges('analyst', state => {
    if (state.confidence < 0.8) return 'human_review';
    return 'finish';
  })
  .compile();

---

六、使用场景对比表

场景	推荐框架	原因
简单的问答机器人	LangChain Agents	标准模式即可
带工具调用的助手	LangChain Agents	预构建架构
多步骤研究助手	LangGraph	需要自定义流程
需要人工审批的自动化	LangGraph	Human-in-the-loop
长时间运行的工作流	LangGraph	持久化执行
复杂的多代理协作	LangGraph	完全控制编排
快速原型验证	LangChain Agents	快速上手
生产级复杂系统	LangGraph	灵活性和可靠性

---

七、关系与独立性

关系图示

┌─────────────────────────────────────┐
│         LangChain 生态系统           │
├─────────────────────────────────────┤
│                                     │
│  基础组件（Models, Tools, etc）      │
│         ↑              ↑            │
│         │              │            │
│  ┌──────┴────┐   ┌────┴─────┐      │
│  │ LangChain │   │ LangGraph│      │
│  │  Agents   │   │          │      │
│  │           │   │          │      │
│  │ (高级抽象) │   │ (底层控制)│      │
│  │ 预构建架构 │   │ 自定义编排 │      │
│  └───────────┘   └──────────┘      │
│                                     │
└─────────────────────────────────────┘

独立性说明

• LangGraph 可以独立使用：不依赖 LangChain
• 文档中常用 LangChain 组件：为了方便集成模型和工具
• 灵活组合：可以混合使用两者的优势

---

八、学习路径

推荐学习顺序

1. 学习基础组件
   ├─ Models（LLM 的基本使用）
   ├─ Tools（定义和调用工具）
   └─ Prompts（提示工程）

2. 尝试 LangChain Agents
   ├─ 快速上手
   ├─ 理解标准模式
   └─ 探索预构建架构

3. 识别限制和需求
   ├─ 评估现有方案是否满足需求
   └─ 识别需要自定义的场景

4. 学习 LangGraph
   ├─ 状态管理
   ├─ 图的构建
   ├─ 复杂编排
   └─ 企业级特性

为什么这个顺序？

• 基础组件是构建代理的基石
• LangChain Agents 让你快速理解代理的工作方式
• 识别限制帮助你判断是否需要 LangGraph
• LangGraph 在理解基础后更容易掌握

---

九、实际案例对比

案例 1：简单问答机器人

需求： 回答用户问题，可以调用搜索和计算器工具

推荐： LangChain Agents

import { createReactAgent } from 'langchain/agents';

const agent = await createReactAgent({
  llm: new ChatOpenAI(),
  tools: [searchTool, calculatorTool],
  prompt: 'You are a helpful assistant',
});

const result = await agent.invoke({
  input: 'What is the weather in Beijing?',
});

原因： 标准的 ReAct 模式完全满足需求，无需复杂定制。

---

案例 2：多步骤研究助手

需求：

1. 分析用户问题
2. 制定研究计划
3. 执行多个搜索
4. 综合信息
5. 生成报告
6. 需要人工审核

推荐： LangGraph

import { StateGraph } from '@langchain/langgraph';

const ResearchState = Annotation.Root({
  question: Annotation<string>,
  plan: Annotation<string[]>,
  searches: Annotation<SearchResult[]>,
  report: Annotation<string>,
  approved: Annotation<boolean>,
});

const workflow = new StateGraph(ResearchState)
  .addNode('analyze', analyzeQuestion)
  .addNode('plan', createResearchPlan)
  .addNode('search', executeSearches)
  .addNode('synthesize', synthesizeInfo)
  .addNode('human_review', humanReview)
  .addNode('generate_report', generateReport)
  .addEdge('analyze', 'plan')
  .addEdge('plan', 'search')
  .addEdge('search', 'synthesize')
  .addEdge('synthesize', 'human_review')
  .addConditionalEdges('human_review', state => {
    return state.approved ? 'generate_report' : 'search';
  })
  .compile();

原因： 需要复杂的多步骤流程、人工审核和条件分支，LangGraph 提供更好的控制。

---

十、关键概念总结

LangGraph 的核心特点

特点	说明
底层	提供构建块而非完整解决方案
灵活	完全控制代理的执行流程
强大	持久化、流式、人机协同等企业级功能
独立	可以独立使用，不依赖 LangChain
专注	专注于代理编排的底层能力

LangChain Agents 的核心特点

特点	说明
高级	提供预构建的完整解决方案
快速	几行代码即可创建代理
标准	实现常见的代理模式
易用	适合初学者和快速原型
集成	深度集成 LangChain 生态

---

十一、最佳实践

1. 从简单开始

• 先使用 LangChain Agents 验证想法
• 确认需求后再考虑 LangGraph

2. 渐进式迁移

// 阶段 1: LangChain Agent
const simpleAgent = createReactAgent({...});

// 阶段 2: 发现限制，部分使用 LangGraph
const hybridWorkflow = new StateGraph(...)
  .addNode("agent", () => simpleAgent.invoke(...))
  .addNode("custom_logic", customFunction)
  ...

// 阶段 3: 完全迁移到 LangGraph
const fullCustomWorkflow = new StateGraph(...)
  .addNode(...)
  ...

3. 选择合适的抽象层次

• 不要过度工程化：如果 LangChain Agents 够用，就不要用 LangGraph
• 不要限制自己：如果需要复杂定制，不要勉强使用 LangChain Agents

4. 利用两者的优势

// 在 LangGraph 中使用 LangChain 组件
import { ChatOpenAI } from "langchain/chat_models/openai";
import { DuckDuckGoSearch } from "langchain/tools";
import { StateGraph } from "@langchain/langgraph";

// LangChain 提供模型和工具
const llm = new ChatOpenAI();
const searchTool = new DuckDuckGoSearch();

// LangGraph 提供编排
const workflow = new StateGraph(...)
  .addNode("search", async (state) => {
    const result = await searchTool.invoke(state.query);
    return { searchResults: result };
  })
  .addNode("analyze", async (state) => {
    const response = await llm.invoke(state.messages);
    return { analysis: response.content };
  })
  ...

---

十二、常见问题

Q: 我必须使用 LangChain 才能使用 LangGraph 吗？

A: 不需要。LangGraph 可以独立使用，但文档中常用 LangChain 组件是为了方便。你可以使用任何模型和工具。

Q: LangGraph 是 LangChain 的升级版吗？

A: 不是。它们解决不同的问题：

• LangChain Agents：快速构建标准代理
• LangGraph：深度定制复杂工作流

Q: 我应该从哪个开始学习？

A: 建议顺序：

1. 学习基础组件（Models, Tools）
2. 尝试 LangChain Agents（快速上手）
3. 根据需求决定是否学习 LangGraph

Q: 可以同时使用两者吗？

A: 可以！你可以在 LangGraph 的节点中调用 LangChain Agents，或使用 LangChain 的组件。

---

十三、总结

核心要点

1. LangGraph = 底层 + 灵活 + 强大

   • 完全控制工作流
   • 企业级功能（持久化、流式、人机协同）
   • 需要更多代码

2. LangChain Agents = 高级 + 快速 + 易用

   • 预构建架构
   • 快速原型
   • 标准模式

3. 选择依据

   • 简单场景 → LangChain Agents
   • 复杂定制 → LangGraph
   • 不确定 → 先用 LangChain Agents

4. 学习路径

   • 基础组件 → LangChain Agents → LangGraph

5. 可以组合使用

   • 利用两者的优势
   • 渐进式迁移

---

参考资源

• LangChain 官方文档
• LangGraph 官方文档
• LangChain Agents 指南
• LangGraph 教程