MetaGPT 框架
MetaGPT 是一个模拟软件公司运作的多智能体框架，将软件开发过程建模为产品经理、架构师、程序员、测试等角色的协作。它强调"标准化流程"和"角色分工"，非常适合软件开发、项目规划和需求分析场景。
一、核心原理
1.1 MetaGPT 设计哲学
MetaGPT 的核心思想是将软件开发团队"虚拟化"：
┌─────────────────────────────────────────────────────────────┐
│ MetaGPT 设计哲学 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统软件开发团队： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 产品经理 │ │ 架构师 │ │ 程序员 │ │ │
│ │ │ PM │ │Architect│ │ Engineer│ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ │ │ │ │ │
│ │ └────────────┼────────────┘ │ │
│ │ ↓ │ │
│ │ ┌─────────────┐ │ │
│ │ │ 软件产品 │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ │ 需要大量人力、时间、沟通成本 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ MetaGPT 虚拟团队： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ PM Agent│ │Arch Agent│ │Eng Agent│ │ │
│ │ │ (AI) │ │ (AI) │ │ (AI) │ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ │ │ │ │ │
│ │ └────────────┼────────────┘ │ │
│ │ ↓ │ │
│ │ ┌─────────────┐ │ │
│ │ │ 软件产品 │ │ │
│ │ │ (自动生成) │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ │ 一条需求指令 → 完整软件（PRD + 设计 + 代码） │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘1.2 核心概念
| 概念 | 英文 | 描述 | 示例 |
|---|---|---|---|
| Role | 角色 | 具有特定职责的 Agent | ProductManager、Architect |
| Action | 动作 | 角色执行的具体任务 | WritePRD、WriteDesign |
| Environment | 环境 | Agent 协作的工作空间 | Software Company |
| Message | 消息 | Agent 间的通信载体 | 需求文档、设计文档 |
| SOP | 标准作业程序 | 标准化的工作流程 | PRD → 设计 → 代码 → 测试 |
1.3 软件公司架构
┌─────────────────────────────────────────────────────────────┐
│ MetaGPT 软件公司架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 输入需求 │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Software Company │ │
│ │ (环境) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 标准作业流程 (SOP) │ │ │
│ │ │ │ │ │
│ │ │ Step 1: 需求分析 │ │ │
│ │ │ ┌─────────────┐ │ │ │
│ │ │ │ProductManager│ ──→ PRD 文档 │ │ │
│ │ │ └─────────────┘ │ │ │
│ │ │ ↓ │ │ │
│ │ │ Step 2: 系统设计 │ │ │
│ │ │ ┌─────────────┐ │ │ │
│ │ │ │ Architect │ ──→ 设计文档 │ │ │
│ │ │ └─────────────┘ │ │ │
│ │ │ ↓ │ │ │
│ │ │ Step 3: 代码实现 │ │ │
│ │ │ ┌─────────────┐ │ │ │
│ │ │ │ProjectManager│ ──→ 任务分配 │ │ │
│ │ │ └─────────────┘ │ │ │
│ │ │ ↓ │ │ │
│ │ │ ┌───────┐ ┌───────┐ ┌───────┐ │ │ │
│ │ │ │Engineer│ │Engineer│ │Engineer│ │ │ │
│ │ │ │ (FE) │ │ (BE) │ │ (QA) │ │ │ │
│ │ │ └───┬───┘ └───┬───┘ └───┬───┘ │ │ │
│ │ │ └─────────┼─────────┘ │ │ │
│ │ │ ↓ │ │ │
│ │ │ Step 4: 测试验收 │ │ │
│ │ │ ┌─────────────┐ │ │ │
│ │ │ │ QaEngineer │ ──→ 测试报告 │ │ │
│ │ │ └─────────────┘ │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ 输出：完整软件项目（文档 + 代码 + 测试） │
│ │
└─────────────────────────────────────────────────────────────┘二、核心组件详解
2.1 Role（角色）
Role 定义了 Agent 的职责和能力：
from metagpt.roles import Role
from metagpt.actions import Action
# 定义角色
class ProductManager(Role):
"""产品经理角色"""
name: str = "Alice"
profile: str = "Product Manager"
goal: str = "分析需求，产出高质量PRD"
constraints: List[str] = [
"遵循标准PRD格式",
"包含完整功能描述",
"明确验收标准"
]
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._watch([UserRequirement]) # 监听用户需求
self._init_actions([WritePRD]) # 初始化动作
async def _act(self) -> Message:
"""执行动作"""
# 获取待处理的消息
todo = self.todo()
# 执行 WritePRD 动作
prd = await todo.run(context=self.history)
# 发布 PRD 消息
return Message(content=prd, role=self.name, cause_by=WritePRD)2.2 Action（动作）
Action 定义了具体的工作内容：
from metagpt.actions import Action
# 定义动作
class WritePRD(Action):
"""编写 PRD 文档"""
name: str = "WritePRD"
async def run(self, context: List[Message]) -> str:
"""执行动作"""
# 提取需求信息
requirements = "\n".join([msg.content for msg in context])
# 使用 LLM 生成 PRD
prompt = f"""
作为产品经理，请根据以下需求编写 PRD 文档：
{requirements}
PRD 格式要求：
1. 项目背景
2. 用户故事
3. 功能需求
4. 非功能需求
5. 验收标准
"""
prd = await self.llm.aask(prompt)
return prd
class WriteDesign(Action):
"""编写设计文档"""
name: str = "WriteDesign"
async def run(self, prd: str) -> str:
"""根据 PRD 生成设计文档"""
prompt = f"""
作为架构师，请根据以下 PRD 编写系统设计：
{prd}
设计文档格式：
1. 系统架构
2. 模块设计
3. API 设计
4. 数据库设计
5. 技术选型
"""
design = await self.llm.aask(prompt)
return design2.3 Environment（环境）
Environment 管理 Agent 的协作：
from metagpt.environment import Environment
from metagpt.roles import ProductManager, Architect, ProjectManager
# 创建环境
class SoftwareCompany(Environment):
"""软件公司环境"""
def __init__(self):
super().__init__()
# 添加角色
self.add_roles([
ProductManager(),
Architect(),
ProjectManager(),
Engineer(n="FE"),
Engineer(n="BE"),
QaEngineer(),
])
async def run_project(self, idea: str):
"""运行项目"""
# 发布初始需求
await self.publish_message(
Message(content=idea, cause_by=UserRequirement)
)
# 运行直到完成
await self.run()2.4 Message（消息）
Message 是 Agent 间的通信载体：
from metagpt.schema import Message
# 创建消息
message = Message(
content="开发一个 TODO 应用", # 消息内容
role="User", # 发送者角色
cause_by=UserRequirement, # 触发原因
sent_from="User", # 发送者
send_to=["ProductManager"], # 接收者列表
metadata={ # 元数据
"priority": "high",
"timestamp": "2026-03-19T00:00:00Z"
}
)三、代码实现
3.1 基础示例：自动生成项目
"""
MetaGPT 基础示例：自动生成软件项目
展示完整的软件开发流程
"""
import asyncio
from metagpt.roles import (
ProductManager,
Architect,
ProjectManager,
Engineer,
QaEngineer
)
from metagpt.environment import Environment
from metagpt.schema import Message
from metagpt.const import USER_REQUIREMENT
# 配置 LLM
from metagpt.config2 import Config
config = Config.default()
config.llm.model = "gpt-4"
async def develop_software(idea: str):
"""自动开发软件"""
# 创建软件公司环境
company = Environment()
# 添加角色
company.add_roles([
ProductManager(),
Architect(),
ProjectManager(),
Engineer(),
QaEngineer(),
])
# 发布需求
company.publish_message(
Message(content=idea, cause_by=USER_REQUIREMENT)
)
# 运行
await company.run()
# 获取产出
print("项目完成！产出文件：")
for role in company.roles:
print(f"- {role.name}: {role.working_memory}")
if __name__ == "__main__":
asyncio.run(develop_software("""
开发一个在线待办事项管理系统：
核心功能：
- 用户注册登录
- 创建/编辑/删除待办
- 待办分类和标签
- 到期提醒
- 数据统计和可视化
"""))3.2 进阶示例：自定义角色
"""
MetaGPT 进阶示例：自定义角色和动作
"""
from metagpt.roles import Role
from metagpt.actions import Action
from metagpt.schema import Message
from typing import List
# ==================== 自定义动作 ====================
class AnalyzeMarket(Action):
"""市场分析动作"""
name: str = "AnalyzeMarket"
async def run(self, product_idea: str) -> str:
"""分析市场"""
prompt = f"""
作为市场分析师，分析以下产品的市场机会：
{product_idea}
分析维度：
1. 目标用户群体
2. 市场规模估算
3. 竞品分析
4. 差异化优势
5. 市场进入策略
"""
return await self.llm.aask(prompt)
class TechnicalFeasibility(Action):
"""技术可行性分析"""
name: str = "TechnicalFeasibility"
async def run(self, product_idea: str, market_analysis: str) -> str:
"""分析技术可行性"""
prompt = f"""
作为技术顾问，评估产品的技术可行性：
产品想法：{product_idea}
市场分析：{market_analysis}
评估内容：
1. 核心技术栈选择
2. 技术风险识别
3. 开发周期估算
4. 团队配置建议
5. 技术成本评估
"""
return await self.llm.aask(prompt)
# ==================== 自定义角色 ====================
class MarketAnalyst(Role):
"""市场分析师角色"""
name: str = "Bob"
profile: str = "Market Analyst"
goal: str = "提供深入的市场洞察"
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._init_actions([AnalyzeMarket])
async def _act(self) -> Message:
# 获取产品想法
idea = self.history[-1].content
# 执行市场分析
analysis = await self.todo().run(idea)
return Message(content=analysis, role=self.name)
class TechnicalAdvisor(Role):
"""技术顾问角色"""
name: str = "Charlie"
profile: str = "Technical Advisor"
goal: str = "评估技术可行性和风险"
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._init_actions([TechnicalFeasibility])
async def _act(self) -> Message:
# 获取产品想法和市场分析
idea = self.history[0].content
market_analysis = self.history[-1].content
# 执行技术可行性分析
feasibility = await self.todo().run(idea, market_analysis)
return Message(content=feasibility, role=self.name)
# ==================== 运行 ====================
async def analyze_product(idea: str):
"""分析产品"""
from metagpt.environment import Environment
env = Environment()
env.add_roles([MarketAnalyst(), TechnicalAdvisor()])
env.publish_message(Message(content=idea))
await env.run()
print("分析完成！")
if __name__ == "__main__":
asyncio.run(analyze_product("开发一款 AI 驱动的个人理财助手"))3.3 标准化流程配置
"""
MetaGPT 流程配置示例
展示如何自定义开发流程
"""
from metagpt.roles import Role
from metagpt.actions import Action
from metagpt.environment import Environment
# 定义流程步骤
DEVELOPMENT_PROCESS = [
("ProductManager", ["WritePRD"]), # Step 1: PM 写 PRD
("Architect", ["WriteDesign"]), # Step 2: 架构师写设计
("ProjectManager", ["WriteTasks"]), # Step 3: PM 分配任务
("Engineer", ["WriteCode"]), # Step 4: 工程师写代码
("QaEngineer", ["WriteTest"]), # Step 5: QA 写测试
]
class CustomSoftwareCompany(Environment):
"""自定义软件开发公司"""
def __init__(self, process=None):
super().__init__()
self.process = process or DEVELOPMENT_PROCESS
self._setup_roles()
def _setup_roles(self):
"""根据流程设置角色"""
for role_name, actions in self.process:
role = self._create_role(role_name, actions)
self.add_role(role)
def _create_role(self, role_name: str, actions: List[str]) -> Role:
"""创建角色"""
action_classes = [get_action(a) for a in actions]
role_class = get_role(role_name)
return role_class(actions=action_classes)
async def develop(self, idea: str):
"""按流程开发"""
# 发布需求
await self.publish_message(
Message(content=idea, cause_by="UserRequirement")
)
# 按流程执行
for role_name, _ in self.process:
role = self.get_role(role_name)
await role.act()四、工作流程
4.1 标准开发流程
┌─────────────────────────────────────────────────────────────┐
│ MetaGPT 标准开发流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 输入: "开发一个 TODO 应用" │
│ │
│ Step 1: 需求分析 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Product Manager │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 输入: 用户需求 │ │ │
│ │ │ 输出: PRD 文档 │ │ │
│ │ │ │ │ │
│ │ │ 内容: │ │ │
│ │ │ • 项目背景 │ │ │
│ │ │ • 用户故事 │ │ │
│ │ │ • 功能需求列表 │ │ │
│ │ │ • 非功能需求 │ │ │
│ │ │ • 验收标准 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ Step 2: 系统设计 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Architect │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 输入: PRD 文档 │ │ │
│ │ │ 输出: 设计文档 + API 设计 │ │ │
│ │ │ │ │ │
│ │ │ 内容: │ │ │
│ │ │ • 系统架构图 │ │ │
│ │ │ • 模块划分 │ │ │
│ │ │ • API 接口设计 │ │ │
│ │ │ • 数据库设计 │ │ │
│ │ │ • 技术选型说明 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ Step 3: 任务分配 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Project Manager │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 输入: 设计文档 │ │ │
│ │ │ 输出: 任务列表 + 排期 │ │ │
│ │ │ │ │ │
│ │ │ 内容: │ │ │
│ │ │ • 任务分解 │ │ │
│ │ │ • 优先级排序 │ │ │
│ │ │ • 工作量估算 │ │ │
│ │ │ • 人员分配 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ Step 4: 代码实现 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Engineer │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 输入: 任务 + 设计文档 │ │ │
│ │ │ 输出: 源代码文件 │ │ │
│ │ │ │ │ │
│ │ │ 内容: │ │ │
│ │ │ • 前端代码 │ │ │
│ │ │ • 后端代码 │ │ │
│ │ │ • 数据库脚本 │ │ │
│ │ │ • 配置文件 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ Step 5: 测试验收 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ QA Engineer │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 输入: 代码 + PRD │ │ │
│ │ │ 输出: 测试报告 │ │ │
│ │ │ │ │ │
│ │ │ 内容: │ │ │
│ │ │ • 单元测试 │ │ │
│ │ │ • 集成测试 │ │ │
│ │ │ • 测试用例 │ │ │
│ │ │ • Bug 报告 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ 输出: 完整软件项目 │
│ - PRD.md │
│ - design.md │
│ - src/ │
│ - tests/ │
│ │
└─────────────────────────────────────────────────────────────┘4.2 消息流转
┌─────────────────────────────────────────────────────────────┐
│ 消息流转机制 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 用户发布需求 │
│ ┌───────────┐ │
│ │ User │ │
│ │ Message │ ──→ "开发 TODO 应用" │
│ └─────┬─────┘ │
│ │ │
│ ↓ │
│ 2. PM 监听并处理 │
│ ┌───────────┐ │
│ │ProductMgr │ │
│ │ _watch() │ ← 监听 UserRequirement │
│ │ _act() │ ──→ 生成 PRD │
│ └─────┬─────┘ │
│ │ │
│ ↓ │
│ 3. 架构师监听 PRD 完成 │
│ ┌───────────┐ │
│ │ Architect │ │
│ │ _watch() │ ← 监听 WritePRD │
│ │ _act() │ ──→ 生成设计文档 │
│ └─────┬─────┘ │
│ │ │
│ ↓ │
│ 4. 后续角色依次处理... │
│ │
│ 核心机制： │
│ • _watch(): 定义监听哪些消息类型 │
│ • _act(): 定义收到消息后执行的动作 │
│ • Message.cause_by: 消息的触发原因 │
│ │
└─────────────────────────────────────────────────────────────┘五、适用场景
5.1 最佳适用场景
| 场景 | 描述 | 配置建议 |
|---|---|---|
| 软件开发 | 从需求到代码的完整流程 | 默认角色配置 |
| 项目规划 | 需求分析和技术方案设计 | PM + Architect |
| 原型开发 | 快速生成可运行原型 | 全流程 |
| 技术预研 | 技术可行性评估 | 自定义分析角色 |
5.2 与其他框架对比
| 对比项 | MetaGPT | CrewAI | AutoGen |
|---|---|---|---|
| 协作模式 | 公司模拟 | 角色扮演 | 对话式 |
| 流程管理 | SOP 标准化 | Process 配置 | 动态协商 |
| 适用场景 | 软件开发 | 内容创作 | 代码开发 |
| 输出产物 | 完整项目 | 任务结果 | 对话结果 |
5.3 不适用场景
| 场景 | 原因 | 推荐替代 |
|---|---|---|
| 非软件项目 | 流程针对软件开发 | CrewAI |
| 灵活对话 | 流程相对固定 | AutoGen |
| 快速响应 | 多步骤流程耗时 | 单 Agent |
六、优缺点分析
6.1 优点
| 优点 | 描述 |
|---|---|
| 流程标准化 | SOP 确保输出质量一致 |
| 角色明确 | 专业分工，职责清晰 |
| 完整产出 | 从需求到代码的完整交付 |
| 可扩展 | 支持自定义角色和流程 |
| 可视化 | 支持架构图和流程图生成 |
6.2 缺点
| 缺点 | 描述 | 缓解方案 |
|---|---|---|
| 流程固定 | 不适合灵活场景 | 自定义流程 |
| 资源消耗大 | 多 Agent 多轮执行 | 减少角色数量 |
| 学习曲线 | 概念较多 | 从简单示例开始 |
七、面试问答
Q1: MetaGPT 的核心概念是什么？
回答： MetaGPT 的核心概念包括：
- Role：角色，定义 Agent 的职责和能力
- Action：动作，角色执行的具体任务
- Environment：环境，Agent 协作的工作空间
- SOP：标准作业程序，标准化的工作流程
Q2: MetaGPT 如何实现角色间的协作？
回答：
- 消息监听：角色通过
_watch()监听特定消息类型 - 动作执行：收到消息后通过
_act()执行动作 - 消息发布：动作完成后发布新消息触发下一角色
- 环境协调：Environment 管理消息传递和状态
Q3: MetaGPT 和 CrewAI 的区别是什么？
回答：
| 对比项 | MetaGPT | CrewAI |
|---|---|---|
| 设计理念 | 软件公司模拟 | 角色扮演团队 |
| 流程管理 | SOP 标准化 | Process 配置 |
| 适用场景 | 软件开发 | 内容创作 |
| 输出产物 | 完整项目 | 任务结果 |
Q4: 如何自定义 MetaGPT 的角色？
回答：
- 定义 Action：创建继承 Action 的动作类
- 定义 Role：创建继承 Role 的角色类
- 配置监听：使用
_watch()定义监听的消息类型 - 配置动作：使用
_init_actions()定义可执行的动作
八、小结
| 概念 | 一句话总结 | 面试关键词 |
|---|---|---|
| MetaGPT | 模拟软件公司运作的多智能体框架 | Role、Action、Environment、SOP |
| 标准化流程 | PRD → 设计 → 代码 → 测试 | ProductManager、Architect、Engineer |
| 角色协作 | 通过消息监听和发布实现 | _watch、_act、Message |
| 适用场景 | 软件开发、项目规划 | 完整项目产出 |
一句话总结：MetaGPT 通过模拟软件公司的标准化流程，实现了从需求到代码的自动化软件开发，是软件开发场景的首选多智能体框架。
最后更新：2026年3月19日