DoneHub
0%

Agent 开发实战指南：10+ 个开源项目带你从入门到进阶

发表于 更新于 分类于 阅读次数： Valine：

上一篇我们系统梳理了 Agent 编程的核心名词词典。有了概念基础，下一步就是动手看真实项目代码。

这篇文章的目标很直接：推荐 10+ 个值得深入学习的开源 Agent 项目，从入门到进阶，涵盖单 Agent、多 Agent、Code Agent、生产级平台。每个项目我都会告诉你：Star 数、学习价值、核心文件、适合什么阶段的人看。

读完之后，你会有一个清晰的学习路线：知道从哪里开始、怎么深入、最终能做什么。

一、为什么必须看开源项目？

很多新手的误区是：先背完所有概念、看完所有文档，再开始写代码。

这是错误的。

正确的学习路径是：

1
概念入门（1-2 天）→ 立刻看项目代码 → 边看边写 → 遇到不懂的概念再回头查

看开源项目的价值：

学习方式 效果
只看文档 概念懂了，但不知道怎么组合起来
只看教程 跟着抄代码，但不知道为什么这么写
看真实项目 看到完整系统架构、真实代码结构、实际问题解决方案

一个真实项目能教会你的东西：

  • Agent 怎么定义（不是文档里说的”抽象概念”，而是具体的类和函数）
  • 工具怎么注册和调用（完整的 Function Calling 流程）
  • 循环怎么实现（ReAct 循环的真实代码）
  • 状态怎么管理（多轮对话、跨会话记忆）
  • 错误怎么处理（真实场景的异常处理）
  • 怎么部署到生产（架构设计、监控、日志）

二、学习路线全景图

先给你一个整体路线，然后再逐个介绍项目：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
┌─────────────────────────────────────────────────────────────┐
│                    Agent 项目学习路线                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  阶段一：入门（理解基本原理）                                 │
│  ├── LangChain 官方示例 ★★★★★                              │
│  ├── LangGraph 示例 ★★★★★                                  │
│  └── Anthropic Cookbook ★★★★★                              │
│                                                             │
│  阀值：能用 LangGraph 写一个简单的 ReAct Agent               │
│                                                             │
│  阶段二：进阶（学习完整 Agent 系统）                         │
│  ├── GPT-Researcher ★★★★★                                  │
│  ├── AutoGPT ★★★★☆                                         │
│  └── AgentGPT ★★★★☆                                        │
│                                                             │
│  阀值：理解完整的任务规划、执行、反馈循环                     │
│                                                             │
│  阶段三：Code Agent 专项（后端工程师重点）                    │
│  ├── OpenHands ★★★★★                                       │
│  ├── SWE-agent ★★★★☆                                       │
│  ├── Continue ★★★★★                                        │
│                                                             │
│  阀值：理解 Agent 如何操作代码库                             │
│                                                             │
│  阶段四：多 Agent 协作                                       │
│  ├── CrewAI ★★★★★                                          │
│  ├── AutoGen ★★★★★                                         │
│  └── MetaGPT ★★★★★                                         │
│                                                             │
│  阀值：能设计多 Agent 协作系统                               │
│                                                             │
│  阶段五：生产级参考                                          │
│  ├── Dify ★★★★★                                            │
│  └── LangGraph Platform ★★★★★                              │
│                                                             │
│  阀值：理解生产级架构、部署、监控                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

三、阶段一：入门级项目（理解基本原理）

3.1 LangChain 官方示例

项目信息 内容
仓库 langchain-ai/langchain
Star 100k+
学习路径 /docs/docs/use_cases/ 和 /cookbook/
学习价值 ★★★★★ 官方最佳实践，覆盖所有核心场景

为什么必看：

LangChain 虽然有”样板代码多”的缺点，但它的官方示例是最系统、最权威的入门材料。覆盖了 Agent、RAG、Tool Calling 的标准写法，每个示例 100-300 行，适合快速上手。

重点看什么：

目录 学习重点
/cookbook/ 完整的小案例，从简单到复杂
/docs/docs/use_cases/agents/ Agent 的各种实现模式
/docs/docs/use_cases/question_answering/ RAG 的各种方案

学习方式：

1
2
3
4
5
6
7
8
9
# 克隆仓库
git clone https://github.com/langchain-ai/langchain.git

# 重点看这些文件
docs/docs/use_cases/agents/
├── agent_iterations.ipynb        # Agent 循环迭代
├── tools.ipynb                   # 工具定义和使用
├── custom_agent.ipynb            # 自定义 Agent
└── agent_reasoning.ipynb         # Agent 推理过程

入门目标：看完后能用 LangChain 写一个能调用工具的简单 Agent。

3.2 LangGraph 示例

项目信息 内容
仓库 langchain-ai/langgraph
Star 30k+
学习路径 /examples/ 目录
学习价值 ★★★★★ 学习 Agent 状态机、循环、分支的最佳资源

为什么必看：

LangGraph 是 LangChain 团队推出的新一代 Agent 框架，用状态图（StateGraph）来定义 Agent 工作流。相比 LangChain 的链式调用，LangGraph 更适合复杂的循环、分支场景。

核心概念：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
LangGraph = 状态机 + Agent

┌─────────────────────────────────────────────────────────────┐
│                    LangGraph 核心概念                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  StateGraph（状态图）                                        │
│  ├── Node（节点）：处理函数，如 agent_node、tool_node       │
│  ├── Edge（边）：流转条件，如 should_continue               │
│  └── State（状态）：在节点间传递的数据                       │
│                                                             │
│  工作流程：                                                  │
│  1. 定义 State（状态结构）                                   │
│  2. 定义 Node（处理节点）                                    │
│  3. 定义 Edge（流转逻辑）                                    │
│  4. compile() → 得到一个可执行的 Agent                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

重点示例：

文件 学习重点
react-agent.ipynb ReAct Agent 的完整实现
planner-agent.ipynb 有规划能力的 Agent
multi-agent.ipynb 多 Agent 协作基础
memory.ipynb 记忆系统实现

核心代码结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# LangGraph 的核心模式
from langgraph.graph import StateGraph, END

# 1. 定义状态
class AgentState(TypedDict):
    messages: list
    tool_calls: list

# 2. 定义节点
def agent_node(state: AgentState):
    # LLM 处理逻辑
    ...

def tool_node(state: AgentState):
    # 工具执行逻辑
    ...

# 3. 构建图
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_edge("agent", "tools")
graph.add_edge("tools", "agent")

# 4. 编译并运行
app = graph.compile()
result = app.invoke({"messages": ["帮我查北京天气"]})

入门目标：看完后能用 LangGraph 写一个 ReAct 循环 Agent。

3.3 Anthropic Cookbook

项目信息 内容
仓库 anthropics/anthropic-cookbook
Star 10k+
学习价值 ★★★★★ Claude 官方最佳实践，代码质量极高

为什么必看：

Anthropic 的 Cookbook 是代码质量最高的学习材料。每个示例都很简洁（100 行以内），注释清晰，直击核心。不像有些项目代码又长又乱，这里每个文件都是精品。

重点看什么：

目录/文件 学习重点
tool_use/ Function Calling 的最佳实践
prompt_caching/ Prompt 缓存，降本 90%
context_windows/ 长上下文处理技巧
computer_use/ Computer Use（操作电脑）能力

特色内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# Anthropic 的 Tool Use 示例（极简风格）
import anthropic

client = anthropic.Client()

def get_weather(city: str):
    # 实际工具函数
    return f"{city}今天晴，25度"

# 定义工具
tools = [{
    "name": "get_weather",
    "description": "获取指定城市的天气",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string"}
        },
        "required": ["city"]
    }
}]

# 调用 Claude
response = client.messages.create(
    model="claude-sonnet-4-6",
    tools=tools,
    messages=[{"role": "user", "content": "北京今天天气怎么样"}]
)

# Claude 会返回 tool_use，你再执行并返回结果

入门目标：理解 Function Calling 的完整流程，学会 Claude 的最佳实践。

四、阶段二：进阶级项目（学习完整 Agent 系统）

4.1 GPT-Researcher

项目信息 内容
仓库 assafelovic/gpt-researcher
Star 15k+
学习价值 ★★★★★ 学习 Agent 如何完成研究任务

为什么必看：

这是一个完整的端到端 Agent 系统。你给它一个研究主题（如”AI Agent 的发展趋势”），它会自动：搜索信息 → 分析多个来源 → 整合内容 → 生成研究报告。非常适合理解完整 Agent 流程。

架构亮点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
┌─────────────────────────────────────────────────────────────┐
│                    GPT-Researcher 架构                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  用户输入："研究 AI Agent 的发展趋势"                        │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Planner Agent                                        │  │
│  │  → 分解研究任务，生成搜索查询                           │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Search Agent                                         │  │
│  │  → 多源搜索（Google、Tavily、新闻）                    │  │
│  │  → 并行执行多个搜索                                    │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Scraper Agent                                        │  │
│  │  → 抓取网页内容                                        │  │
│  │  → 过滤无关信息                                        │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Writer Agent                                         │  │
│  │  → 整合所有信息                                        │  │
│  │  → 生成结构化研究报告                                   │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心文件：

文件路径 学习重点
gpt_researcher/master.py 主 Agent，任务编排
gpt_researcher/actions/ 各个 Agent 的具体实现
gpt_researcher/memory/ 记忆系统
gpt_researcher/tools/ 搜索、抓取等工具

学习收获：

  • 理解 Agent 如何分解任务
  • 理解多源信息检索和整合
  • 理解并行执行和结果汇总
  • 理解如何生成结构化输出

4.2 AutoGPT

项目信息 内容
仓库 Significant-Gravitas/AutoGPT
Star 170k+
学习价值 ★★★★☆ Agent 概念的开创者

历史地位：

AutoGPT 是 2023 年 Agent 概念爆发的起点。它首次展示了 LLM 可以自主规划、自主执行、自主反思。虽然现在看来架构有些老旧，但理解它能帮助你理解 Agent 的”初心”。

核心创新：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
AutoGPT 的核心循环：

Goal: "帮我写一个 Python 爬虫"

┌─────────────────────────────────────────────────────────────┐
│  Thought: "我需要先了解一下 Python 爬虫的基础知识"          │
│  Reasoning: "应该从基础教程开始"                            │
│  Plan: ["搜索 Python 爬虫教程", "阅读教程", "写代码"]       │
│  Action: search("Python 爬虫入门教程")                      │
│  Observation: 搜索结果：XXX 教程...                         │
│                                                             │
│  Thought: "这个教程不错，接下来写代码"                      │
│  Action: write_file("crawler.py", ...)                     │
│  Observation: 文件已创建                                    │
│                                                             │
│  ... 循环继续 ...                                           │
└─────────────────────────────────────────────────────────────┘

建议：代码量较大（5000+ 行），建议只看核心架构部分，不必深究每个细节。

4.3 AgentGPT

项目信息 内容
仓库 reworkd/AgentGPT
Star 32k+
学习价值 ★★★★☆ 带前端界面的 Agent 部署平台

为什么看：

如果你想做一个完整的 Agent Web 应用，AgentGPT 是很好的参考。它包含：

  • Next.js 前端
  • FastAPI 后端
  • Agent 执行引擎
  • 用户管理、任务管理

架构：

1
2
3
4
5
6
7
8
9
10
11
12
AgentGPT 架构：

Frontend (Next.js)
├── 任务提交界面
├── 执行进度展示
└── 结果展示

Backend (FastAPI)
├── API 接口
├── Agent 执行引擎
├── 数据库（任务存储）
└── SSE（实时推送）

核心文件：

路径 学习重点
frontend/ Next.js + React，Agent UI 设计
backend/ FastAPI，Agent API 设计
backend/agent/ Agent 核心逻辑

五、阶段三：Code Agent 专项（后端工程师重点）

这部分是你作为后端工程师的重点学习内容。 Code Agent 是目前最有价值的 Agent 方向之一。

5.1 OpenHands（原名 OpenDevin）

项目信息 内容
仓库 All-Hands-AI/OpenHands
Star 40k+
学习价值 ★★★★★ 最活跃的 Devin 开源实现

为什么必看：

OpenHands 是目前最成熟的 Code Agent 开源项目。它能：

  • 理解代码库结构
  • 修改代码文件
  • 执行命令行操作
  • 运行测试
  • 调试问题

核心架构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
┌─────────────────────────────────────────────────────────────┐
│                    OpenHands 架构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Controller                                          │  │
│  │  → 任务编排、状态管理                                  │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Agent                                               │  │
│  │  → LLM 决策、规划、执行                                │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Runtime                                             │  │
│  │  → Docker 容器执行环境                                 │  │
│  │  → 文件操作、命令执行、代码运行                         │  │
│  └──────────────────────────────────────────────────────┘  │
│                      │                                      │
│                      ▼                                      │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Tools                                                │  │
│  │  → 文件读写、搜索、执行命令、运行测试                   │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心文件：

路径 学习重点
agenthub/ Agent 定义，各种 Agent 类型
controller/ 任务编排，状态管理
runtime/ Docker 执行环境设计
tools/ 工具集定义

关键技术点：

  1. 执行环境隔离：用 Docker 容器执行代码，安全且可控
  2. 文件操作工具：如何让 Agent 安全地读写文件
  3. 命令执行：如何让 Agent 执行 bash 命令并获取结果
  4. 状态恢复：如何暂停和恢复 Agent 任务

学习方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 克隆仓库
git clone https://github.com/All-Hands-AI/OpenHands.git

# 核心文件结构
openhands/
├── agenthub/
│   ├── codeact_agent/        # 核心 Agent 实现
│   │   └── codeact_agent.py  # ★ 重点看这个
│   └── browsing_agent/       # 浏览器操作 Agent
│
├── controller/
│   └── state.py              # 状态管理
│   └── action_parser.py      # 动作解析
│
├── runtime/
│   ├── docker/               # Docker 执行环境
│   └── plugins/              # 运行时插件
│
└── tools/
    ├── execute_bash.py       # Bash 好执行工具
    ├── file_ops.py           # 文件操作工具
    └── search.py             # 代码搜索工具

5.2 SWE-agent

项目信息 内容
仓库 princeton-nlp/SWE-agent
Star 15k+
学习价值 ★★★★☆ 普林斯顿出品，专注代码修复

为什么看：

SWE-agent 是学术界的 Code Agent 实现，在 SWE-bench（代码修复基准测试）上表现优秀。它的特点是专注于代码问题定位和修复。

核心能力：

  • 定位问题代码
  • 理解 Bug 原因
  • 生成修复补丁
  • 验证修复效果

学习收获：

  • 理解 Agent 如何”理解代码库”
  • 理解问题定位的策略（搜索、分析、追踪）
  • 理解代码修复的流程

5.3 Continue

项目信息 内容
仓库 continuedev/continue
Star 20k+
学习价值 ★★★★★ IDE 集成 Agent 的最佳参考

为什么必看：

Continue 是一个开源的 IDE AI 插件（VS Code、JetBrains），如果你想了解如何把 Agent 集成到开发工具中，这是最好的参考。

架构亮点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌─────────────────────────────────────────────────────────────┐
│                    Continue 架构                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  IDE Extension                                              │
│  ├── VS Code 插件                                          │
│  ├── JetBrains 插件                                        │
│  └── 用户界面（聊天、代码补全）                             │
│                                                             │
│  Core Engine                                                │
│  ├── Context 收集（当前文件、相关文件）                     │
│  ├── LLM 调用                                              │
│  ├── Code 处理                                             │
│                                                             │
│  Features                                                   │
│  ├── Chat（对话）                                          │
│  ├── Edit（代码编辑）                                       │
│  ├── Autocomplete（补全）                                  │
│  └── Commands（自定义命令）                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心文件：

路径 学习重点
extension/ IDE 插件开发（VS Code）
core/ Agent 核心逻辑
core/context/ 上下文收集策略

六、阶段四：多 Agent 协作项目

6.1 CrewAI

项目信息 内容
仓库 crewAIInc/crewAI
Star 25k+
学习价值 ★★★★★ 多 Agent 角色扮演的最佳学习案例

为什么必看：

CrewAI 是目前最优雅的多 Agent 框架。它的核心理念是：把多个 Agent 定义为不同角色，让它们像团队一样协作。

核心概念：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from crewai import Agent, Task, Crew

# 定义角色
researcher = Agent(
    role="研究员",
    goal="收集最新信息",
    backstory="你擅长搜索和整理资料",
)

writer = Agent(
    role="撰稿人",
    goal="撰写高质量文章",
    backstory="你擅长文字表达",
)

# 定义任务
research_task = Task(
    description="研究 AI Agent 的最新进展",
    agent=researcher,
)

write_task = Task(
    description="撰写一篇关于 AI Agent 的文章",
    agent=writer,
)

# 组建团队
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,  # 顺序执行
)

# 执行
crew.kickoff()

学习收获：

  • 理解角色定义（role、goal、backstory）
  • 理解任务定义和分配
  • 理解协作模式（sequential、hierarchical）
  • 理解如何让多个 Agent 传递信息

核心文件：

路径 学习重点
crewai/agent.py Agent 类定义
crewai/task.py Task 类定义
crewai/crew.py Crew 类定义，协作编排
crewai/process/ 协作流程实现

6.2 AutoGen

项目信息 内容
仓库 microsoft/autogen
Star 35k+
学习价值 ★★★★★ 微软出品，多 Agent 对话框架

为什么必看：

AutoGen 是微软的多 Agent 研究成果，特点是Agent 间通过对话协作。不同于 CrewAI 的角色扮演，AutoGen 更侧重于Agent 间的信息交换和讨论。

核心模式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌─────────────────────────────────────────────────────────────┐
│                    AutoGen 对话模式                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  User Proxy Agent                                          │
│  ├── 代表用户，转发消息                                     │
│  └── 执行代码                                               │
│                                                             │
│  Assistant Agent                                           │
│  ├── LLM Agent，生成方案                                    │
│  └── 提出代码建议                                           │
│                                                             │
│  对话流程：                                                 │
│  User: "帮我写一个爬虫"                                    │
│  Assistant: "好的，这是方案..."                            │
│  User Proxy: 执行代码...                                   │
│  Assistant: "有错误，我来修复..."                          │
│  User Proxy: 执行修复后的代码...                           │
│  ... 循环直到成功 ...                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心文件：

路径 学习重点
autogen/agent/contrib/ 各种 Agent 类型
autogen/oai/ LLM 调用封装
samples/ 使用示例

6.3 MetaGPT

项目信息 内容
仓库 geekan/MetaGPT
Star 45k+
学习价值 ★★★★★ 多 Agent 模拟软件开发团队

为什么必看：

MetaGPT 是最有创意的多 Agent 项目之一。它把多个 Agent 定义为软件团队的各个角色：产品经理、架构师、程序员、测试工程师等，让它们协作开发一个完整的软件。

团队结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌─────────────────────────────────────────────────────────────┐
│                    MetaGPT 软件团队                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  产品经理 Agent                                             │
│  → 分析需求，输出 PRD                                       │
│                                                             │
│  架构师 Agent                                               │
│  → 设计系统架构，输出设计文档                                │
│                                                             │
│  项目经理 Agent                                             │
│  → 分配任务，管理进度                                       │
│                                                             │
│  工程师 Agent（多个）                                        │
│  → 实现代码                                                 │
│                                                             │
│  QA Engineer Agent                                          │
│  → 编写测试，验证代码                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

学习收获：

  • 理解如何让 Agent 输出结构化文档（PRD、设计文档）
  • 理解 Agent 间如何传递文档和代码
  • 理解如何让 Agent 执行完整的软件流程

七、阶段五：生产级平台参考

7.1 Dify

项目信息 内容
仓库 langgenius/dify
Star 50k+
学习价值 ★★★★★ 企业级 LLM 应用开发平台

为什么必看：

Dify 是目前最完整的开源 LLM 应用平台。它包含：

  • 可视化工作流编辑器
  • Agent 编排
  • RAG 知识库管理
  • 多租户、多模型支持
  • 完整的部署方案

架构全景：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
┌─────────────────────────────────────────────────────────────┐
│                    Dify 架构                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Frontend                                                   │
│  ├── React + Next.js                                       │
│  ├── 工作流可视化编辑器                                     │
│  └── 知识库管理界面                                         │
│                                                             │
│  Backend                                                    │
│  ├── Python + Flask                                        │
│  ├── 工作流引擎                                             │
│  ├── Agent 执行器                                           │
│  ├── RAG 引擎                                               │
│  └── 模型路由（多模型支持）                                  │
│                                                             │
│  Infrastructure                                             │
│  ├── PostgreSQL（元数据）                                   │
│  ├── Vector Store（向量存储）                               │
│  ├── Redis（缓存）                                          │
│  └── Celery（异步任务）                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心文件：

路径 学习重点
api/core/workflow/ 工作流引擎核心
api/core/agent/ Agent 执行逻辑
api/core/rag/ RAG 引擎
web/ 前端工作流编辑器

学习收获：

  • 理解企业级架构设计
  • 理解工作流引擎设计
  • 理解多租户、多模型支持
  • 理解生产级部署方案

7.2 LangGraph Platform

项目信息 内容
仓库 langchain-ai/langgraph
学习路径 /platform/ 目录
学习价值 ★★★★★ Agent 生产部署最佳实践

为什么看：

LangGraph Platform 是 LangChain 团队推出的生产级 Agent 部署方案。它解决了 Agent 从 Demo 到生产的关键问题：

  • 持久化（任务状态保存）
  • 恢复（暂停后继续）
  • 监控（执行链路追踪）
  • API 设计（Agent 作为服务）

核心能力：

能力 说明
Persistence Agent 状态持久化，支持暂停恢复
Memory 跨会话记忆管理
Streaming 实时推送执行进度
API REST API + WebSocket

八、项目学习方法总结

8.1 看项目的正确姿势

错误方式 正确方式
从头到尾逐行看代码 先看架构，再看核心模块，最后看细节
只看不跑 先跑起来，再改代码，看效果
看完就忘 记笔记、画架构图、写总结
看一个项目就停止 多个项目对比，找出共同模式

推荐步骤：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Step 1: 理解项目目标
├── 读 README
├── 看官方文档/介绍视频
└── 明确"这个项目解决什么问题"

Step 2: 跑起来
├── 按文档安装依赖
├── 运行最小示例
└── 理解基本输入输出

Step 3: 看架构
├── 读项目目录结构
├── 找核心入口文件
├── 画架构图（自己画）

Step 4: 看核心模块
├── Agent 定义文件
├── 工具注册文件
├── 循环实现文件
├── 状态管理文件

Step 5: 改代码
├── 添加一个新工具
├── 修改 Agent 行为
├── 观察变化

8.2 核心文件速查表

不管什么项目，这几个核心模块一定要找到：

核心模块 关键文件特征 学习重点
Agent 定义 通常有 agent.py 或 agents/ 目录 Agent 如何初始化、有什么属性、如何执行
工具注册 tools/ 或 functions/ 目录 工具如何定义、如何注册给 Agent
循环实现 main.py 或 run.py 或 execute() ReAct 循环怎么写、状态怎么传递
状态管理 state.py 或 memory/ 目录 状态如何保存、如何恢复
LLM 调用 llm.py 或 model/ 目录 如何调用 LLM、如何处理响应

九、Java 工程师的特别建议

作为 Java 后端工程师，你有独特的优势：

优势 如何利用
系统设计能力 重点看架构设计部分，不只是代码细节
工程化经验 重点看生产级项目（Dify、LangGraph Platform）
调试能力 主动改代码、加日志、看执行过程

推荐路径：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
阶段一（Python 生态入门）—— 1-2 周
├── 看 LangGraph 示例，理解状态图模式
├── 看 GPT-Researcher，理解完整流程
└── 用 Python 写一个简单的 ReAct Agent

阶段二（Code Agent 专项）—— 2-3 周
├── 看 OpenHands 核心代码
├── 理解文件操作、命令执行工具
└── 思考：如何用 Java 实现类似系统

阶段三（Java 生态融合）—— 2-3 周
├── 学习 LangChain4j
├── 学习 Spring AI
├── 用 Java 重构你的 Python Agent Demo
└── 集成到你现有的项目中

阶段四（生产级设计）—— 持续
├── 研究 Dify 的架构
├── 设计你自己的 Agent 平台
├── 考虑：多租户、监控、部署、成本控制

Java 生态框架：

框架 说明 学习优先级
LangChain4j LangChain 的 Java 版，成熟度高 ★★★★★
Spring AI Spring 官方 AI 框架，生态整合好 ★★★★★
Semantic Kernel 微软出品，支持 Java ★★★★☆

十、学习路线时间规划

阶段 时间 目标
入门 1-2 周 理解 Agent 基本原理，能用 LangGraph 写简单 Agent
进阶 2-3 周 理解完整 Agent 系统，能写出类似 GPT-Researcher 的项目
Code Agent 2-3 周 理解 Code Agent，能用 Java 实现文件操作、命令执行
多 Agent 1-2 周 理解多 Agent 协作，能设计 Agent 团队
生产级 持续 理解生产架构，能部署和维护 Agent 服务

附录：项目速查表

项目 Star 学习价值 适合阶段 核心学习点
LangChain 示例 100k+ ★★★★★ 入门 基础 Agent 写法
LangGraph 示例 30k+ ★★★★★ 入门 状态图、循环、分支
Anthropic Cookbook 10k+ ★★★★★ 入门 Function Calling 最佳实践
GPT-Researcher 15k+ ★★★★★ 进阶 完整 Agent 流程
AutoGPT 170k+ ★★★★☆ 进阶 Agent 自主性
AgentGPT 32k+ ★★★★☆ 进阶 Web 应用架构
OpenHands 40k+ ★★★★★ Code Agent 代码库操作
SWE-agent 15k+ ★★★★☆ Code Agent 代码修复
Continue 20k+ ★★★★★ Code Agent IDE 集成
CrewAI 25k+ ★★★★★ 多 Agent 角色扮演协作
AutoGen 35k+ ★★★★★ 多 Agent 对话协作
MetaGPT 45k+ ★★★★★ 多 Agent 模拟软件团队
Dify 50k+ ★★★★★ 生产级 企业级架构

总结

看完这两篇博客，你应该：

  1. 概念清晰：知道 Agent、Tool、Function Calling、ReAct、RAG 等核心名词的含义
  2. 路线明确：知道从哪个项目开始，怎么深入
  3. 实践有方：知道看项目要看什么、怎么学最快
  4. 职业定位：知道自己的后端经验如何转化为 Agent 开发优势

上一篇：Agent 编程名词词典：产品视角与技术视角的双面解读