第四章：三大框架 Agent 声明对比

同样是”创建一个能搜索的Agent”，三大框架写法差异巨大。本节课逐一对比LangChain、LangGraph、DeepAgents的Agent声明方式，帮你选择最适合的开发方式。

4.1 LangChain 方式

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate

# 1. 定义工具
@tool
def search(query: str) -> str:
    """搜索互联网"""
    return f"搜索结果: {query}"

# 2. 定义提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有帮助的助手"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),  # 必须的占位符
])

# 3. 创建 Agent
llm = ChatOpenAI(model="gpt-4o")
agent = create_tool_calling_agent(llm, [search], prompt)

# 4. 包装为执行器
agent_executor = AgentExecutor(agent=agent, tools=[search], verbose=True)

# 5. 运行
result = agent_executor.invoke({"input": "LangChain 是什么？"})
print(result["output"])

特点：

• 需要手动定义提示词模板和占位符
• 需要 AgentExecutor 包装
• 没有内置状态管理
• 没有内置规划、文件系统、上下文压缩
• 适合简单的链式任务

执行流程：

sequenceDiagram
participant User as 用户
participant Executor as AgentExecutor
participant LLM as LLM
participant Tool as 工具

User->>Executor: 输入问题
loop 循环直到完成
    Executor->>LLM: 发送消息 + 工具定义
    LLM-->>Executor: 返回响应
    alt 需要调用工具
        Executor->>Tool: 执行工具调用
        Tool-->>Executor: 返回工具结果
    else 无需调用工具
        Executor-->>User: 返回最终回答
    end
end

4.2 LangGraph 方式

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.graph import StateGraph, START, END, MessagesState
from langgraph.prebuilt import ToolNode

# 1. 定义工具
@tool
def search(query: str) -> str:
    """搜索互联网"""
    return f"搜索结果: {query}"

# 2. 定义模型
llm = ChatOpenAI(model="gpt-4o")
llm_with_tools = llm.bind_tools([search])

# 3. 定义节点函数
def agent_node(state: MessagesState):
    """LLM 决策节点"""
    system_msg = {"role": "system", "content": "你是一个有帮助的助手"}
    response = llm_with_tools.invoke([system_msg] + state["messages"])
    return {"messages": [response]}

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

# 5. 构建图
builder = StateGraph(MessagesState)
builder.add_node("agent", agent_node)
builder.add_node("tools", ToolNode([search]))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
builder.add_edge("tools", "agent")

agent = builder.compile()

# 6. 运行
result = agent.invoke({"messages": [{"role": "user", "content": "LangGraph 是什么？"}]})
print(result["messages"][-1].content)

特点：

• 需要手动定义每个节点和边
• 可以精确控制执行流程
• 支持状态持久化和人工干预
• 没有内置规划、文件系统、上下文压缩
• 适合需要精确控制的复杂流程

执行流程：

flowchart TD
START([START]) --> Agent[agent 节点: LLM 决策]
Agent --> Decision{有工具调用?}
Decision -->|是| Tools[tools 节点: 执行工具]
Decision -->|否| END([END])
Tools --> Agent

style START fill:#e8f5e9
style END fill:#ffebee
style Agent fill:#e3f2fd
style Tools fill:#fff9c4

4.3 DeepAgents 方式

from deepagents import create_deep_agent

# 定义工具
def search(query: str) -> str:
    """搜索互联网"""
    return f"搜索结果: {query}"

# 一行创建 Agent！
agent = create_deep_agent(
    model="openai:gpt-4o",
    tools=[search],
    system_prompt="你是一个有帮助的助手",
)

# 运行
result = agent.invoke({
    "messages": [{"role": "user", "content": "DeepAgents 是什么？"}]
})
print(result["messages"][-1].content)

特点：

• 一个函数创建 Agent
• 内置规划、文件系统、上下文压缩、子 Agent
• 底层仍然是 LangGraph 的状态图
• 适合复杂的自主 Agent 任务

执行流程（自动）：

sequenceDiagram
participant User as 用户
participant Agent as Deep Agent
participant Plan as 规划模块
participant Tool as 工具
participant Ctx as 上下文管理器

User->>Agent: 输入问题
Agent->>Plan: write_todos 自动规划
Plan-->>Agent: 生成待办列表

loop 按计划逐步执行
    Agent->>Tool: 选择并调用工具
    Tool-->>Agent: 返回结果

    alt 工具结果过大
        Agent->>Ctx: 自动卸载到文件系统
        Ctx-->>Agent: 返回文件引用
    end

    alt 上下文接近85%阈值
        Agent->>Ctx: 自动摘要旧消息
        Ctx-->>Agent: 返回压缩后上下文
    end
end

Agent-->>User: 返回最终回答

4.4 对比总结

维度	LangChain	LangGraph	DeepAgents
代码量	~15 行	~30 行	~5 行
需要手写提示词模板	是	否	否
需要手写节点/边	否	是	否
内置规划	否	否	是
内置文件系统	否	否	是
内置上下文压缩	否	否	是
内置子 Agent	否	否	是
精确控制流程	否	是	有限
执行流程可预测性	高	最高	中
灵活性	中	最高	中高

一句话总结：

• LangChain：我需要自己管每一步的输入输出
• LangGraph：我需要精确控制每一步的执行逻辑
• DeepAgents：让 Agent 自己规划，我只需要告诉它目标

4.5 混合使用策略

实际项目中，你不必只选一个：

from deepagents import create_deep_agent
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

# 简单的 LCEL 链（LangChain 方式）
simple_chain = ChatOpenAI(model="gpt-4o") | StrOutputParser()

# DeepAgents Agent 处理复杂任务
agent = create_deep_agent(
    model="openai:gpt-4o",
    tools=[list_tables, get_table_schema, run_sql_query],
    system_prompt="你是一个 SQL 助手",
)

# 简单问题用链，复杂问题用 Agent
def ask(question: str) -> str:
    if len(question) < 20 and "数据库" not in question:
        return simple_chain.invoke(question)
    else:
        result = agent.invoke({
            "messages": [{"role": "user", "content": question}]
        })
        return result["messages"][-1].content