图解AI编程

第10章 巨人的肩膀，挑哪个站 ​

前九章把Agent原理讲透了——脑子、手脚、记忆、规划、协作。现在你面前摆了一堆框架：LangChain、LangGraph、CrewAI、AutoGen……每个都说自己最好。该学哪个？这一章帮你理清楚，不踩坑。

10.1 像搭积木一样组装AI应用 ​

10.1.1 LangChain 是什么 ​

LangChain 是AI应用开发领域最主流的框架。它的核心思路就一个：

把AI应用的每个组件变成一块"积木"，你用管道符 | 把它们串起来。

比如你要做"用户提问 → 套Prompt模板 → 调LLM → 解析输出"，用LangChain写就三行：

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

prompt = ChatPromptTemplate.from_template("给我讲个关于{topic}的笑话")
model = ChatOpenAI(model="gpt-4")
parser = StrOutputParser()

chain = prompt | model | parser  # ← 积木串在一起
result = chain.invoke({"topic": "程序员"})

10.1.2 LangChain 适合什么 ​

场景适合度
简单的链式处理（问→答）⭐⭐⭐⭐⭐
RAG（检索增强生成）⭐⭐⭐⭐⭐
单轮工具调用⭐⭐⭐⭐
多轮复杂对话⭐⭐⭐
有分支、循环的Agent⭐⭐

一句话总结：如果你的Agent流程是"一条直线"，LangChain 是最简单高效的选择。输入进去，一路处理，输出出来。

10.1.3 LangChain 的短板 ​

当你的Agent不再是"一条直线"——比如"如果用户不满意，换个工具重新查"——LangChain就吃力了。它不是为"循环"和"分支"设计的。

这就是LangGraph的用武之地。

10.2 当你的Agent需要"绕弯路"的时候 ​

10.2.1 LangGraph 是什么 ​

LangGraph 是LangChain团队做的，专门解决"复杂流程"的问题。它把Agent的行为建模成状态机——有节点（做事的步骤）、有边（步骤之间的跳转条件）。

LangChain的想法：输入→处理→输出，一条线。 LangGraph的想法：节点→条件判断→跳转到另一个节点→再判断→……可以有循环、有分支、有回退。

10.2.2 LangGraph 适合什么 ​

场景适合度
复杂多步骤Agent⭐⭐⭐⭐⭐
需要条件分支的流程⭐⭐⭐⭐⭐
多轮对话+状态持久化⭐⭐⭐⭐⭐
Multi-Agent协作⭐⭐⭐⭐
简单问答⭐⭐（用LangChain更轻）

一句话总结：如果你发现用LangChain的 | 写不下去了——需要用if、需要循环、需要回退——换LangGraph。

10.2.3 LangChain vs LangGraph ​

LangChainLangGraph
核心概念链（Chain）图（Graph）
流程直线有分支、循环
学习曲线低中
适合场景简单Agent复杂Agent
关系—基于LangChain，是其"增强版"

不用担心学了LangChain白学。 LangGraph底层用的还是LangChain的组件（Prompt、Model、Tool），只是编排方式从"链"变成了"图"。

10.2.4 StateGraph 深入：状态就是一切 ​

StateGraph 的"状态"不是普通的 Python 字典，它有一套完整的合并机制。

基础 State 定义——用 TypedDict 声明字段：

python
from typing import TypedDict

class BasicState(TypedDict):
    messages: list[str]
    count: int
    result: str | None

每个节点处理后返回的更新，会自动合并到 State 中。

带 Reducer 的 State——当多个节点同时修改同一个字段时，用 Reducer 控制合并逻辑：

python
from typing import TypedDict, Annotated
from operator import add

class AgentState(TypedDict):
    # messages 用 add Reducer → 自动累加，不会覆盖
    messages: Annotated[list, add]
    # count 没有 Reducer → 默认替换
    count: int

不同 Reducer 的行为：

  • messages: Annotated[list, add] → ["hi"] 加 ["hello"] 得到 ["hi", "hello"]
  • count: int → 5 被 6 直接替换
  • 还可以自定义 Reducer：merge_dicts(existing, new) 合并字典，keep_last_n(existing, new) 只保留最近 N 条

Reducer 本质上就是一个函数：(existing, new) -> result。

10.2.5 节点类型与完整工作流 ​

LangGraph 有三种节点类型，覆盖 Agent 的所有行为：

python
# 类型 1：函数节点 —— 最基础，做任意处理
def process_input(state: State) -> dict:
    return {"processed": state["input"].upper()}

# 类型 2：LLM 节点 —— 让大模型处理
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")

def llm_node(state: State) -> dict:
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

# 类型 3：工具节点 —— 调用外部 API
from langchain_core.tools import tool

@tool
def search_database(query: str) -> str:
    """搜索数据库"""
    return f"查询结果: {query}"

llm_with_tools = llm.bind_tools([search_database])

def tool_node(state: State) -> dict:
    last_msg = state["messages"][-1]
    if last_msg.tool_calls:
        result = search_database.invoke(last_msg.tool_calls[0]["args"])
        return {"messages": [result]}
    return {"messages": []}

把它们串起来，就是一个完整的 Agent：

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

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

graph = StateGraph(AgentState)
graph.add_node("llm", llm_node)
graph.add_node("tools", tool_node)

graph.add_edge(START, "llm")
graph.add_conditional_edges("llm", route_to_tools, {
    "tools": "tools",
    "__end__": END
})
graph.add_edge("tools", "llm")  # 工具结果返回 LLM，形成循环

app = graph.compile()

这个工作流的执行路径是：START → LLM → (需要工具？→ 工具节点 → LLM → 需要工具？→ ...) → 直接回答 → END。

三种节点 + 条件边 + 循环 = Agent 的完整骨架。 不管你的 Agent 有多复杂——Multi-Agent、ReAct、Human-in-the-Loop——底层都是这套骨架的扩展。

10.3 让多个Agent"组队打怪" ​

10.3.1 CrewAI：给Agent分配"角色" ​

CrewAI 专注于 Multi-Agent 团队协作。它的核心概念是"角色（Role）"——每个Agent有自己的名字、职责、目标和背景故事。

python
from crewai import Agent, Task, Crew

# 定义Agent角色
analyst = Agent(
    role="数据分析师",
    goal="从数据中发现业务洞察",
    backstory="你在数据行业有10年经验，擅长从数字中发现趋势。"
)

writer = Agent(
    role="报告撰写者", 
    goal="把分析结果写成易读的报告",
    backstory="你擅长把复杂的数据分析转成CEO看得懂的文字。"
)

# 组建团队
crew = Crew(agents=[analyst, writer], tasks=[task1, task2])
result = crew.kickoff()

CrewAI的特点：上手快，概念直观（角色+任务+团队）。不需要自己管Agent之间的通信——框架帮你搞定了。

10.3.2 AutoGen（微软）：Agent对话Agent ​

AutoGen 把多Agent协作建模成 "对话"。Agent之间通过发消息来沟通，就像人在群里聊天。

python
from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent("assistant", llm_config={"model": "gpt-4"})
user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding"})

# 用户发起对话，Agent自动配合
user_proxy.initiate_chat(
    assistant,
    message="帮我写一个Python函数，输入日期返回星期几"
)
# AutoGen的Agent会自动：
# 1. 写代码
# 2. 执行代码
# 3. 看到错误自己修
# 4. 直到代码能跑

10.3.3 CrewAI vs AutoGen ​

CrewAIAutoGen
核心概念角色+任务+团队Agent对话
上手难度低中
适合场景结构化团队协作开放式对话协作
代码自动执行需要额外配置内置
生态成熟度增长中微软背书，较成熟

10.4 框架怎么选？ ​

10.4.1 按场景选 ​

10.4.2 按学习路径选 ​

推荐路径：LangChain → LangGraph → CrewAI/AutoGen

  1. 先学LangChain：理解"链"的概念，知道怎么调LLM、怎么接工具、怎么搭RAG。这些是基础。
  2. 再学LangGraph：当你的Agent变复杂了，需要分支、循环、状态管理了，自然过渡到LangGraph。
  3. 最后学CrewAI/AutoGen：当你需要多Agent协作时再学。这两个框架底层也依赖LangChain。

不用全学。 你的项目到什么复杂度，就学到什么深度。LangChain是地基，绕不开；其他的按需学。

10.4.3 本书的策略 ​

这本书第11章会重点讲LangChain和LangGraph，因为：

  • 它们是Agent开发的"基础设施"，几乎所有其他框架都依赖它们
  • 掌握了这两个，CrewAI和AutoGen上手只需要半天
  • 第16-18章的三个项目全部基于LangChain/LangGraph实现

10.5 本章小结 ​

这一章帮你理清了框架选型的思路：

  1. LangChain：搭积木，管道符一串联就完事。简单场景首选。
  2. LangGraph：状态机，有分支、有循环、有回退。复杂Agent的标配。
  3. CrewAI：角色扮演式多Agent协作，适合结构化团队。
  4. AutoGen：对话式多Agent协作，适合开放式探索。

核心建议：LangChain是基础，必学；LangGraph是进阶，本书重点；CrewAI/AutoGen按需学。

✅ 知识点检查 ​

学完这一章，试试回答这几个问题：

  • [ ] LangChain的"链"和LangGraph的"图"，核心区别在哪？
  • [ ] 什么场景适合用LangChain，什么场景必须用LangGraph？
  • [ ] CrewAI和AutoGen都是Multi-Agent框架，各有什么特点？怎么选？
  • [ ] 推荐的学习路径是什么？为什么LangChain是地基？

📚 延伸阅读 ​

🎯 下一章预告 ​

第11章，深入LangChain和LangGraph——

"从死脑筋到会拐弯。框架选好了，我们把它吃透。"