langchain与langgraph区别以及学习路线

可以把它们先理解成一句话：

LangChain 是"构建 LLM 应用的工具箱"，LangGraph 是"构建有状态、可循环、可控 Agent 工作流的运行框架"。

如果你准备做 AI Agent / RAG / 多 Agent / 企业级 AI 应用 ，建议不要把 LangChain 和 LangGraph 当成两个完全独立的东西学，而是 先 LangChain，再 LangGraph。

1. LangChain vs LangGraph

对比	LangChain	LangGraph
核心定位	LLM 应用开发框架	Agent / 工作流编排框架
解决的问题	怎么调用模型、工具、RAG、结构化输出	怎么让 Agent 按流程执行、循环、暂停、恢复
上手难度	⭐⭐	⭐⭐⭐⭐
典型应用	Chatbot、RAG、工具调用	Agent、多 Agent、复杂任务
状态管理	有，但不是核心	核心能力
循环/分支	支持，但不是重点	核心能力
Human-in-the-loop	有相关能力	非常适合
持久化	有相关能力	核心场景之一
多 Agent	可以实现	非常适合
工作流控制	中等	强

LangChain 更像这样

用户问题
   ↓
LLM
   ↓
Tool
   ↓
LLM
   ↓
回答

例如：

用户：东京明天天气怎么样？

        ↓

   LangChain Agent
        ↓
    调用天气 Tool
        ↓
    获取天气数据
        ↓
      LLM
        ↓
    返回自然语言

---

LangGraph 更像这样

复杂一点：

                ┌──────────────┐
                │  用户问题     │
                └──────┬───────┘
                       ↓
                 ┌───────────┐
                 │  意图分析  │
                 └─────┬─────┘
                       ↓
              ┌───────────────┐
              │   是否需要搜索 │
              └───┬───────┬───┘
                  │       │
                 是       否
                  ↓       ↓
               Search    LLM
                  ↓       │
               判断结果    │
                  ↓       │
              需要继续搜索？│
               ↓      ↓    │
              是      否    │
               │       └────┤
               └──→ Search  │
                       ↓     │
                       └──→ LLM
                              ↓
                           最终回答

这种有状态 + 条件分支 + 循环 + 多节点的 Agent，正是 LangGraph 擅长的。

---

2. 两者是什么关系？

现在学习 LangChain，建议理解成：

                 AI Application
                       │
              ┌────────┴────────┐
              │                 │
          LangChain          LangGraph
              │                 │
       LLM / Tools / RAG    Agent Workflow
       Prompt / Retriever   State / Graph
       Structured Output    Loop / Branch
              │                 │
              └────────┬────────┘
                       ↓
                    LLM API
              OpenAI / Claude / ...

实际上 LangGraph 可以使用 LangChain 的很多组件。

比如：

from langchain_openai import ChatOpenAI

模型还是 LangChain 生态里的东西。

而 LangGraph 负责：

State
  ↓
Node
  ↓
Node
  ↓
Conditional Edge
  ↓
Node

所以不要纠结：

"LangChain 和 LangGraph 到底选哪个？"

更合理的是：

LangChain 学组件，LangGraph 学 Agent 编排。

---

3. 推荐你的学习路线

如果你是有 Node.js / 前端 / 后端开发经验，我建议走这条路线：

Python / TypeScript 基础
        ↓
LLM API
        ↓
Prompt
        ↓
Structured Output
        ↓
Tool Calling
        ↓
LangChain
        ↓
RAG
        ↓
Agent
        ↓
LangGraph
        ↓
Memory / Persistence
        ↓
Human-in-the-loop
        ↓
Multi-Agent
        ↓
Agent Production

---

第一阶段：先搞懂 LLM 原生能力

不要一上来就 LangChain。

先直接调用模型 API。

你需要搞懂：

① Chat Completion

system
user
assistant

理解：

• message
• token
• context window
• temperature
• streaming
• structured output

---

② Tool Calling

这是后面学 Agent 的基础。

例如：

{
  "name": "search_weather",
  "arguments": {
    "city": "Tokyo"
  }
}

整个流程：

用户
 ↓
LLM
 ↓
判断需要 Tool
 ↓
调用 Tool
 ↓
Tool 返回结果
 ↓
LLM
 ↓
最终答案

如果这个流程你彻底理解了，后面 Agent 会简单很多。

---

第二阶段：LangChain 核心

这一阶段不要追求把 LangChain API 全学完。

重点学 6 个东西：

1. Chat Model

model = ChatOpenAI(...)

理解：

输入 → Model → AIMessage

---

2. Prompt

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个专业助手"),
    ("human", "{question}")
])

理解：

Prompt Template
       ↓
    Model
       ↓
   Response

---

3. Structured Output

例如：

class UserInfo(BaseModel):
    name: str
    age: int

让 LLM 输出：

{
  "name": "张三",
  "age": 25
}

这个在实际项目里非常重要。

---

4. Tool

例如：

@tool
def search_database(keyword: str):
    ...

然后让 LLM 决定：

需要查询数据库？
      ↓
     Yes
      ↓
调用 search_database

---

5. Retriever

这是 RAG 的核心。

Documents
    ↓
Embedding
    ↓
Vector DB
    ↓
Retriever
    ↓
Relevant Documents
    ↓
LLM

---

6. Agent

最后把：

LLM
+
Tools
+
Reasoning

组合起来。

你应该理解 Agent 的本质：

Agent 并不是一个神秘的 AI，它本质上是一个"LLM + 工具 + 循环决策"的程序。

---

第三阶段：RAG

这部分非常值得认真学。

建议掌握：

PDF / Markdown / Web
        ↓
Document Loader
        ↓
Chunk
        ↓
Embedding
        ↓
Vector Database
        ↓
Retriever
        ↓
Rerank
        ↓
LLM

然后理解：

Naive RAG

问题
 ↓
Embedding
 ↓
Vector Search
 ↓
Top K
 ↓
LLM

进一步：

Advanced RAG

Query Rewrite
     ↓
Hybrid Search
     ↓
Vector Search
     ↓
Keyword Search
     ↓
Rerank
     ↓
Context
     ↓
LLM

如果你以后做企业级 AI，这部分比背 LangChain API 更重要。

---

第四阶段：正式进入 LangGraph

这时候再学 LangGraph，会非常顺。

核心就 4 个概念：

State

整个 Agent 的状态。

class State(TypedDict):
    messages: list
    search_result: str

---

Node

一个执行步骤。

def search_node(state):
    ...

例如：

Node A
  ↓
Node B
  ↓
Node C

---

Edge

控制节点之间怎么走。

A → B

---

Conditional Edge

最重要。

       A
       ↓
   判断条件
    ↙   ↘
   B     C

---

5. LangGraph 最重要的思想：State Machine

你可以把 LangGraph 理解成：

给 Agent 做状态机。

比如一个 Coding Agent：

        ┌────────────┐
        │ Understand │
        └─────┬──────┘
              ↓
        ┌────────────┐
        │ Write Code │
        └─────┬──────┘
              ↓
        ┌────────────┐
        │ Run Tests  │
        └─────┬──────┘
              ↓
        ┌────────────┐
        │   Passed?  │
        └───┬────┬───┘
            │    │
           Yes   No
            ↓    ↓
          Done  Fix Code
                  │
                  └──────→ Run Tests

这就是 LangGraph 非常典型的应用。

---

6. 然后学习 Agent Memory

这里建议分清两个概念。

短期状态

例如：

当前对话
当前任务
当前工具调用
当前 Agent 状态

长期记忆

例如：

用户偏好
历史任务
用户资料
长期知识

不要把：

Conversation History

简单等同于：

Memory

这是很多初学者容易混淆的地方。

---

7. 再学 Human-in-the-loop

这是 LangGraph 很值得学习的一块。

例如：

Agent
 ↓
准备删除数据库
 ↓
暂停
 ↓
等待人工确认
 ↓
用户批准
 ↓
继续执行

或者：

Agent
 ↓
生成邮件
 ↓
人工审核
 ↓
修改
 ↓
发送

这才开始接近真正的企业级 Agent。

---

8. 再往后：Multi-Agent

例如一个研究 Agent：

                 Supervisor
                      │
          ┌───────────┼───────────┐
          ↓           ↓           ↓
      Researcher   Coder       Writer
          ↓           ↓           ↓
          └───────────┼───────────┘
                      ↓
                   Reviewer
                      ↓
                    Final

LangGraph 非常适合做这种复杂编排。

---

9. 最后进入生产环境

如果你的目标不是"会写 Demo"，而是以后做真正的 AI 产品，这些一定要学：

LangChain
   ↓
LangGraph
   ↓
Streaming
   ↓
Persistence
   ↓
Checkpoint
   ↓
Human-in-the-loop
   ↓
Observability
   ↓
Evaluation
   ↓
Guardrails
   ↓
Cost Control
   ↓
Concurrency
   ↓
Production Deployment

尤其是：

Evaluation

你需要知道：

Agent 到底好不好？
RAG 找到的资料对不对？
回答有没有幻觉？
Tool 有没有调用错误？

不能只靠"我测试了一下感觉还行"。

---

10. 如果你是 Node.js 开发者

你其实不一定需要转 Python。

LangChain 有 TypeScript 生态。

可以走：

Node.js
  ↓
TypeScript
  ↓
LangChain.js
  ↓
LangGraph.js
  ↓
Next.js
  ↓
PostgreSQL / Redis
  ↓
Vector DB

这条路线非常适合做 Web AI 产品。

例如：

Next.js
   ↓
AI API
   ↓
LangChain
   ↓
LangGraph
   ↓
Redis / PostgreSQL
   ↓
Vector DB

你之前关注过 Redis + Node.js 的高并发架构，这方面的后端经验其实可以直接迁移到 Agent 系统里：Agent 本身只是业务编排层，真正生产化时仍然会遇到缓存、队列、并发、限流、持久化、流式输出等传统后端问题。

---

11. 我建议你按这个顺序学

如果每天有 1～2 小时：

第 1 周：LLM 基础

LLM API
Prompt
Message
Streaming
Structured Output
Tool Calling

第 2 周：LangChain

Model
Prompt
Output Parser
Tool
Runnable
Agent

第 3 周：RAG

Embedding
Vector DB
Retriever
Chunk
Metadata
Hybrid Search
Rerank

第 4 周：LangGraph

State
Node
Edge
Conditional Edge
Graph
Checkpoint

第 5 周：Agent

Tool Agent
ReAct
Memory
Human-in-the-loop
Reflection
Planning

第 6～7 周：复杂 Agent

Multi-Agent
Supervisor
Subgraph
Long-term Memory
Persistence

第 8 周：生产化

Streaming
Observability
Evaluation
Guardrails
Retry
Timeout
Rate Limit
Cost Control
Deployment

---

12. 最重要的是：不要"看教程学"

我更推荐你直接做一个项目：

「AI 企业知识库 Agent」

最终架构：

                       用户
                        │
                        ↓
                    Next.js
                        │
                        ↓
                 LangGraph Agent
                        │
            ┌───────────┼───────────┐
            ↓           ↓           ↓
         Search       SQL Tool    Web Tool
            │           │           │
            ↓           ↓           ↓
        Vector DB    PostgreSQL    Search API
            │           │           │
            └───────────┼───────────┘
                        ↓
                       LLM
                        │
                        ↓
                     Answer

然后逐步加：

V1：普通 Chat
 ↓
V2：RAG
 ↓
V3：Tool Calling
 ↓
V4：Agent
 ↓
V5：LangGraph
 ↓
V6：Memory
 ↓
V7：Human Approval
 ↓
V8：Multi-Agent
 ↓
V9：Evaluation
 ↓
V10：Production

这样学下来，你会真正理解 LangChain 和 LangGraph 为什么存在，而不是记住一堆 API。

如果你现在主要是 Node.js + Next.js ，我会建议你直接走 TypeScript + LangChain.js + LangGraph.js 这条路线，不必为了学 Agent 专门切 Python。