LangChain + LangGraph 学习路径

文章目录

• 总体路线（一句话）
• [Day 0（1--2 小时）：先建立「全局运行模型」（非常关键）](#Day 0（1–2 小时）：先建立「全局运行模型」（非常关键）)
• [Day 1：LangChain ------ 把「Agent 是什么」彻底学透](#Day 1：LangChain —— 把「Agent 是什么」彻底学透)
• • [1️⃣ LangChain 中你必须真正掌握的 5 个核心概念](#1️⃣ LangChain 中你必须真正掌握的 5 个核心概念)
  • • （1）Tool：不是函数，是「能力边界」
    • （2）Agent：不是模型，是「决策器」
    • [（3）Agent Loop（你一定要懂）](#（3）Agent Loop（你一定要懂）)
    • [（4）Output Parser / Pydantic（可信度杀器）](#（4）Output Parser / Pydantic（可信度杀器）)
    • （5）Memory（先理解接口，不要管实现）
    • [✅ Day 1 结束时，你必须能回答：](#✅ Day 1 结束时，你必须能回答：)
• [Day 2：LangGraph ------ 这是你可信度跃迁的一天](#Day 2：LangGraph —— 这是你可信度跃迁的一天)
• • [2️⃣ LangGraph 你必须吃透的 4 个概念](#2️⃣ LangGraph 你必须吃透的 4 个概念)
  • • （1）State：不是变量，是「全局共享事实」
    • （2）Node：不是函数，是「责任单元」
    • [（3）Edge / Conditional Edge：系统逻辑显性化](#（3）Edge / Conditional Edge：系统逻辑显性化)
    • [（4）Loop / Retry：这才是 Agent 系统](#（4）Loop / Retry：这才是 Agent 系统)
    • [✅ Day 2 结束时，你必须能回答：](#✅ Day 2 结束时，你必须能回答：)
• [Day 3：反向理解你的项目（可信度构建）](#Day 3：反向理解你的项目（可信度构建）)
• • [3️⃣ 用 LangGraph 语言"翻译"你的项目](#3️⃣ 用 LangGraph 语言“翻译”你的项目)
  • • [GraphRAG 双路检索](#GraphRAG 双路检索)
    • [多 Agent 协作](#多 Agent 协作)
    • [CRAG 自反思](#CRAG 自反思)
    • 记忆机制
    • 类型安全
• [Day 4（半天）：面试级「整合表达」](#Day 4（半天）：面试级「整合表达」)
• • • 你以后说话要像这样：
• 最后一句非常重要的话

你的理解基本正确！LangChain + LangGraph 是核心框架，其他都是基于这两个框架的具体应用。但学习不能只靠"跑代码"，需要概念理解 + 动手实践结合。

让我先帮你搜索一下最新的学习资源和官方文档：

根据你的问题，我帮你整理了一个更具体、可操作的学习方案。直接跑示例代码是对的，但需要有顺序、有重点地学。

🚀 3天快速上手方案（聚焦简历项目）

第0步：环境搭建（1小时）

创建虚拟环境

python -m venv agent_env

source agent_env/bin/activate # Mac/Linux

或 agent_envScriptsactivate # Windows

安装核心库

pip install langchain langgraph langchain-openai neo4j qdrant-client pydantic

准备 API Key（可以用免费额度测试）

OpenAI / DeepSeek / 智谱 任选一个

export OPENAI_API_KEY="your-key-here"

第1天：LangGraph 核心概念（重点！） ⭐⭐⭐⭐⭐

学习顺序：概念 → 官方示例 → 修改示例 → 自己写

时间 任务 具体操作 产出

上午 理解 4 个核心概念 State、Node、Edge、Graph 能口述解释

下午 跑官方 Hello World 官方快速入门 代码能运行

晚上 改造成 2 节点工作流 加一个 Grader 节点 理解条件边

必须跑通的示例代码（保存为 day1_basic.py）：

from typing import TypedDict, Annotated

from langgraph.graph import StateGraph, END

import operator

定义状态（所有节点共享的数据）

class State(TypedDict):

messages: Annotated[list, operator.add] # 消息列表会累积

query: str

result: str

定义节点函数

def planner_node(state):

print(f"📋 Planner: 收到查询 {state['query']}")

return {"messages": ["Planner 已处理"], "result": "规划完成"}

def grader_node(state):

print(f"✅ Grader: 评估结果 {state['result']}")

return {"messages": ["Grader 已评估"]}

构建图

graph = StateGraph(State)

graph.add_node("planner", planner_node)

graph.add_node("grader", grader_node)

定义边

graph.set_entry_point("planner") # 入口

graph.add_edge("planner", "grader") # 顺序执行

graph.add_edge("grader", END) # 结束

编译运行

app = graph.compile()

result = app.invoke({"query": "帮我规划北京 3 日游", "messages": []})

print(result)

跑完后问自己：

State 是怎么在节点间传递的？

如果我想让 grader 不满意时回到 planner，怎么改？（答案：条件边）

第2天：多 Agent + 条件边（简历核心） ⭐⭐⭐⭐⭐

目标：实现你简历中的"Planner 调度子 Agent"架构

必须跑通的示例代码（保存为 day2_multi_agent.py）：

from typing import TypedDict, Literal

from langgraph.graph import StateGraph, END

class State(TypedDict):

query: str

current_step: str

weather_result: str

hotel_result: str

final_plan: str

子 Agent 节点

def weather_agent(state):

print("🌤️ 天气 Agent 工作中...")

return {"weather_result": "北京晴天，25°C"}

def hotel_agent(state):

print("🏨 酒店 Agent 工作中...")

return {"hotel_result": "推荐：北京饭店"}

def planner_agent(state):

print("📋 Planner 聚合结果...")

return {"final_plan": f"天气:{state['weather_result']}, 住宿:{state['hotel_result']}"}

条件边：决定走哪个分支

def route_logic(state) -> Literal["weather", "hotel", "end"]:

if "天气" in state["query"]:

return "weather"

elif "酒店" in state["query"]:

return "hotel"

else:

return "end"

构建图

graph = StateGraph(State)

graph.add_node("planner", planner_agent)

graph.add_node("weather", weather_agent)

graph.add_node("hotel", hotel_agent)

graph.set_entry_point("planner")

graph.add_conditional_edges("planner", route_logic) # 条件分支

graph.add_edge("weather", END)

graph.add_edge("hotel", END)

app = graph.compile()

测试

app.invoke({"query": "查天气", "current_step": ""})

app.invoke({"query": "找酒店", "current_step": ""})

跑完后问自己：

条件边怎么工作的？

如果要并行调用天气和酒店 Agent，怎么改？（答案：add_edge 到同一个节点）

第3天：CRAG 式反思 + 记忆机制（简历亮点） ⭐⭐⭐⭐

目标：实现"质量评估→不满意→重写查询"的循环

必须跑通的示例代码（保存为 day3_crag.py）：

from typing import TypedDict, Literal

from langgraph.graph import StateGraph, END

class State(TypedDict):

query: str

search_result: str

grade_score: float

final_answer: str

rewrite_count: int

检索节点

def retrieve(state):

print(f"🔍 检索：{state['query']}")

模拟检索质量不稳定

import random

score = random.random()

return {"search_result": f"搜索结果_{score}", "grade_score": score}

评估节点

def grade(state):

score = state["grade_score"]

print(f"📊 评分：{score}")

if score > 0.7:

return "ACCEPT"

elif score > 0.3:

return "REWRITE"

else:

return "SEARCH"

重写查询节点

def rewrite_query(state):

count = state.get("rewrite_count", 0) + 1

print(f"✏️ 重写查询 (第{count}次)")

return {"query": f"{state['query']}_优化版", "rewrite_count": count}

构建带循环的图

graph = StateGraph(State)

graph.add_node("retrieve", retrieve)

graph.add_node("rewrite", rewrite_query)

graph.set_entry_point("retrieve")

graph.add_conditional_edges("retrieve", grade, {

"ACCEPT": END,

"REWRITE": "rewrite",

"SEARCH": "rewrite"

})

graph.add_edge("rewrite", "retrieve") # 循环回去

app = graph.compile()

result = app.invoke({"query": "北京景点", "rewrite_count": 0})

print(f"最终结果：{result}")

跑完后问自己：

循环是怎么实现的？（答案：rewrite → retrieve 的边）

怎么防止无限循环？（答案：在 rewrite 里计数，超过阈值强制结束）

📚 学习资源优先级

资源 链接 优先级 用时

官方快速入门 https://langchain-ai.github.io/langgraph/tutorials/introduction/ ⭐⭐⭐⭐⭐ 2 小时

官方多 Agent 示例 https://langchain-ai.github.io/langgraph/tutorials/multi_agent/ ⭐⭐⭐⭐⭐ 3 小时

CSDN 中文教程 搜索"LangGraph 入门" ⭐⭐⭐⭐ 2 小时

GitHub 示例库 https://github.com/langchain-ai/langgraph ⭐⭐⭐ 选看

🎯 面试前必须准备好的 5 个图

面试时能画出来比能说更重要：

整体架构图

┌─────────────────────────────────────────┐

│ 用户 Query │

└───────────────────┬─────────────────────┘

▼

┌─────────────────────────────────────────┐

│ Planner Agent │

│ (意图识别 + 任务拆解 + 结果聚合) │

└──────┬──────────┬──────────┬────────────┘

▼ ▼ ▼

┌──────┐ ┌──────┐ ┌──────┐

│天气 │ │酒店 │ │景点 │

│Agent │ │Agent │ │Agent │

└──────┘ └──────┘ └──────┘

LangGraph 工作流图

Entry → Planner → [条件分支] → Weather/Hotel → Grader → END

↑ │

└───────┬──────┘

(循环重写)

双路召回流程图

用户 Query → 向量检索 (Qdrant) ──┐

→ 图谱检索 (Neo4j) ──┼→ 融合 → 结果

(RRF/加权)

CRAG 反思流程

Retrieve → Grade → [>0.7: END]

0.3-0.7: Rewrite

\<0.3: Search+Rewrite

记忆存储架构

短期：MessageHistory (内存)

中期：Qdrant (用户偏好向量)

长期：Neo4j (用户画像关系)

⚠️ 避坑指南

坑 表现 解决方案

环境冲突 包版本不兼容 用虚拟环境，固定版本

API Key 问题 调用失败 先用 Mock 数据跑通逻辑

概念混淆 LangChain vs LangGraph 记住：LangGraph 是 LangChain 的图工作流扩展

代码跑不通 直接复制粘贴 先理解每行代码作用，再修改

面试被问住 死记硬背 理解原理，不会就说"这部分我参考了 XX 方案"

✅ 学习完成自检清单

\] 能解释 State、Node、Edge、Graph 分别是什么 \[ \] 能画出你项目的 Agent 架构图 \[ \] 能说明白条件边怎么工作 \[ \] 能解释 CRAG 的 3 个分支逻辑 \[ \] 能说明双路召回的融合方式 \[ \] 能说出 Pydantic 在项目中的作用 \[ \] 3 个示例代码都能本地跑通 最后建议：今天就开始跑第一个示例代码，动手比看书重要 10 倍。遇到报错不要慌，把错误信息复制给我，我帮你分析。 需要我帮你解释某个具体概念，或者帮你调试代码吗？ 明白了 👍 你这个诉求其实是\*\*"以 LangChain + LangGraph 为主线的反向学习"\*\*： > **先把 Agent / Workflow / State / Tool / Memory 这些"骨架"吃透** > > 再回头把 GraphRAG、CRAG、Planner 这些"肉"往上填 > > 这样你在面试时给人的感觉是： > > 👉 *不是照着教程堆功能，而是对 Agent 系统的运行机制非常清楚* 下面我给你一条**高度聚焦、以 LangChain + LangGraph 为中心的「工程级速成路径」** ，**3--4 天即可形成"我真的懂"的可信度**。 *** ** * ** *** ## 总体路线（一句话） > **LangChain 解决「Agent 能力如何被调用」 > LangGraph 解决「Agent 在什么时候、以什么顺序、失败后怎么继续」** 你要学习的不是 API，而是 **运行模型（mental model）**。 *** ** * ** *** ## Day 0（1--2 小时）：先建立「全局运行模型」（非常关键） 在写任何代码之前，你先把这张**心智图**刻进脑子里： User Query ↓ Planner / Entry Node ↓ [ Agent Node ] ├─ decide ├─ call tool └─ produce structured output ↓ Grader / Router ├─ accept → END └─ reject → rewrite / retry / fallback 你要明确区分 **三件事**： | 层 | 你在控制什么 | |-----------|-----------------------------| | LLM | 语言推理 | | LangChain | 能力封装（Agent / Tool / Memory） | | LangGraph | 流程与状态（节点 / 边 / 回路） | 👉 **面试可信度 70% 来自这个层级认知** *** ** * ** *** ## Day 1：LangChain ------ 把「Agent 是什么」彻底学透 > 目标：**任何人问你 Agent，你都能从"决策 + 工具 +约束"回答** ### 1️⃣ LangChain 中你必须真正掌握的 5 个核心概念 #### （1）Tool：不是函数，是「能力边界」 你要这样理解 Tool： > Tool = *"LLM 被允许调用的外部世界接口"* 关键点（面试会问）： * Tool 是 **受控 IO** * Tool schema = 给 LLM 的 **契约** 你在项目里用 Pydantic，本质是： > 把 Tool 调用从"猜格式"变成"强约束接口" *** ** * ** *** #### （2）Agent：不是模型，是「决策器」 **非常重要的一句话**（建议背）： > LangChain Agent 的本质不是生成答案，而是**决定下一步该不该调用 Tool、调用哪个、用什么参数** 这直接解释了： * 为什么 Agent 比 Chain 不稳定 * 为什么需要拆 Agent *** ** * ** *** #### （3）Agent Loop（你一定要懂） Agent ≠ 一次 LLM 调用 而是： Thought → Action → Observation → Thought → ... 你项目里 **多 Agent 架构** 的合理性，就来自这里： > 当一个 Agent 的 Action 空间太大，它的 Loop 会变得不稳定 *** ** * ** *** #### （4）Output Parser / Pydantic（可信度杀器） 你可以非常工程化地说： > 在多 Agent 系统中，LLM 输出必须被当作"不可信输入"，Pydantic 是系统稳定性的关键组件。 这句话非常「像做过」。 *** ** * ** *** #### （5）Memory（先理解接口，不要管实现） 你现在只需要知道： * LangChain Memory = **LLM 可见的历史** * 它不等于数据库 * 它决定 **Agent 的"短期认知"** *** ** * ** *** #### ✅ Day 1 结束时，你必须能回答： * Agent 和 Chain 的本质差异？ * Tool 为什么一定要结构化？ * 为什么 Agent 一多就容易崩？ *** ** * ** *** ## Day 2：LangGraph ------ 这是你可信度跃迁的一天 > 目标：**你能清楚说出「为什么不用 for-loop + if」** *** ** * ** *** ### 2️⃣ LangGraph 你必须吃透的 4 个概念 #### （1）State：不是变量，是「全局共享事实」 在 LangGraph 中： > State = **所有节点可读写的任务上下文** 你项目里： * 用户约束 * 中间规划结果 * Grader 评分 👉 都应该是 State **面试关键词**： > "显式状态建模" *** ** * ** *** #### （2）Node：不是函数，是「责任单元」 你要这样定义 Node： > Node = *"在当前 State 下，完成一个确定职责的计算单元"* 所以： * Agent Node：负责生成方案 * Grader Node：负责判断质量 *** ** * ** *** #### （3）Edge / Conditional Edge：系统逻辑显性化 LangGraph 最重要的价值不是"能连起来"，而是： > **把原本藏在 Prompt 里的 if / retry / fallback，变成代码级逻辑** 这正是你 CRAG 能站得住的原因。 *** ** * ** *** #### （4）Loop / Retry：这才是 Agent 系统 你要能清楚说出： * 普通 Agent：失败 = 结束 * LangGraph Agent：失败 = 状态变化 + 再执行 *** ** * ** *** #### ✅ Day 2 结束时，你必须能回答： * LangGraph 解决了什么工程问题？ * 为什么它比 LangChain Chain 更适合复杂 Agent？ * Grader 为什么一定要是 Node？ *** ** * ** *** ## Day 3：反向理解你的项目（可信度构建） 现在你回头看你的简历，每一条都能被 LangGraph / LangChain 精确解释： *** ** * ** *** ### 3️⃣ 用 LangGraph 语言"翻译"你的项目 #### GraphRAG 双路检索 → **不是 RAG 技巧，而是：** > "在 Agent 工具层，通过不同 Tool 接口分别暴露结构检索与语义检索能力" *** ** * ** *** #### 多 Agent 协作 → **不是多模型，而是：** > "在 LangGraph 中将不同决策空间拆成多个 Agent Node，由 Planner 统一协调" *** ** * ** *** #### CRAG 自反思 → **不是 Prompt 技巧，而是：** > "通过 Grader Node + Conditional Edge 实现显式质量控制回路" *** ** * ** *** #### 记忆机制 → **不是聊天记录，而是：** > "为 Agent 决策提供跨节点、跨会话的上下文状态" *** ** * ** *** #### 类型安全 → **不是 Python 习惯，而是：** > "Agent 系统中最关键的稳定性工程手段" *** ** * ** *** ## Day 4（半天）：面试级「整合表达」 你现在要做的不是再学新东西，而是**统一语言体系**： #### 你以后说话要像这样： * ❌「我用了 LangGraph」 * ✅「我用显式状态机管理 Agent 的失败与重试逻辑」 * ❌「我用了 CRAG」 * ✅「我在工作流中加入质量评估节点，避免低置信度结果直接返回」 *** ** * ** *** ## 最后一句非常重要的话 你现在这个项目，**真正的核心不是 GraphRAG** ， 而是： > **你已经在无意中做了一个「可控、可恢复、可扩展的 Agent Workflow 系统」** 只要你按这条路径学， 面试官会感受到的不是"会用框架"， 而是： 👉 **"这个人真的理解 Agent 系统是怎么跑起来的。"** *** ** * ** *** 如果你愿意，下一步我可以直接帮你做一件更狠的事： **用 LangGraph 的概念，帮你把这个项目"重新讲一遍成一个 5 分钟面试故事"** 。 这个对实战非常致命。