基于CrewAI 多 Agent 软件研发团队案例

使用langchain或langgraph实现多智能体协助固然可以比较灵活，单过程过于复杂，CrewAI 以智能体角色驱动，基于它开发做智能体协同可以大大降低难度，如果你有简单的工作流，你也可以开发自己的agents军团，让他们为你干活。如果你有多智能体开发的需求不防看看这个项目，为大家准备了开发文档和源码，开箱即用。

https://github.com/share-budaozhe/AI-DevelopmentCourse/tree/master/crewai-demo

一、项目需求

1. 项目背景

在 AI Agent 技术的发展中，单一 Agent 的能力常常不足以应对复杂、多领域的任务。多智能体协作系统（Multi-Agent Collaboration System） 通过让多个具有不同专长的 Agent 协同工作，实现了"1+1>2"的效果。

CrewAI 是目前最流行的多 Agent 框架之一，专注于角色驱动（Role-Based）的 Agent 协作。与 LangGraph 的"状态图编排"思路不同，CrewAI 更贴近"组建团队、分配任务、各自完成"的人类协作模式。

本 Demo 以软件研发团队为场景，展示如何使用 CrewAI 构建一个高效的 5 人 Agent 团队，完成从需求分析到部署上线的完整软件开发生命周期。

2. 项目目标

展示 CrewAI 核心概念
：Agent（角色）、Task（任务）、Crew（团队）、Process（执行模式）
提供可运行的示例
：5 个角色 Agent 协作完成真实软件开发流程
对比框架差异
：直观感受 CrewAI 与 LangGraph 在设计理念和使用方式上的差异
建立最佳实践
：Agent 角色设计、Task 拆分粒度、上下文传递等工程实践

3. 项目范围

维度	内容
覆盖场景	需求分析 → 架构设计 → 代码实现 → 质量测试 → 部署方案
Agent 数量	5 个（产品经理、架构师、开发工程师、测试工程师、运维工程师）
框架	CrewAI
执行模式	Sequential（顺序）为主，支持 Hierarchical（层级）
工具支持	需求分析、技术栈推荐、代码审查、部署检查、知识检索

4. CrewAI vs LangGraph 对比

特性	CrewAI	LangGraph
设计理念	角色驱动的团队协作	状态图驱动的流程编排
Agent 定义	role + goal + backstory	自定义节点 + 提示词
任务管理	Task 对象，自动上下文传递	手动在 State 中传递数据
执行模式	Sequential / Hierarchical	自定义图（DAG）
工具绑定	内置 BaseTool 基类	通过 LangChain Tool
记忆能力	内置 Memory 模块	需自行实现
学习曲线	低——概念直观，上手快	中——需理解图编程
灵活性	中等——框架约束了结构	高——完全自定义图结构
适用场景	角色分工明确的任务	复杂条件路由和分支

5. 适用场景

5.1 学习

学习 CrewAI 框架的核心概念和 API
对比不同多 Agent 框架的设计哲学
团队培训中的动手实验案例

5.2 原型验证

快速搭建多 Agent 协作原型
验证 Agent 角色定义对团队效能的影晌
评估不同 LLM 在角色扮演场景下的表现

5.3 实际应用

内容创作团队（选题→调研→写作→编辑→发布）
代码开发团队（需求→设计→编码→测试→部署）
研究分析团队（资料收集→分析→报告撰写→审核→发布）
客户服务团队（接入→分析→解决方案→审核→回复）

6. 项目价值

学习价值
：将 CrewAI 的核心概念转化为可运行的具体代码
对比价值
：与项目中的 LangGraph Demo 形成对比参考
工程价值
：提供 CrewAI 项目的最佳实践和代码模板
扩展价值
：模块化设计，易于替换 Agent 角色和工具集

二、CrewAI 多 Agent 软件研发团队 —— 流程图

1. 整体协作流程

                          ┌─────────────┐                          │  用户输入    │                          │  项目需求    │                          └──────┬──────┘                                 │                  ┌──────────────▼──────────────┐                  │       CrewAI Crew            │                  │  Process: Sequential         │                  │  Memory: Enabled             │                  │  Planning: Enabled           │                  └──────────────┬──────────────┘                                 │         ┌───────────────────────┼───────────────────────┐         │                       │                       │         ▼                       ▼                       ▼┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐│   Task 1        │   │   Task 2        │   │   Task 3        ││ 📋 需求分析      │──▶│ 🏗️ 架构设计      │──▶│ 💻 代码实现      ││                 │   │                 │   │                 ││ Agent: 产品经理  │   │ Agent: 架构师    │   │ Agent: 开发工程师││ Output: PRD     │   │ Output: 技术方案 │   │ Output: 代码    │└─────────────────┘   └─────────────────┘   └─────────────────┘                                                      │                          ┌───────────────────────────┘                          │                          ▼         ┌───────────────────────────────┐         │           Task 4              │         │        🧪 质量测试             │         │                               │         │ Agent: 测试工程师              │         │ Output: 测试报告              │         └───────────────┬───────────────┘                         │                         ▼         ┌───────────────────────────────┐         │           Task 5              │         │        🚀 部署方案             │         │                               │         │ Agent: DevOps 运维工程师       │         │ Output: 部署方案 + 运维手册    │         └───────────────┬───────────────┘                         │                         ▼                  ┌─────────────┐                  │  最终交付   │                  │  完整方案   │                  └─────────────┘

2. 单 Agent 执行流程

┌─────────────────────────────────────────────────────────┐│                   Task 开始                              │└────────────────────┬────────────────────────────────────┘                     │                     ▼┌─────────────────────────────────────────────────────────┐│  1. 上下文收集                                           ││  - 读取上游 Task 的输出（通过 context 自动注入）          ││  - 加载 Crew Memory 中的相关记忆                         │└────────────────────┬────────────────────────────────────┘                     │                     ▼┌─────────────────────────────────────────────────────────┐│  2. 提示词构建                                           ││  ┌─────────────────────────────────────────────────┐   ││  │ System: role + goal + backstory                 │   ││  │ Context: 上游任务输出（自动拼接）                 │   ││  │ Task: description + expected_output             │   ││  │ Memory: 历史记忆（如启用）                        │   ││  └─────────────────────────────────────────────────┘   │└────────────────────┬────────────────────────────────────┘                     │                     ▼┌─────────────────────────────────────────────────────────┐│  3. LLM 推理循环（max_iter 次）                          ││  ┌─────────────────────────────────────────────────┐   ││  │ LLM 思考 → 需要工具？                            │   ││  │   ├── 是 → 调用工具 → 获取结果 → 继续思考        │   ││  │   └── 否 → 生成最终输出                          │   ││  └─────────────────────────────────────────────────┘   │└────────────────────┬────────────────────────────────────┘                     │                     ▼┌─────────────────────────────────────────────────────────┐│  4. 输出处理                                             ││  - 生成 TaskOutput（包含 raw + parsed 内容）             ││  - 存储到 Crew Memory                                   ││  - 传递给下一个 Task 的 context                          │└────────────────────┬────────────────────────────────────┘                     │                     ▼┌─────────────────────────────────────────────────────────┐│  5. 错误处理（如发生）                                    ││  - 捕获异常 → 记录错误信息 → 标记 Task 失败              ││  - CrewAI 内置重试机制                                   │└─────────────────────────────────────────────────────────┘

3. Sequential vs Hierarchical 模式

Sequential（顺序模式）              Hierarchical（层级模式）─────────────────────────          ────────────────────────   Task 1                            ┌─────────────┐     │                               │   Manager   │     ▼                               │   Agent     │   Task 2                            └──┬───┬───┬──┘     │                               │   │   │   │     ▼                               ▼   ▼   ▼   ▼   Task 3                           T1  T2  T3  T4  T5     │                               ▲   ▲   ▲   ▲   ▲     ▼                               │   │   │   │   │   Task 4                           └───┴───┴───┴───┘     │                              Manager 动态分配,     ▼                              可能并行, 可能重试,   Task 5                            可能改变顺序 特点:                            特点: - 固定顺序                         - 动态调度 - 自动上下文传递                    - Manager 协调 - 确定性强                          - 灵活性高 - 适合流水线任务                    - 适合复杂不确定任务

4. 上下文传递机制

┌─────────┐     ┌─────────┐     ┌─────────┐│ Task 1  │     │ Task 2  │     │ Task 3  ││         │     │         │     │         ││ Output  │────▶│ Input:  │     │         ││ (PRD)   │     │ - Topic │     │         ││         │     │ - PRD   │────▶│ Input:  ││         │     │         │     │ - Topic ││         │     │ Output  │     │ - PRD   ││         │     │ (架构)   │     │ - 架构   │└─────────┘     └─────────┘     │         │                                │ Output  │                                │ (代码)   │                                └─────────┘CrewAI 自动将上游 Task 输出作为下游 Task 的上下文注入，无需手动管理 State。每个 Task 可以访问所有 context 中指定的上游输出。

5. 工具调用流程

Agent 执行中...     │     ▼需要搜索技术资料？     │     ├── 是 → 调用 knowledge_search("微服务架构")     │         │     │         ▼     │       工具返回结果     │         │     │         └──→ Agent 将结果融入思考     │     ▼需要推荐技术栈？     │     ├── 是 → 调用 tech_stack_recommender("web")     │         │     │         ▼     │       返回推荐栈     │         │     │         └──→ Agent 基于推荐做决策     │     ▼继续推理 → 生成最终输出

6. 项目文件结构

crewai-demo/├── main.py                          # 🚀 主入口 (Rich CLI)├── requirements.txt                 # 📦 依赖清单├── .env.example                     # 🔑 环境变量模板├── README.md                        # 📖 项目说明├── src/│   ├── config.py                    # ⚙️ LLM 配置管理│   ├── crew.py                      # 🎯 Crew 编排逻辑│   ├── agents/                      # 🤖 Agent 定义│   │   ├── product_manager.py       #   产品经理│   │   ├── architect.py             #   系统架构师│   │   ├── developer.py             #   开发工程师│   │   ├── tester.py                #   测试工程师│   │   └── devops.py               #   运维工程师│   ├── tasks/                       # 📋 Task 定义│   │   └── tasks.py                 #   5 个阶段任务│   └── tools/                       # 🔧 自定义工具│       └── tools.py                 #   5 个工具类├── tests/│   └── test_crew.py                 # 🧪 测试套件└── docs/    ├── 项目说明.md                   # 📄 项目说明文档    ├── 实现原理.md                   # 🔬 技术实现详解    ├── 技术要点.md                   # 💡 技术要点与调试    └── 流程图.md                     # 🗺️ 流程与架构图

三、CrewAI 多 Agent 软件研发团队 —— 实现原理

1. 核心架构

本系统采用 CrewAI 的 角色驱动协作架构（Role-Based Collaboration Architecture），由 5 个专职 Agent 组成软件开发团队，通过 Crew 进行任务编排和上下文传递。

┌─────────────────────────────────────────────────────┐│                  用户接口层                           ││            main.py (CLI / Rich UI)                   │└────────────────────┬────────────────────────────────┘                     │┌────────────────────▼────────────────────────────────┐│                  Crew 编排层                          ││   Crew (agents + tasks + process + memory + plan)    ││   ┌──────────────────────────────────────────────┐  ││   │  Sequential Process:                          │  ││   │  Task 1 → Task 2 → Task 3 → Task 4 → Task 5   │  ││   │  (每个 Task 的输出自动成为下一 Task 的上下文)    │  ││   └──────────────────────────────────────────────┘  │└────────────────────┬────────────────────────────────┘                     │┌────────────────────▼────────────────────────────────┐│                   Agent 层                            ││  ┌──────────┐ ┌──────────┐ ┌──────────┐             ││  │📋 产品经理│→│🏗️ 架构师 │→│💻 开发   │            ││  │ PRD文档  │ │ 技术方案  │ │ 代码实现  │            ││  └──────────┘ └──────────┘ └──────────┘             ││  ┌──────────┐ ┌──────────┐                          ││  │🧪 测试   │→│🚀 运维   │                          ││  │ 测试报告  │ │ 部署方案  │                          ││  └──────────┘ └──────────┘                          │└────────────────────┬────────────────────────────────┘                     │┌────────────────────▼────────────────────────────────┐│                  工具与基础设施层                      ││  ┌──────────┐ ┌──────────┐ ┌──────────┐             ││  │需求分析工具│ │技术栈推荐 │ │代码审查  │             ││  └──────────┘ └──────────┘ └──────────┘             ││  ┌──────────┐ ┌──────────┐                          ││  │部署检查  │ │知识检索  │   内存记忆 + 任务规划      ││  └──────────┘ └──────────┘                          │└─────────────────────────────────────────────────────┘

2. CrewAI 核心概念

2.1 Agent（智能体）

CrewAI 的 Agent 是角色驱动的，每个 Agent 包含 4 个核心属性：

Agent(    role="产品经理",           # 角色名称 —— 定义 Agent 的身份    goal="产出 PRD 文档",      # 目标 —— Agent 要达成什么    backstory="10年经验...",   # 背景故事 —— 塑造 Agent 的行为风格    tools=[...],              # 工具 —— Agent 可以调用的能力    llm=llm,                  # LLM —— 驱动 Agent 的大语言模型    allow_delegation=False,   # 是否允许委托其他 Agent    verbose=True,             # 是否输出详细日志)

设计原则：

角色聚焦
：每个 Agent 只负责一个领域，避免"万能 Agent"
背景塑造行为
：backstory 不仅提供上下文，更塑造输出风格和决策偏好
工具按需分配
：只给 Agent 它真正需要的工具，避免"工具过载"

2.2 Task（任务）

Task 定义了 Agent 要完成的具体工作：

Task(    description="详细的任务描述...",  # 任务说明（可引用其他任务输出）    expected_output="期望的输出格式",  # 明确输出预期    agent=product_manager,             # 负责执行的 Agent    context=[previous_task],           # 依赖的上游任务)

Task 设计要点：

description
中可引用 {topic} 等变量实现参数化
expected_output
帮助 Agent 聚焦输出方向
context
建立了任务间的依赖关系，CrewAI 自动传递上下文

2.3 Crew（团队）

Crew 是将 Agent 和 Task 组合在一起的编排器：

Crew(    agents=[...],                    # 团队成员    tasks=[...],                     # 任务列表    process=Process.sequential,      # 执行模式    memory=True,                     # 启用记忆    planning=True,                   # 启用任务规划    verbose=True,                    # 详细日志)

2.4 Process（执行模式）

模式	说明	适用场景
Sequential	任务按列表顺序依次执行，前一个输出自动传入下一个	流水线式工作流，步骤固定
Hierarchical	CrewAI 自动创建一个 Manager Agent，负责任务分发和协调	复杂任务，需要动态调度

3. 关键设计决策

3.1 为什么选择 Sequential 模式？

本 Demo 展示的软件研发流程是典型的流水线模式——每个阶段的输出是下一阶段的输入。Sequential 模式完美匹配这种场景：

需求 → 架构 → 开发 → 测试 → 部署
每个阶段的上下文自动传递，无需手动管理

Hierarchical 模式更适合任务不确定的场景，例如"分析这个代码库并给出改进建议"——Manager Agent 需要动态决定先做什么、后做什么。

3.2 工具设计策略

本 Demo 实现了 5 个工具，分配给不同 Agent：

工具	分配给	原因
requirement_analyzer	产品经理	辅助需求结构化
tech_stack_recommender	架构师	辅助技术选型
code_reviewer	开发 + 测试	开发和测试都需要审查代码
deploy_checker	运维	验证部署条件
knowledge_search	架构师 + 开发 + 运维	通用知识检索需求

3.3 记忆机制（Memory）

CrewAI 内置了 Memory 模块，包括：

短期记忆
：当前 Crew 执行过程中的上下文
长期记忆
：跨 Crew 执行的知识积累（需配置向量存储）
实体记忆
：对关键实体（如用户、项目）的信息存储

本 Demo 启用了 memory=True，使 Agent 在协作过程中能"记住"之前讨论的关键信息。

3.4 上下文传递机制

CrewAI 的上下文传递与 LangGraph 的 State 传递有明显区别：

# LangGraph 方式：显式状态管理class AgentState(TypedDict):    research_output: str    analysis_output: str    # ...# CrewAI 方式：自动上下文注入task2.context = [task1]  # task1 的输出自动注入到 task2 的提示词中

CrewAI 的上下文传递更"黑盒"——你不需要定义 State 结构，框架自动将上游任务输出拼接为一个上下文块，注入到下游任务的提示词中。

4. 执行流程详解

1. kickoff() 触发   │2. CrewAI 检查 process 类型   ├── Sequential → 按 tasks 列表顺序执行   └── Hierarchical → Manager Agent 规划执行顺序   │3. 对于每个 Task:   ├── 收集 context 中依赖任务的输出   ├── 构建完整 Prompt（role + goal + backstory + context + description）   ├── Agent 调用 LLM + Tools 执行   ├── Agent 可能需要多轮 tool calling 迭代（由 max_iter 控制）   ├── 生成 TaskOutput   └── 存储到记忆（如启用）   │4. 所有 Task 完成后   └── 返回 CrewOutput（包含最终结果和各 Task 输出）

5. 与传统 LangGraph 方案的差异

方面	CrewAI	LangGraph（原 multi-agent-demo）
Agent 定义	role + goal + backstory	自定义 Python 函数 + System Prompt
状态管理	自动上下文传递	显式 TypedDict State
流程控制	Sequential / Hierarchical	自定义图结构（add_node/add_edge）
错误处理	框架内置重试	需手动 try/except + 条件路由
工具集成	继承 BaseTool	使用 @tool 装饰器或 BaseTool
记忆	内置 Memory	需自行实现（共享上下文字典）
代码量	较少——框架完成大量工作	较多——需显式管理状态和路由

四、CrewAI 多 Agent 软件研发团队 —— 技术要点

1. 环境配置

1.1 Python 版本

要求 Python >= 3.10，推荐 Python 3.11+。

1.2 依赖安装

pip install -r requirements.txt

1.3 API Key 配置

cp .env.example .env

编辑 .env 文件，填入你的 API Key。支持以下 LLM Provider：

Provider	需要配置的环境变量
OpenAI	`OPENAI_API_KEY`, `OPENAI_MODEL`
DeepSeek	`DEEPSEEK_API_KEY`, `DEEPSEEK_MODEL`, `DEEPSEEK_BASE_URL`
Anthropic	`ANTHROPIC_API_KEY`, `ANTHROPIC_MODEL`

切换 Provider 只需修改 LLM_PROVIDER 环境变量。

2. CrewAI 核心 API

2.1 Agent 创建

from crewai import Agentagent = Agent(    role="角色名称",          # 必填：定义 Agent 的身份    goal="要达成的目标",      # 必填：Agent 的核心目标    backstory="背景故事",     # 推荐：塑造 Agent 的行为风格    tools=[tool1, tool2],    # 可选：Agent 可调用的工具列表    llm=llm_instance,        # 可选：默认使用 OPENAI_API_KEY    verbose=True,            # 可选：是否输出详细日志    allow_delegation=False,  # 可选：是否允许委托其他 Agent    max_iter=5,              # 可选：最大工具调用迭代次数)

最佳实践：

backstory
应包含角色经验、工作习惯、决策偏好
为不同角色设置不同的 temperature（架构师低温度，创意角色高温度）
allow_delegation=True
仅用于 Manager 或需要协调的角色

2.2 Task 定义

from crewai import Tasktask = Task(    description="详细的任务描述",      # 必填    expected_output="期望的输出格式",  # 推荐：帮助 Agent 聚焦    agent=agent_instance,              # 必填：指派 Agent    context=[previous_task],           # 可选：依赖的上游任务    async_execution=False,             # 可选：是否异步执行)