01_LangGraph是什么？

本节课将用大白话解释LangGraph是什么，为什么需要它。通过生活场景类比，让你理解LangGraph的核心概念：图、节点、边、状态。学完本课，你将知道LangGraph能解决什么问题，以及它与传统编程的区别。

---

🎯 学习目标

学完本节课，你将能够：

1. 用自己的话解释什么是LangGraph
2. 理解为什么需要LangGraph来开发AI应用
3. 掌握LangGraph的核心概念（图、节点、边、状态）
4. 知道LangGraph适合什么样的应用场景

---

1. LangGraph是什么？（大白话版）

1.1 从一个问题开始

假设你要开发一个智能客服系统，需求是这样的：

1. 用户发来消息
2. AI判断用户的意图（咨询问题？投诉？退款？）
3. 根据不同意图，执行不同操作：
   • 如果是咨询 → 查询知识库 → 回答
   • 如果是投诉 → 记录问题 → 转人工
   • 如果是退款 → 检查订单 → 处理退款 → 发送确认

用传统方式写代码，你可能会写一堆 if-else：

def handle_message(user_message: str) -> str:
    # 调用AI判断意图
    intent = get_intent(user_message)
    
    if intent == "咨询":
        knowledge = search_knowledge(user_message)
        answer = generate_answer(knowledge)
        return answer
    elif intent == "投诉":
        log_complaint(user_message)
        return "已转人工客服"
    elif intent == "退款":
        order = check_order(user_message)
        if order.can_refund:
            process_refund(order)
            return "退款成功"
        else:
            return "该订单不支持退款"
    else:
        return "抱歉，我没理解您的意思"

这种方式有什么问题？

1. 流程写死了：增加新功能要改代码
2. 难以调试：出错了不知道卡在哪一步
3. 无法重试：如果某一步失败，整个流程就挂了
4. 没有记忆：多轮对话需要自己管理上下文
5. 代码混乱：业务逻辑和流程控制混在一起

1.2 LangGraph的解决方案

LangGraph = 工作流引擎 + AI能力

把上面的场景想象成一个流程图：

[用户输入] → [意图识别] → [路由决策]
                              ↓
                    ┌─────────┼─────────┐
                    ↓         ↓         ↓
                [咨询流程] [投诉流程] [退款流程]
                    ↓         ↓         ↓
                    └─────────┼─────────┘
                              ↓
                          [返回结果]

LangGraph让你能够：

1. 把流程画成图：每个方块是一个”节点”，箭头是”边”
2. 节点之间传递数据：通过”状态”
3. 灵活控制流转：可以跳转、循环、重试
4. 可视化调试：能看到流程走到哪一步
5. 内置AI能力：轻松集成大模型

用LangGraph的方式写，代码变成这样：

from langgraph.graph import StateGraph
from typing import TypedDict

# 定义状态（流程中传递的数据）
class State(TypedDict):
    user_message: str
    intent: str
    result: str

# 定义节点（每个处理步骤）
def intent_node(state: State) -> State:
    """识别用户意图"""
    state["intent"] = get_intent(state["user_message"])
    return state

def consult_node(state: State) -> State:
    """处理咨询"""
    knowledge = search_knowledge(state["user_message"])
    state["result"] = generate_answer(knowledge)
    return state

def complaint_node(state: State) -> State:
    """处理投诉"""
    log_complaint(state["user_message"])
    state["result"] = "已转人工客服"
    return state

# 定义路由（根据意图决定走哪条路）
def route_by_intent(state: State) -> str:
    """根据意图路由到不同节点"""
    intent_map = {
        "咨询": "consult",
        "投诉": "complaint",
        "退款": "refund"
    }
    return intent_map.get(state["intent"], "end")

# 构建图
graph = StateGraph(State)
graph.add_node("intent", intent_node)
graph.add_node("consult", consult_node)
graph.add_node("complaint", complaint_node)
graph.add_node("refund", refund_node)

# 设置流程
graph.set_entry_point("intent")
graph.add_conditional_edges("intent", route_by_intent)
graph.add_edge("consult", "end")
graph.add_edge("complaint", "end")
graph.add_edge("refund", "end")

# 运行
app = graph.compile()
result = app.invoke({"user_message": "我要退款"})

看起来代码变多了？但好处是：

• ✅ 流程清晰：能一眼看出整个流程
• ✅ 易于扩展：加新功能只需加新节点
• ✅ 容易调试：能看到每一步的状态
• ✅ 支持重试：某一步失败可以重来
• ✅ 有记忆：状态自动在节点间传递

---

2. 核心概念详解

2.1 图（Graph）

类比： 想象你在用流程图设计一个业务流程

• 传统编程：代码从上往下执行，遇到 if 就分叉
• LangGraph：明确定义每个步骤（节点）和流转路径（边）

graph = StateGraph(State)  # 创建一个图

2.2 节点（Node）

类比： 流程图中的每个方框

节点就是一个函数，负责：

1. 接收当前状态
2. 执行某个任务
3. 更新状态并返回

def my_node(state: State) -> State:
    """节点的标准格式"""
    # 1. 从state中读取数据
    input_data = state["some_key"]
    
    # 2. 执行任务
    result = do_something(input_data)
    
    # 3. 更新state
    state["result"] = result
    
    # 4. 返回state
    return state

# 添加节点到图中
graph.add_node("my_node_name", my_node)

重要提示：

• 节点名称（字符串）和函数是分开的
• 一个节点就是一个功能单元，尽量保持单一职责

2.3 边（Edge）

类比： 流程图中的箭头

边定义了节点之间的流转关系：

普通边（固定流转）

# A节点执行完，一定会到B节点
graph.add_edge("node_a", "node_b")

条件边（根据条件选择下一步）

def router(state: State) -> str:
    """返回下一个节点的名称"""
    if state["score"] > 80:
        return "good_node"
    else:
        return "bad_node"

graph.add_conditional_edges("check_node", router)

特殊边

# 设置入口：从哪个节点开始
graph.set_entry_point("start_node")

# 设置出口：到END就结束
graph.add_edge("final_node", END)

2.4 状态（State）

类比： 想象一个快递包裹，在流水线上传递

状态是一个字典（或TypedDict），在节点之间传递数据：

from typing import TypedDict

class State(TypedDict):
    # 定义状态包含哪些字段
    user_input: str      # 用户输入
    intent: str          # 识别出的意图
    context: list        # 对话历史
    result: str          # 最终结果
    error: str           # 错误信息

状态的特点：

1. 每个节点都能读取和修改状态
2. 状态会自动传递到下一个节点
3. 可以用TypedDict定义字段类型（强烈推荐）

状态更新示例：

def node1(state: State) -> State:
    state["intent"] = "查询"
    return state

def node2(state: State) -> State:
    # 可以读取node1设置的intent
    print(state["intent"])  # 输出：查询
    state["result"] = "处理完成"
    return state

---

3. 为什么需要LangGraph？

3.1 对比传统方式

维度	传统if-else	LangGraph
流程清晰度	混乱，难以理解	清晰，像流程图
可维护性	改一处动全身	模块化，易扩展
错误处理	需要自己try-catch	内置重试机制
调试	打断点看变量	可视化流程，看状态变化
多轮对话	自己管理上下文	状态自动传递
并行执行	需要多线程	内置支持
AI集成	自己调API	原生支持LLM

3.2 LangGraph的优势

✅ 1. 复杂流程变简单

场景： 审批流程

• 提交申请 → 部门审批 → 财务审核 → 总经理审批 → 发放款项
• 任何一步不通过 → 退回修改 → 重新审批

用LangGraph，每个审批环节是一个节点，退回重审只需加一条边。

✅ 2. AI能力开箱即用

from langchain_openai import ChatOpenAI

# 轻松集成大模型
llm = ChatOpenAI(model="gpt-4")

def ai_node(state: State) -> State:
    response = llm.invoke(state["user_input"])
    state["ai_response"] = response.content
    return state

✅ 3. 自动处理多轮对话

传统方式需要自己维护对话历史，LangGraph的状态自动传递：

class State(TypedDict):
    messages: list  # 对话历史自动累积

def chat_node(state: State) -> State:
    # messages已经包含了之前的对话
    response = llm.invoke(state["messages"])
    state["messages"].append(response)
    return state

✅ 4. 支持复杂控制流

• 循环：可以让流程回到之前的节点
• 并行：多个节点同时执行
• 条件分支：根据结果选择不同路径
• 子图：把一个复杂流程封装成子图

✅ 5. 可视化和调试

LangGraph可以导出流程图，还能记录每一步的状态变化：

# 导出流程图
from IPython.display import Image, display
display(Image(app.get_graph().draw_mermaid_png()))

# 查看执行过程
for step in app.stream({"user_input": "你好"}):
    print(f"当前节点: {step}")
    print(f"当前状态: {step}")

---

4. LangGraph适合什么场景？

✅ 适合的场景

1. 多步骤AI工作流

   • 例如：写作助手（构思 → 列提纲 → 写初稿 → 润色 → 生成标题）

2. 需要决策和分支的任务

   • 例如：智能客服（判断意图 → 分流处理）

3. 需要工具调用的Agent

   • 例如：数据分析助手（理解需求 → 查询数据 → 生成图表 → 解读结果）

4. 需要人工审核的流程

   • 例如：内容审核（AI初审 → 人工复审 → 发布）

5. 需要重试和容错的任务

   • 例如：SQL生成（生成SQL → 验证 → 如果错误重新生成）

❌ 不适合的场景

1. 简单的一问一答

   • 直接调用LLM API就够了，不需要LangGraph

2. 没有复杂流程的任务

   • 比如简单的文本分类，用LangChain就够了

3. 纯计算任务

   • 不涉及AI或复杂流程控制的，直接写Python更简单

---

5. 生活场景类比

类比1：餐厅点餐流程

想象你去一家智能餐厅：

[顾客] → [迎宾（入口节点）]
           ↓
       [点餐（节点1）]
           ↓
       [确认订单（节点2）]
           ↓
    [判断是否有过敏信息]
       ↙         ↘
   [特殊处理]   [正常流程]
       ↓         ↓
    [开始制作（节点3）]
           ↓
       [上菜（节点4）]
           ↓
       [结账（END）]

• 节点：每个服务环节（迎宾、点餐、制作、上菜）
• 边：服务的流转（点完餐 → 开始制作）
• 状态：订单信息（点了什么菜、有无过敏、桌号等）
• 条件边：如果有过敏 → 特殊处理，否则 → 正常流程

类比2：快递配送

[寄件] → [揽收] → [分拣中心] → [运输中] 
    ↓
[判断地址]
    ↙    ↘
[本地]  [外地]
    ↓    ↓
[派送] [转运]
    ↓    ↓
  [签收（END）]

• 节点：每个物流环节
• 状态：包裹信息（地址、重量、状态）
• 条件边：根据地址决定本地派送还是转运

类比3：体检流程

[登记] → [抽血] → [X光] → [心电图]
    ↓
[医生诊断]
    ↓
[判断结果]
    ↙    ↘
[正常]  [异常]
    ↓    ↓
[打印报告] [建议复查]
    ↓        ↓
  [END]   [预约复查]

---

6. LangGraph vs LangChain

你可能听说过LangChain，那它和LangGraph有什么区别？

LangChain

• 定位：组件库
• 功能：提供各种AI组件（LLM、提示词模板、向量数据库等）
• 适合：快速调用LLM，构建简单的AI功能

LangGraph

• 定位：流程编排框架
• 功能：构建复杂的多步骤AI工作流
• 适合：需要复杂流程控制的AI应用

关系： LangGraph基于LangChain构建，可以一起使用：

• LangChain提供组件（LLM、工具等）
• LangGraph编排流程（怎么调用这些组件）

---

7. 小结

核心要点

1. LangGraph是什么？

   • 一个用于构建AI工作流的框架
   • 让你能把AI应用的流程画成图

2. 核心概念

   • 图（Graph）：整个工作流
   • 节点（Node）：每个处理步骤（函数）
   • 边（Edge）：流程流转关系（箭头）
   • 状态（State）：节点间传递的数据（字典）

3. 为什么用LangGraph？

   • 流程清晰，易于理解
   • 模块化，易于扩展
   • 内置AI能力，开箱即用
   • 支持复杂流程控制（循环、分支、并行）
   • 便于调试和可视化

4. 适合什么场景？

   • 多步骤的AI工作流
   • 需要决策和分支的任务
   • 需要调用外部工具的Agent
   • 需要重试和容错的流程

思考题

在开始下一节课之前，想一想：

1. 你的工作中，有哪些场景可以用LangGraph来实现？
2. 这些场景有哪些步骤？步骤之间如何流转？
3. 每个步骤需要什么输入，产生什么输出？

---

📚 下一步

现在你已经理解了LangGraph的基本概念，准备好写第一行代码了吗？

下一课： Lesson 02: 第一个LangGraph应用

我们将：

• 配置开发环境
• 使用通义千问API
• 写一个最简单的Hello World程序
• 理解每一行代码的作用

---

📖 参考资料

• LangGraph官方文档
• LangChain官方文档
• 什么是有向无环图（DAG）