罗罗编程学习记录
本页内容 展开查看

10.9.1 LangChain 与 LangGraph(图编排、状态、检查点)

所属:全栈开发面试题库 / 10 AI 应用开发:LLM 与 Agent / 10.9 Agent 框架与工具链

覆盖范围

  • LangChain 的核心抽象(Chain、Memory、Tool)
  • LangGraph 的图编排模型(节点、边、状态)
  • 状态管理与检查点(checkpointing)
  • LangChain vs LangGraph 的选型
  • 常见设计模式(ReAct、Plan-Execute)
  • 生产环境的注意事项

高频题速览

编号 题目 难度 频率
10.9.1-001 LangChain 的核心抽象是什么? 基础 ★★★★
10.9.1-002 LangGraph 解决了 LangChain 什么问题? 进阶 ★★★★
10.9.1-003 LangGraph 的状态怎么管理? 进阶 ★★★
10.9.1-004 检查点(checkpoint)有什么用? 基础 ★★★
10.9.1-005 LangChain 有哪些常见设计模式? 进阶 ★★★
10.9.1-006 LangChain 生产环境有什么坑? 进阶 ★★★★
10.9.1-007 怎么选 LangChain vs LangGraph? 基础 ★★★
10.9.1-008 LangSmith 是做什么的? 基础 ★★★

10.9.1-001 LangChain 的核心抽象是什么?

频率 ★★★★ | 难度 基础

一句话结论

LangChain 的核心抽象是:Model(LLM/ChatModel)、Prompt(提示模板)、Chain(把多个步骤串起来)、Memory(对话记忆)、Tool(外部工具调用)、Retriever(检索器);通过这些积木组装 LLM 应用。

概念解释

  • Model:统一封装不同 LLM 提供商的接口。
  • Prompt:提示模板,支持变量插入。
  • Chain:把 prompt + model + output parser 串成一个流水线。
  • Memory:管理对话历史,支持滑动窗口、摘要等。
  • Tool:让 LLM 调用外部函数(搜索、数据库、API)。
  • Retriever:从向量库检索相关文档,用于 RAG。

原理流程

  1. 定义 Prompt 模板。
  2. 选择 Model。
  3. 组装 Chain:Prompt → Model → OutputParser。
  4. 加入 Memory 或 Tool。
  5. 调用 Chain 得到结果。

代码 / 示例

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

# 组装一个简单 Chain
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个助手"),
    ("user", "{question}")
])
model = ChatOpenAI(model="gpt-4o")
chain = prompt | model | StrOutputParser()

# 调用
result = chain.invoke({"question": "什么是 RAG"})

常见误区

  • 误区:LangChain 是一个框架必须用它的所有功能;正解:LangChain 是工具库,可以只选需要的组件,甚至只用 Model 和 Prompt。
  • 误区:LangChain 版本稳定;正解:LangChain 迭代很快,API 变化大,升级要注意 breaking changes。

追问

  • Q:LangChain 的 LCEL 是什么? A:LangChain Expression Language,用 | 运算符组装 Chain,类似 Unix 管道,是 LangChain 的核心组合方式。
  • Q:LangChain 支持哪些模型? A:几乎所有主流模型提供商都有集成,OpenAI、Anthropic、本地模型等,通过统一接口调用。

10.9.1-002 LangGraph 解决了 LangChain 什么问题?

频率 ★★★★ | 难度 进阶

一句话结论

LangChain 的 Chain 是线性流水线,难以表达循环、分支、条件判断等复杂逻辑;LangGraph 用有向图编排 Agent 流程,节点是计算步骤,边是控制流,支持循环、分支、并行,适合复杂 Agent。

概念解释

  • LangChain Chain:线性,输入 → 步骤1 → 步骤2 → 输出,难以表达循环和分支。
  • LangGraph:图结构,节点是步骤,边是转移条件,支持循环、条件分支、并行。
  • 状态:图在节点间传递共享状态,类似 Actor 模型。
  • 适用:需要多步推理、工具循环、人在回路的复杂 Agent。

原理流程

  1. 定义状态结构(State)。
  2. 定义节点(Node):每个节点是一个函数,接收状态返回更新。
  3. 定义边(Edge):节点间的转移,支持条件边。
  4. 编译图,得到可执行的 Agent。
  5. 调用图,从入口节点开始执行。

代码 / 示例

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]

# 定义节点
def call_model(state):
    response = model.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state):
    # 条件判断: 是否需要继续调用工具
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

# 组装图
graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_node("tools", call_tools)
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")

app = graph.compile()

常见误区

  • 误区:LangGraph 是 LangChain 的替代品;正解:LangGraph 是 LangChain 生态的一部分,用于复杂 Agent 场景,简单 Chain 还是用 LangChain。
  • 误区:LangGraph 只能做 ReAct;正解:LangGraph 是通用图编排,可以实现任意 Agent 模式,ReAct 只是其中一种。

追问

  • Q:LangGraph 和直接写 Python 循环有什么区别? A:LangGraph 提供状态管理、检查点、可观测性、人在回路等基础设施,不用自己写。
  • Q:LangGraph 适合简单场景吗? A:简单的线性 Chain 用 LangChain 就够了,LangGraph 适合复杂的、需要循环和分支的 Agent。

10.9.1-003 LangGraph 的状态怎么管理?

频率 ★★★ | 难度 进阶

一句话结论

LangGraph 的状态是一个 TypedDict(或 Pydantic),在节点间传递;每个节点接收当前状态,返回状态更新(部分更新),框架自动合并;可以用 reducer(如 operator.add)定义列表的合并方式。

概念解释

  • 状态定义:TypedDict 或 Pydantic,定义所有需要在节点间传递的数据。
  • 节点更新:节点返回字典,是状态的部分更新,不是全量替换。
  • Reducer:定义字段如何合并,如列表用 + 追加,而不是覆盖。
  • 通道:每个字段有一个通道,决定如何累积更新。

原理流程

  1. 定义 State 结构。
  2. 初始状态传入图。
  3. 每个节点执行,返回状态更新。
  4. 框架按 reducer 合并到全局状态。
  5. 下一节点接收更新后的状态。

代码 / 示例

from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    # messages 字段: 用 operator.add 做 reducer, 新消息追加到列表
    messages: Annotated[list, operator.add]
    # count 字段: 默认行为, 新值覆盖旧值
    count: int
    # 需要自定义 reducer 时用 Annotated 包装

常见误区

  • 误区:节点返回全量状态;正解:节点返回部分更新,框架自动合并,不要手动拼接。
  • 误区:列表字段默认追加;正解:列表默认是覆盖,需要用 Annotated[list, operator.add] 显式声明追加。

追问

  • Q:状态可以很大吗? A:状态会在节点间传递,太大的状态会影响性能和检查点存储,建议只存必要信息。
  • Q:状态能持久化吗? A:LangGraph 支持检查点,状态可以持久化到数据库,实现断点续跑。

10.9.1-004 检查点(checkpoint)有什么用?

频率 ★★★ | 难度 基础

一句话结论

检查点在每个节点执行后保存当前状态,用于:断点续跑(程序崩溃后从上次检查点恢复)、人在回路(暂停等待人工审批后继续)、时间旅行(回退到之前的状态重新执行)。

概念解释

  • 自动保存:每个节点执行后自动保存状态。
  • 持久化:保存到 SQLite/PostgreSQL/Redis 等。
  • 恢复:从检查点恢复状态,继续执行。
  • 人在回路:在关键节点暂停,等待人工输入后继续。

原理流程

  1. 配置检查点存储(如 SqliteSaver)。
  2. 每个节点执行后,自动保存当前状态。
  3. 程序中断后,从最后一个检查点恢复。
  4. 人在回路:在指定节点暂停,等待人工审批。

代码 / 示例

from langgraph.checkpoint.sqlite import SqliteSaver

# 配置检查点存储
checkpointer = SqliteSaver.from_conn_string("checkpoints.db")

# 编译图时传入 checkpointer
app = graph.compile(checkpointer=checkpointer)

# 调用时指定 thread_id
config = {"configurable": {"thread_id": "user-123"}}
result = app.invoke({"messages": [...]}, config=config)

# 之后可以从这个 thread_id 恢复
# 即使程序重启, 也能从数据库恢复状态

常见误区

  • 误区:检查点是自动的不需要配置;正解:需要显式配置 checkpointer,否则不持久化。
  • 误区:检查点只存最终结果;正解:每个节点执行后都存,粒度很细。

追问

  • Q:检查点存什么? A:存完整的状态快照,包括所有字段,所以状态不要太大,否则存储开销大。
  • Q:怎么实现人在回路? A:在指定节点用 interrupt 函数暂停,程序挂起;人工审批后用 Command(resume=...) 继续。

10.9.1-005 LangChain 有哪些常见设计模式?

频率 ★★★ | 难度 进阶

一句话结论

常见设计模式:RAG(检索增强)、ReAct(推理+行动循环)、Plan-Execute(先规划再执行)、Reflection(反思自我修正)、Map-Reduce(分段处理再合并);根据任务复杂度选择。

概念解释

  • RAG:先检索相关文档,再送入模型生成回答。
  • ReAct:模型交替推理和调用工具,直到完成任务。
  • Plan-Execute:先由规划器制定步骤,再由执行器逐步执行。
  • Reflection:模型生成后自我反思,修正错误。
  • Map-Reduce:长文档分段处理,再合并结果。

原理流程

  1. 简单问答:直接 Prompt + Model。
  2. 需要外部知识:RAG。
  3. 需要工具调用:ReAct。
  4. 复杂多步任务:Plan-Execute。
  5. 需要高质量输出:Reflection。

代码 / 示例

设计模式选择:

任务类型                推荐模式
----------------------  ----------------
简单问答                直接 Chain
需要知识库              RAG
需要查数据库/搜索        ReAct
复杂多步任务            Plan-Execute
高质量写作/代码          Reflection + 多轮
长文档总结              Map-Reduce

常见误区

  • 误区:所有问题都用 ReAct;正解:简单问题直接答更快更省,ReAct 有额外的 token 和延迟成本。
  • 误区:Plan-Execute 一定比 ReAct 好;正解:Plan-Execute 适合步骤明确的任务,动态变化的任务用 ReAct 更灵活。

追问

  • Q:Reflection 模式怎么实现? A:让模型生成回答后,再让它自己批评和修改,重复 1~2 轮,提升质量但增加 token 成本。
  • Q:Map-Reduce 适合什么? A:长文档处理,如总结 100 页 PDF,分段总结再合并。

10.9.1-006 LangChain 生产环境有什么坑?

频率 ★★★★ | 难度 进阶

一句话结论

生产环境坑:版本迭代快 breaking changes 多、抽象层厚导致调试困难、token 消耗不易控制、异步支持不完善、内存泄漏;建议:核心逻辑自己写,LangChain 只做胶水层,用 LangSmith 做监控。

概念解释

  • 版本不稳定:LangChain 更新快,小版本也可能有 breaking changes。
  • 调试困难:抽象层多,出错时栈深,难以定位问题。
  • token 消耗:Chain 内部可能有多次 LLM 调用,成本不透明。
  • 异步:早期版本异步支持差,性能问题。

原理流程

  1. 核心业务逻辑自己写,不依赖 LangChain 的抽象。
  2. 用 LangChain 做模型调用、工具集成等胶水层。
  3. 用 LangSmith 监控每次 LLM 调用的 token 和延迟。
  4. 固定版本,谨慎升级。

代码 / 示例

LangChain 生产建议:
  - 核心逻辑自己写, 不被框架绑架
  - 固定版本号, 不要自动升级
  - 用 LangSmith 监控每次调用
  - 控制最大迭代次数 (防止 Agent 死循环)
  - 设置超时和重试
  - 关键步骤加日志和审计

常见误区

  • 误区:用 LangChain 就不用管 token 成本了;正解:LangChain 内部可能多次调用 LLM,必须监控每次调用的 token。
  • 误区:LangChain 是生产级框架;正解:LangChain 更适合原型开发,生产环境需要自己加很多控制。

追问

  • Q:不用 LangChain 怎么写 Agent? A:直接用 OpenAI SDK 写循环,自己管理工具调用和状态,代码更可控,适合生产。
  • Q:LangChain 有替代方案吗? A:LlamaIndex(偏 RAG)、Pydantic AI(轻量)、直接用 SDK,根据需求选择。

10.9.1-007 怎么选 LangChain vs LangGraph?

频率 ★★★ | 难度 基础

一句话结论

简单线性流程(RAG、单次问答、文本处理)用 LangChain Chain;复杂 Agent(多步循环、工具调用、人在回路、状态管理)用 LangGraph;两者可以组合使用,不是二选一。

概念解释

  • LangChain Chain:线性、简单、快速开发。
  • LangGraph:图编排、复杂逻辑、状态管理。
  • 组合:LangGraph 内部可以调用 LangChain Chain。
  • 选择:看流程是否需要循环和分支。

原理流程

  1. 流程是线性的:输入 → 处理 → 输出 → 用 LangChain。
  2. 流程有循环和分支:用 LangGraph。
  3. 不确定:先简单实现,复杂了再迁移到 LangGraph。

代码 / 示例

选型决策:

场景                          推荐
----------------------------  ----------
RAG 问答                      LangChain
单次文本处理                   LangChain
需要工具循环                   LangGraph
需要人在回路审批               LangGraph
多 Agent 协作                  LangGraph
简单 prompt 调用               直接用 SDK

常见误区

  • 误区:新项目都用 LangGraph;正解:简单场景用 LangChain 或直接 SDK 更快更简单。
  • 误区:LangGraph 替代 LangChain;正解:LangGraph 是 LangChain 的扩展,两者互补。

追问

  • Q:从 LangChain 迁移到 LangGraph 难吗? A:不太难,核心的 Model 和 Prompt 可以复用,只是编排方式从 Chain 改成 Graph。
  • Q:LangGraph 学习成本高吗? A:需要理解状态、节点、边的概念,比 LangChain 稍微复杂,但文档和示例丰富。

10.9.1-008 LangSmith 是做什么的?

频率 ★★★ | 难度 基础

一句话结论

LangSmith 是 LangChain 生态的可观测平台:追踪每次 LLM 调用(prompt、输出、token、延迟)、评估模型质量、调试 Agent 流程、监控线上应用;是 LLM 应用开发的调试和运维工具。

概念解释

  • Tracing:记录每次 LLM 调用的完整链路。
  • Evaluation:评测集管理,自动化评估模型输出。
  • Monitoring:线上应用的 token、延迟、错误率监控。
  • Debugging:查看每次调用的 prompt 和输出,定位问题。

原理流程

  1. 配置 LangSmith API key。
  2. LangChain 自动追踪所有 LLM 调用。
  3. 在 LangSmith 后台查看每次调用的详情。
  4. 配置评测集,自动化回归测试。

代码 / 示例

# 环境变量配置 LangSmith
export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_API_KEY=ls_xxx
export LANGCHAIN_PROJECT=my-agent

常见误区

  • 误区:LangSmith 是必须的;正解:LangSmith 是可选的,也可以自己写日志和监控,但 LangSmith 开箱即用。
  • 误区:LangSmith 只支持 LangChain;正解:LangSmith 也支持直接用 SDK 调用,不限于 LangChain。

追问

  • Q:LangSmith 收费吗? A:有免费额度,生产用需要付费;也可以用开源替代(如 Phoenix、Langfuse)。
  • Q:怎么监控 token 成本? A:LangSmith 会记录每次调用的 token 数和成本,按项目和模型汇总。

待整理清单

  • [ ] LangGraph 多 Agent 编排模式
  • [ ] LangChain 的异步并发控制
  • [ ] Agent 的死循环防护
  • [ ] 自定义 Tool 开发最佳实践
  • [ ] 生产级 Agent 的监控与告警