04 LangGraph面试题

1、LangGraph解决了什么问题？

LangChain在面对复杂的业务场景时，会遇到以下几个问题：

• 执行流程不可控：通过create_agent创建的Agent执行流程是黑盒的，开发者很难修改和调整执行路径。

• 无法处理复杂逻辑：当Agent的逻辑变得复杂后，可能会有多个分支、循环，无法构建复杂的业务流程。

• 不支持持久执行：如果Agent执行到一半失败了，只能从头开始重新执行，无法从失败的地方恢复继续。

• 不支持人工介入：在某些关键步骤（如转账、扣款），需要人工确认后才能继续。

LangGraph 就是为了解决这些问题而诞生的。它是一个基于图结构的Agent编排框架，通过图来管理Agent的执行流程。

LangGraph解决了上述问题：

• 流程可视化：用图结构描述执行流程，整个执行流程非常清晰
• 支持处理复杂逻辑：通过定义节点、边、条件边控制分支结构
• 持久执行：通过 Checkpoint 机制，支持断点恢复
• 人工介入：通过 interrupt/resume，支持 Human-in-the-Loop

2、LangGraph中的State是什么？

State（状态） 是 LangGraph 中所有节点的共享数据，定义了图运行过程中需要传递和更新的数据，State 一般用于短期记忆。LangGraph 提供了一个 MessagesState，继承了 TypedDict，内部定义了消息列表，如果我们想自定义 State 可以继承 MessagesState。

class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

State 中的每个字段都可以指定一个归纳函数，决定了当节点返回数据时，是覆盖还是追加。不指定归纳函数，节点返回的数据会直接覆盖原数据；指定 operator.add，节点返回的数据会追加到原数据后面。

# 不指定归纳函数 → 覆盖
class State(TypedDict):
    result: str  # 每次节点返回都会覆盖

# 指定operator.add → 追加
class State(TypedDict):
    result: Annotated[list[str], operator.add]  # 每次节点返回都会追加

每个节点函数都可以接收 State 作为参数，并读取 State 中的数据，通过返回值对字段进行更新。

def my_node(state: MessagesState):
    # 读取State中的消息列表
    messages = state["messages"]
    # 处理逻辑...
    # 返回需要更新的字段，`LangGraph`会自动合并到State中
    return {"messages": [new_message]}

3、LangGraph中的Node是什么？

Node（节点）是 LangGraph 中最基本的执行单元，本质上就是一个处理 State 的 Python 函数。

它接收当前状态（State）作为输入，执行相应逻辑后返回状态更新结果，LangGraph 会自动将返回结果合并到全局 State 中。

def chatbot(state):
    response = model.invoke(state["messages"])

    return {
        "messages": [response]
    }

添加 Node：

graph.add_node("chatbot", chatbot)

其中：

• state：LangGraph State 数据
• chatbot：Node 的具体实现
• 返回值：需要更新的状态数据

Node 节点可以负责调用 LLM、调用 Tool、RAG 检索、数据处理、条件判断等工作，在 LangGraph 中，State 负责存储数据，Node 负责处理数据，多个 Node 通过 Edge（边）连接后组成完整的 LangGraph 工作流。

4、LangGraph中的Edge是什么？

Edge（边）用于连接 Node 节点，通过边来决定工作流的执行顺序和执行路径。

添加边的方法如下，当 chatbot 节点执行完成后，会自动执行 tool 节点。

graph.add_edge("chatbot", "tool")

除了普通 Edge 之外，LangGraph 还支持条件边（Conditional Edge），示例如下：在条件边的路由函数中，判断是否需要执行工具，如需要，则返回 tool，执行 tool 节点，否则返回 END，执行结束节点。

graph.add_conditional_edges(
    "chatbot",
    route
)
def route(state):
    if need_tool:
        return "tool"
    return END

所以，Edge 的核心作用是定义 Node 之间的执行顺序和执行路径，通过条件边实现条件分支和循环执行。

5、Checkpoint的作用是什么？

Checkpoint（检查点）用于持久化保存 State，让 LangGraph 拥有记忆能力。

当图执行到某个节点时，LangGraph 会自动将当前 State 保存到 Checkpoint 中。如果程序中断、重启或需要继续执行，可以从上次保存的位置恢复，而不需要重新开始。

例如：

from langgraph.checkpoint.memory import InMemorySaver

checkpointer = InMemorySaver()

builder = StateGraph(State)
graph = builder.compile(
    checkpointer=checkpointer
)

执行过程中，State 会被自动保存：

{
    "messages": [...],
    "user_info": {...}
}

下次使用相同的 thread_id 调用时，LangGraph 会自动恢复之前的 State，实现多轮对话记忆。

config = {
    "configurable": {
        "thread_id": "user_001"
    }
}

Checkpoint 的主要作用：

• 持久化保存 State
• 实现短期记忆
• 支持断点执行（Resume）
• 支持 Human-in-the-loop（人在环路）
• 支持长时间运行的 Agent 工作流

6、LangGraph如何实现断点恢复？

LangGraph 通过 Checkpoint（检查点）机制来实现断点恢复。

工作流运行过程中，LangGraph 会自动将当前 State 数据保存到 Checkpointer 中。当程序异常退出、服务重启或执行中断后，通过相同的 thread_id 恢复之前保存的状态，并从中断位置继续执行。

示例如下：

graph = builder.compile(
    checkpointer=InMemorySaver()
)

config = {
    "configurable": {
        "thread_id": "user_001"
    }
}

第一次执行：

graph.invoke(
    {"messages": [HumanMessage("你好")]},
    config=config
)

程序重启后再次执行：

graph.invoke(
    {"messages": [HumanMessage("继续刚才的话题")]},
    config=config
)

因为使用了相同的 thread_id，LangGraph 会自动从 Checkpoint 中恢复之前保存的 State，而不是从头开始执行。

Checkpoint 不仅保存 State，还会保存当前图的执行快照，包括下一步待执行的节点信息。因此恢复时不仅能恢复数据，还能恢复执行进度，从上次中断的位置继续执行。

7、LangGraph如何实现循环执行？

LangGraph 通过 条件边回到之前的节点 来实现循环执行，本质上就是在图中形成一个环（Loop）。

在实际场景中，通过条件边（Conditional Edge）控制循环何时结束，比如当 LLM 判断需要继续调用工具时，执行 tool 节点，工具执行完再回到 agent 节点；当任务完成时直接返回 END，执行结束节点停止循环。

graph.add_conditional_edges(
    "agent",
    should_continue
)
def should_continue(state):
    if state["need_tool"]:
        return "tool"
    return END

为什么需要循环执行呢？因为在很多 Agent 场景中，LLM 往往需要多轮思考，本质上都依赖循环执行机制。

例如：

• ReAct Agent
• Tool Calling Agent
• RAG 检索增强
• 多步任务规划

8、LangGraph如何实现多Agent协作？

LangGraph 中的多 Agent 协作，本质上是将多个 Agent 作为不同的 Node 节点，通过共享的 State 和 Edge 连接起来共同完成任务。

例如：

graph.add_node("planner", planner_agent)
graph.add_node("researcher", researcher_agent)
graph.add_node("writer", writer_agent)

graph.add_edge("planner", "researcher")
graph.add_edge("researcher", "writer")

其中：Planner Agent 负责任务规划，Researcher Agent 负责信息检索，Writer Agent 负责内容生成，多个 Agent 共享同一个 State。

class State(TypedDict):
    task: str
    research_result: str
    final_answer: str

还可以使用 Conditional Edge 动态路由，来决定执行哪个 Agent。

graph.add_conditional_edges(
    "planner",
    route_agent
)

9、LangGraph和AutoGen有什么区别？

LangGraph 和 AutoGen 都可以用于构建 AI Agent 应用，但两者的设计理念不同，LangGraph 更关注工作流编排，AutoGen 更关注多 Agent 协作。LangGraph 执行过程由图结构控制，开发者需要明确设计执行流程。AutoGen 基于 Agent 对话，多个 Agent 通过消息传递协作完成任务。

在流程管理上：

• LangGraph 支持条件分支、循环执行、状态持久化、Human-in-the-loop、断点恢复。
• AutoGen 流程主要依赖 Agent 之间的对话，控制逻辑更多由 Agent 自主决定，复杂流程的可控性弱于 LangGraph。

在状态管理上：

• LangGraph 拥有统一的 State，所有节点共享同一个状态对象。
• AutoGen 每个 Agent 维护自己的消息历史，状态管理相对分散。

在多 Agent 支持上：

• LangGraph 支持多 Agent，但不是核心设计目标，通常把 Agent 当作 Node。
• AutoGen 把多 Agent 当成核心能力，天然适合 Agent 间协作和讨论。

在使用场景上：

• LangGraph 更适合企业级 Agent、长流程任务。
• AutoGen 适合实验项目、Agent 研究、多智能体探索。

10、LangGraph和CrewAI有什么区别？

LangGraph 更关注工作流编排，CrewAI 更关注多 Agent 角色协作。

在核心模型上：

• LangGraph 基于 State Graph（状态图），由 State、Node、Edge 构成，执行过程由图结构控制，开发者需要明确设计执行流程。
• CrewAI 基于 Role + Task + Crew（角色与任务），通过定义不同 Agent 角色和任务分工，由框架自动完成协作调度。

在流程管理上：

• LangGraph 支持条件分支、循环执行、Checkpoint 状态持久化、Human-in-the-loop、断点恢复等能力，流程可控性非常强。
• CrewAI 支持顺序执行（Sequential）和层级执行（Hierarchical），整体流程更偏自动化编排，复杂流程控制能力弱于 LangGraph。

在状态管理上：

• LangGraph 拥有统一的 State，所有 Node 共享同一个状态。
• CrewAI 主要依赖 Task 输出传递，上一任务输出作为下一任务输入，状态管理相对分散，没有统一全局 State。

在多 Agent 支持上：

• LangGraph 支持多 Agent，但本质是把 Agent 当作 Node 来编排，多个 Agent 如何协作由开发者实现。
• CrewAI 多 Agent 是核心能力，通过角色分工（如 Researcher、Writer、Reviewer）天然支持团队式协作。

在适用场景上：

• LangGraph 更适合：企业级 Agent、Tool Calling、RAG 工作流、长流程任务、复杂业务编排。
• CrewAI 更适合：多角色内容生产、市场调研、写作协作等场景。