MetaGPT：用 Agent 团队重新定义软件开发

引言：从单一 Agent 到 Agent 协作

在大语言模型（LLM）的浪潮中，基于 AI Agent 的应用开发已经从单一 Agent 系统演进到多 Agent 协作系统。MetaGPT 作为一个创新性的多 Agent 框架，将软件公司的组织结构和工作流程映射到 AI Agent 的协作中，实现了从一行需求到完整软件项目的自动化生成。

MetaGPT 的核心理念可以用一个公式表达：Code = SOP(Team)。这意味着通过将标准操作流程（SOP）应用于由大语言模型组成的团队，可以生成高质量的代码和完整的软件项目。

本文将深入探讨 MetaGPT 的架构设计、Agent 协作机制，以及如何通过代码实现这一切。

一、Agent 架构设计：模拟真实软件团队

MetaGPT 的独特之处在于它将真实软件公司的角色体系映射到了 Agent 系统中。每个 Agent 扮演一个特定的角色，例如产品经理（ProductManager）、架构师（Architect）、工程师（Engineer）等。这些 Agent 不是孤立工作的，而是通过标准化的消息传递机制进行协作。

Role 基类：Agent 的骨架

在 MetaGPT 中，所有的 Agent 都继承自 Role 基类。让我们看看 Role 类的核心定义（metagpt/roles/role.py）：

class Role(BaseRole, SerializationMixin, ContextMixin, BaseModel):
    """Role/Agent"""

    name: str = ""                      # Agent 的名称
    profile: str = ""                   # 角色类型
    goal: str = ""                      # 主要目标
    constraints: str = ""               # 操作约束
    actions: list[Action] = []          # 可执行的动作列表
    rc: RoleContext                     # 运行时上下文

    # 记忆系统
    enable_memory: bool = True

    # 状态机
    states: list[str] = []

    # 反应模式
    # REACT: 动态响应消息
    # BY_ORDER: 按预定义顺序执行动作
    # PLAN_AND_ACT: 先规划再执行

这个设计非常优雅：每个 Agent 都有明确的身份（name、profile）、目标（goal）、能力（actions）和约束（constraints）。通过 RoleContext，Agent 可以维护自己的状态、记忆和待办事项。

Agent 的三种工作模式

MetaGPT 为 Agent 提供了三种反应模式，对应不同的工作场景：

模式一：REACT（响应式）
Agent 根据接收到的消息动态决定下一步行动。这类似于人类根据情况灵活应对。

模式二：BY_ORDER（顺序执行）
Agent 按照预定义的顺序执行动作序列。这适用于流程明确的任务，例如产品经理先准备文档，再编写 PRD。

模式三：PLAN_AND_ACT（规划后执行）
Agent 先制定计划，然后按计划执行。这结合了前两种模式的优势，适合复杂任务。

class RoleReactMode(str, Enum):
    REACT = "react"
    BY_ORDER = "by_order"
    PLAN_AND_ACT = "plan_and_act"

RoleContext：Agent 的运行时环境

每个 Agent 都有一个运行时上下文 RoleContext，它管理 Agent 的状态和记忆：

class RoleContext(BaseModel):
    """Role Runtime Context"""

    env: BaseEnvironment = None              # 所在环境
    msg_buffer: MessageQueue                  # 消息缓冲区
    memory: Memory                            # 短期记忆
    working_memory: Memory                    # 工作记忆
    state: int = -1                           # 当前状态
    todo: Action = None                       # 待执行动作
    watch: set[str]                           # 关注的动作类型
    react_mode: RoleReactMode                 # 反应模式
    max_react_loop: int = 1                   # 最大反应循环次数

通过 watch 机制，Agent 可以订阅特定类型的消息。例如，架构师可以关注产品经理发出的 PRD 消息，从而在 PRD 生成后自动开始设计工作。

二、Message 消息系统：Agent 之间的通信协议

在多 Agent 系统中，消息传递是实现协作的核心机制。MetaGPT 设计了一套完整的消息系统，使得 Agent 之间能够高效、有序地交换信息。

Message 类：不仅仅是文本

MetaGPT 的 Message 类（metagpt/schema.py）不仅包含消息内容，还包含丰富的元数据用于路由和追溯：

class Message(BaseModel):
    """消息类：Agent 之间通信的基本单元"""

    id: str = Field(default="")                          # 唯一标识符
    content: str                                         # 自然语言内容
    instruct_content: Optional[BaseModel] = None         # 结构化内容
    role: str = "user"                                   # system/user/assistant

    # 路由机制的关键字段
    cause_by: str = ""                                   # 由哪个动作产生
    sent_from: str = ""                                  # 发送者角色
    send_to: set[str] = {MESSAGE_ROUTE_TO_ALL}          # 接收者角色集合

    # 元数据
    metadata: Dict[str, Any] = {}                        # 额外信息

这个设计的巧妙之处在于：

双重内容表示：content 字段存储自然语言描述，instruct_content 存储结构化数据。这使得消息既可以被人类理解，也可以被程序精确解析。

消息路由字段：通过 cause_by、sent_from 和 send_to 三个字段，实现了精确的消息路由。一个 Agent 可以选择性地接收它关心的消息类型。

唯一标识：每条消息都有唯一的 ID，便于追踪和调试整个协作过程。

消息路由：发布-订阅模式

MetaGPT 采用发布-订阅模式实现 Agent 之间的消息路由。让我们看一个具体的例子，产品经理 Agent 的定义（metagpt/roles/product_manager.py）：

class ProductManager(RoleZero):
    """产品经理 Agent"""

    name: str = "Alice"
    profile: str = "Product Manager"
    goal: str = "Create a Product Requirement Document"

    def __init__(self, **kwargs) -> None:
        super().__init__(**kwargs)

        # 设置可执行的动作序列
        self.set_actions([PrepareDocuments, WritePRD])

        # 订阅用户需求消息
        self._watch([UserRequirement, PrepareDocuments])

        # 使用顺序执行模式
        self.rc.react_mode = RoleReactMode.BY_ORDER

在这个例子中：

第一步，产品经理通过 _watch([UserRequirement]) 订阅用户需求消息。当用户发布需求时，产品经理 Agent 会被激活。

第二步，产品经理执行 PrepareDocuments 动作，准备相关文档。

第三步，产品经理执行 WritePRD 动作，生成产品需求文档。这个 PRD 会作为新消息发布出去。

第四步，架构师 Agent（订阅了 WritePRD 消息）接收到 PRD，开始设计系统架构。

这种链式反应形成了一个完整的工作流，就像真实的软件团队一样。

消息队列：异步处理的基础

为了支持异步消息处理，MetaGPT 实现了 MessageQueue 类：

class MessageQueue(BaseModel):
    """支持异步更新的消息队列"""

    _queue: Queue = PrivateAttr(default_factory=Queue)

    def pop(self) -> Message | None:
        """从队列中取出一条消息"""
        try:
            item = self._queue.get_nowait()
            if item:
                self._queue.task_done()
            return item
        except QueueEmpty:
            return None

    def push(self, msg: Message):
        """将消息推入队列"""
        self._queue.put_nowait(msg)

每个 Agent 的 RoleContext 都有一个消息缓冲区 msg_buffer，用于暂存接收到的消息。Agent 在每个思考循环中会从这个队列中取出消息并处理。

三、Action 行为系统：赋予 Agent 能力

如果说 Role 定义了"Agent 是谁"，那么 Action 就定义了"Agent 能做什么"。在 MetaGPT 中，每个具体的任务都被封装成一个 Action。

Action 基类：原子操作的抽象

Action 是 Agent 可以执行的原子操作。让我们看看 Action 的基本结构：

class Action(SerializationMixin, ContextMixin, BaseModel):
    """动作基类"""

    name: str = ""                              # 动作名称
    i_context: Union[dict, str, Message]        # 输入上下文
    prefix: str = ""                            # 系统提示词前缀
    node: ActionNode                            # 结构化输出定义

    async def run(self, *args, **kwargs):
        """执行动作的核心方法"""
        # 子类需要实现具体逻辑
        raise NotImplementedError

每个 Action 都有：

输入上下文（i_context）：定义了执行该动作需要的信息。

系统提示词（prefix）：引导 LLM 完成特定任务的指令。

结构化输出（node）：定义了动作的输出格式，确保结果可被解析。

执行方法（run）：实现具体的业务逻辑。

典型 Action 示例：WritePRD

让我们看一个实际的 Action 实现。WritePRD（编写产品需求文档）是产品经理 Agent 的核心能力之一：

class WritePRD(Action):
    """编写产品需求文档"""

    name: str = "WritePRD"

    async def run(self, requirements: str) -> ActionOutput:
        """
        执行 PRD 编写

        Args:
            requirements: 用户需求描述

        Returns:
            ActionOutput: 包含 PRD 文档的输出
        """
        # 1. 构造提示词
        prompt = self._build_prompt(requirements)

        # 2. 调用 LLM 生成 PRD
        prd_content = await self.llm.aask(prompt)

        # 3. 解析并结构化输出
        prd_doc = self._parse_prd(prd_content)

        # 4. 保存到文件系统
        await self._save_prd(prd_doc)

        # 5. 返回结果
        return ActionOutput(
            content=prd_content,
            instruct_content=prd_doc
        )

这个 Action 的执行流程清晰：接收需求 → 生成提示词 → 调用 LLM → 解析结果 → 保存文档 → 返回输出。

常见 Action 类型

MetaGPT 内置了丰富的 Action 库，覆盖软件开发的各个环节：

需求分析阶段

  • WritePRD：编写产品需求文档
  • PrepareDocuments：准备相关文档

设计阶段

  • WriteDesign：编写系统设计文档
  • DesignAPI：设计 API 接口

开发阶段

  • WriteCode：编写代码实现
  • WriteCodeReview：代码审查
  • FixBug：修复缺陷

测试阶段

  • WriteTest：编写测试用例
  • RunCode：执行代码和测试

每个 Action 都是一个独立的、可复用的模块，可以被不同的 Agent 使用。

Action 的组合：构建复杂工作流

Agent 可以通过组合多个 Action 来完成复杂任务。例如，工程师 Agent 可能需要先读取设计文档，然后编写代码，最后运行测试：

class Engineer(Role):
    """工程师 Agent"""

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        # 组合多个 Action
        self.set_actions([
            WriteCode,
            WriteTest,
            RunCode
        ])

        # 订阅设计文档消息
        self._watch([WriteDesign])

        # 使用顺序执行模式
        self.rc.react_mode = RoleReactMode.BY_ORDER

通过这种方式，我们可以灵活地定义 Agent 的能力边界和工作流程。

四、Team 与 Environment：Agent 团队的协作舞台

单个 Agent 可以完成特定任务，但真正的价值在于多个 Agent 的协同工作。MetaGPT 通过 Team 和 Environment 两个核心组件，实现了 Agent 团队的高效协作。

Team 类：组建 Agent 团队

Team 类（metagpt/team.py）负责管理和协调多个 Agent。让我们看看它的核心实现：

class Team(BaseModel):
    """
    Team: 拥有一个或多个角色（Agent）、标准操作流程（SOP）
    以及用于即时通讯的环境，致力于完成任何多 Agent 活动
    """

    env: Optional[Environment] = None       # 共享环境
    investment: float = 10.0                # 预算限制
    idea: str = ""                          # 项目目标

    def hire(self, roles: list[Role]):
        """招募角色加入团队"""
        self.env.add_roles(roles)

    def invest(self, investment: float):
        """投资公司，设置预算上限"""
        self.investment = investment
        self.cost_manager.max_budget = investment

    async def run(self, n_round=3, idea="", auto_archive=True):
        """运行团队直到达到目标轮次或预算耗尽"""
        if idea:
            self.run_project(idea=idea)

        while n_round > 0:
            if self.env.is_idle:
                logger.debug("所有角色都已空闲。")
                break

            n_round -= 1
            self._check_balance()
            await self.env.run()

        self.env.archive(auto_archive)
        return self.env.history

Team 的设计体现了几个关键思想：

招募机制（hire）：通过 hire 方法将不同角色的 Agent 添加到团队中，就像组建真实的项目团队一样。

预算管理（invest）：设置 API 调用的预算上限，避免成本失控。这在实际应用中非常重要。

轮次控制（run）：通过 n_round 参数限制协作的轮次，防止 Agent 之间无限循环对话。

空闲检测：当所有 Agent 都完成任务后，自动停止运行。

Environment：Agent 的共享工作空间

Environment 类是 Agent 之间交互的媒介，它维护消息历史、管理 Agent 状态、协调消息传递：

class Environment(BaseModel):
    """环境类：促进 Agent 之间的消息传递和观察"""

    desc: str                               # 环境描述
    roles: dict[str, Role]                  # 活跃的角色
    history: Memory                         # 消息历史

    def publish_message(self, message: Message):
        """向所有订阅的角色广播消息"""
        self.history.add(message)
        for role in self.roles.values():
            if self._should_receive(role, message):
                role.put_message(message)

    async def run(self):
        """执行一轮 Agent 交互"""
        # 1. 所有 Agent 观察消息
        for role in self.roles.values():
            await role.observe()

        # 2. 所有 Agent 思考并行动
        for role in self.roles.values():
            if role.has_todo():
                await role.react()

    def is_idle(self) -> bool:
        """检查是否所有 Agent 都已完成任务"""
        return all(not role.has_todo() for role in self.roles.values())

Environment 实现了两个核心功能：

消息广播：通过 publish_message 方法，将消息发送给所有订阅该消息的 Agent。这里使用了发布-订阅模式，只有关注特定消息类型的 Agent 才会接收。

协调执行：在每一轮执行中，Environment 先让所有 Agent 观察消息（observe），然后让有待办任务的 Agent 进行反应（react）。这确保了 Agent 之间的有序协作。

Agent 协作的完整流程

让我们通过一个完整的例子，看看多个 Agent 如何协作完成软件开发任务。以下是 generate_repo 函数（metagpt/software_company.py）的核心逻辑：

def generate_repo(idea, investment=3.0, n_round=5):
    """从一行需求生成完整的代码仓库"""

    # 1. 创建团队
    company = Team()

    # 2. 招募各角色 Agent
    company.hire([
        TeamLeader(),        # 团队领导
        ProductManager(),    # 产品经理
        Architect(),         # 架构师
        Engineer2(),         # 工程师
        DataAnalyst(),       # 数据分析师
    ])

    # 3. 设置预算
    company.invest(investment)

    # 4. 启动协作
    asyncio.run(company.run(n_round=n_round, idea=idea))

    return project_path

执行流程如下：

Round 1：用户需求被发布到环境中。产品经理 Agent 监听到 UserRequirement 消息，开始准备文档并编写 PRD。

Round 2：架构师 Agent 监听到 WritePRD 消息，读取 PRD 内容，开始设计系统架构，生成设计文档。

Round 3：工程师 Agent 监听到 WriteDesign 消息，根据设计文档开始编写代码。

Round 4：工程师继续完成代码实现，可能还会进行代码审查和测试。

Round 5：数据分析师 Agent 可能会生成项目总结和分析报告。

整个过程就像一个真实的软件团队在协作：产品经理定义需求，架构师设计系统，工程师编写代码，每个角色专注于自己的职责，通过文档和消息传递协作。

消息驱动的工作流

这种协作模式的核心是消息驱动：

用户需求 (UserRequirement)
    ↓
产品经理 → PRD 文档 (WritePRD)
    ↓
架构师 → 设计文档 (WriteDesign)
    ↓
工程师 → 代码实现 (WriteCode)
    ↓
测试工程师 → 测试用例 (WriteTest)
    ↓
完整项目

每个 Agent 只需要关注：接收什么消息 → 执行什么动作 → 发送什么消息。这种解耦的设计使得系统易于扩展和维护。

五、实战案例：用 Agent 团队创建一个 2048 游戏

理论讲完了，让我们通过一个实际案例来看看 MetaGPT 的 Agent 团队是如何工作的。我们将使用 MetaGPT 生成一个完整的 2048 游戏项目。

使用命令行接口

最简单的方式是使用 MetaGPT 的命令行工具：

metagpt "Create a 2048 game"

这一行命令会启动整个 Agent 团队，完成从需求分析到代码实现的全过程。让我们看看背后发生了什么。

使用 Python API

如果你想在代码中调用 MetaGPT，可以使用 Python API：

from metagpt.software_company import generate_repo
from metagpt.utils.project_repo import ProjectRepo

# 生成项目
repo: ProjectRepo = generate_repo("Create a 2048 game")

# 查看生成的项目结构
print(repo)

Agent 团队的工作流程

当你执行上述命令后，MetaGPT 的 Agent 团队会按以下流程协作：

第一轮：需求分析

产品经理 Agent（Alice）接收到用户需求"Create a 2048 game"。她会：

  1. 分析需求，理解 2048 游戏的核心玩法
  2. 搜索相关资料，了解市场上同类产品
  3. 编写产品需求文档（PRD），包括：
    • 游戏规则说明
    • 核心功能列表
    • 用户界面设计要求
    • 成功标准

产品经理生成的 PRD 会被保存到 docs/prd.md，并作为 WritePRD 消息发布出去。

第二轮：系统设计

架构师 Agent 监听到 WritePRD 消息，开始进行系统设计：

  1. 读取 PRD 文档
  2. 设计系统架构，确定技术栈（可能选择 Python + Pygame）
  3. 设计数据结构（游戏板、方块状态等）
  4. 设计 API 接口（移动、合并、检查胜负等）
  5. 生成设计文档和 UML 图

架构师生成的设计文档会保存到 docs/system_design.md，并发布 WriteDesign 消息。

第三轮：代码实现

工程师 Agent 监听到 WriteDesign 消息，开始编写代码：

  1. 读取设计文档，理解系统架构
  2. 实现游戏逻辑： 
    class Game2048:
    def __init__(self):
        self.board = [[0] * 4 for _ in range(4)]
        self.score = 0

    def move(self, direction):
        """处理移动操作"""
        # 实现上下左右移动逻辑
        pass

    def merge(self):
        """合并相同数字的方块"""
        # 实现合并逻辑
        pass

    def add_random_tile(self):
        """在空白处添加新方块"""
        # 实现添加方块逻辑
        pass

    def is_game_over(self):
        """检查游戏是否结束"""
        # 实现胜负判断逻辑
        pass
  3. 实现用户界面
  4. 编写主程序入口

所有代码会被保存到项目的相应目录中，例如 2048_game/game.py、2048_game/ui.py 等。

第四轮：测试和优化

如果启用了测试功能，QA 工程师 Agent 会：

  1. 为核心功能编写测试用例
  2. 运行测试，检查是否有 bug
  3. 如果发现问题，发送 FixBug 消息给工程师

第五轮：文档生成

数据分析师 Agent 可能会：

  1. 生成项目总结
  2. 创建 README 文档
  3. 记录开发过程中的关键决策

输出产物

完成所有轮次后，你会在 ./workspace 目录下得到一个完整的项目：

workspace/2048_game/
├── docs/
│   ├── prd.md                  # 产品需求文档
│   ├── system_design.md        # 系统设计文档
│   └── api_spec.md             # API 规范
├── 2048_game/
│   ├── __init__.py
│   ├── game.py                 # 游戏逻辑
│   ├── ui.py                   # 用户界面
│   └── main.py                 # 程序入口
├── tests/
│   └── test_game.py            # 测试用例
├── requirements.txt            # 依赖列表
└── README.md                   # 项目说明

运行生成的游戏

生成完成后，你可以直接运行：

cd workspace/2048_game
pip install -r requirements.txt
python 2048_game/main.py

一个可玩的 2048 游戏就启动了！

自定义 Agent 团队

你还可以根据需要自定义 Agent 团队。例如，如果你只想生成代码而不需要测试：

from metagpt.team import Team
from metagpt.roles import ProductManager, Architect, Engineer2

# 创建自定义团队
team = Team()
team.hire([
    ProductManager(),
    Architect(),
    Engineer2()
])

# 设置预算（控制 API 调用成本）
team.invest(5.0)

# 启动项目
import asyncio
asyncio.run(team.run(n_round=3, idea="Create a Snake game"))

这种灵活性使得 MetaGPT 可以适应不同的开发场景和需求。

六、深入理解：MetaGPT 的核心设计哲学

通过前面的分析，我们可以总结出 MetaGPT 的几个核心设计理念：

SOP（标准操作流程）的代码化

MetaGPT 最大的创新在于将软件开发的标准流程编码到了 Agent 系统中。传统的 LLM 应用往往是单一 Agent 尝试完成所有任务，这容易导致输出质量不稳定。而 MetaGPT 通过角色分工和流程控制，确保每个环节都有专门的 Agent 负责，就像真实的软件团队一样。

这种方法的好处是：

质量保证：每个 Agent 专注于自己擅长的领域，输出更专业。

可追溯性：每个环节都产生文档，整个开发过程透明可查。

可维护性：流程清晰，出现问题容易定位和修复。

消息驱动的松耦合架构

Agent 之间通过消息传递而非直接调用进行通信，这带来了：

解耦性：每个 Agent 是独立的模块，可以单独开发和测试。

可扩展性：添加新的 Agent 或修改现有 Agent 不会影响其他部分。

灵活性：可以根据需要组合不同的 Agent 形成不同的工作流。

结构化输出与类型安全

MetaGPT 要求 Action 定义明确的输入输出格式，这解决了 LLM 输出不稳定的问题：

class Message(BaseModel):
    content: str                                         # 自然语言
    instruct_content: Optional[BaseModel] = None         # 结构化数据

通过 Pydantic 的类型验证，确保 Agent 之间传递的数据是可靠的。

记忆与上下文管理

每个 Agent 都有自己的记忆系统（Memory），可以记住之前的对话和决策。同时，通过 RoleContext，Agent 可以访问全局上下文，了解项目的整体状态。

这使得 Agent 能够：

保持连贯性：在多轮对话中保持上下文一致性。

做出更好的决策：基于历史信息而非仅仅当前输入。

协作更高效：了解其他 Agent 的工作进展。

七、应用场景与未来展望

当前应用场景

MetaGPT 已经在多个领域展现出价值：

软件开发：从需求到代码的全流程自动化，适合原型开发、小工具生成、自动化脚本编写等场景。

数据分析：通过 Data Interpreter Agent，可以自动完成数据清洗、分析、可视化等任务。

内容生成：多个 Agent 协作完成复杂的写作任务，如技术文档、教程等。

研究辅助：通过 Researcher Agent，可以自动收集、整理、分析信息。

游戏开发：生成简单的游戏原型，适合教学和快速验证想法。

核心价值

MetaGPT 的核心价值不仅仅是"生成代码"，而是：

降低门槛：让非专业开发者也能通过自然语言描述需求来创建软件。

提高效率：自动化重复性工作，让开发者专注于创意和核心业务逻辑。

知识沉淀：生成的文档和代码本身就是宝贵的学习资料。

最佳实践传播：将软件工程的最佳实践编码到 Agent 系统中，自动应用。

技术挑战与改进方向

当然，MetaGPT 也面临一些挑战：

成本控制：多个 Agent 协作意味着多次 LLM 调用，成本较高。可以通过使用更小的模型、优化提示词、缓存机制等方式降低成本。

质量保证：虽然有多 Agent 协作，但 LLM 的输出仍有不确定性。需要更强的验证机制和自我修正能力。

复杂项目支持：目前主要适合中小型项目，对于大型复杂项目还需要更强的规划和管理能力。

领域适应性：不同领域的开发流程差异很大，需要更灵活的 Agent 定制机制。

未来展望

多 Agent 系统代表了 AI 应用的一个重要方向。MetaGPT 展示了通过模拟真实团队协作来解决复杂问题的可能性。未来可能的发展方向包括：

更丰富的 Agent 生态：支持更多专业角色，如 UI/UX 设计师、DevOps 工程师等。

动态团队组建：根据任务复杂度和类型，自动选择合适的 Agent 组合。

人机协作增强：允许人类开发者随时介入，与 Agent 共同完成任务。

跨项目知识共享：Agent 能够从过往项目中学习，积累经验。

多模态能力：支持图像、视频等多模态输入输出，完成更复杂的任务。

八、总结：Agent 协作开启 AI 应用新范式

MetaGPT 通过将软件公司的组织结构和工作流程映射到 AI Agent 系统中，展示了多 Agent 协作的强大潜力。它的核心设计理念包括：

角色分工：每个 Agent 扮演特定角色，专注于自己的领域。

消息驱动：通过消息传递实现 Agent 之间的松耦合协作。

流程编码：将 SOP 编码到系统中，确保输出质量。

结构化输出：使用类型系统保证数据的可靠性。

从技术实现角度，MetaGPT 的代码架构清晰、模块化程度高、可扩展性强。通过 Role、Action、Message、Team、Environment 等核心组件，构建了一个完整的多 Agent 协作框架。

无论你是想快速生成一个原型项目，还是想了解多 Agent 系统的设计理念，MetaGPT 都是一个值得深入研究的框架。它不仅仅是一个工具，更是对未来 AI 应用开发模式的一次探索。

随着大语言模型能力的不断提升，我们有理由相信，Agent 协作将成为解决复杂问题的主流方式。MetaGPT 作为这个领域的先行者，为我们展示了一条可行的道路。

参考资源

MetaGPT GitHub 仓库：https://github.com/geekan/MetaGPT

官方文档：https://docs.deepwisdom.ai/

论文：MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework (ICLR 2024)

MGX 产品：https://mgx.dev/ - MetaGPT 的商业化产品

如果你对 MetaGPT 感兴趣，建议从简单的例子开始，逐步理解各个组件的工作原理。通过阅读源码、运行示例、自定义 Agent，你会对多 Agent 系统有更深入的理解。

Happy coding with AI Agents!

# 人工智能 # python # 自然语言处理 # github # 开源软件 # 交互 # 团队开发
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

给 Agent 加一个可靠的知识检索层：从向量引擎到 RAG 工作流的实践笔记

avatar 2048 AI社区
cover

远程办公难协同？OpenClaw 接入钉钉，AI 全程辅助执行

avatar 2048 AI社区

主流AI 七层关系：Token→提示词→上下文→Agent→Harness→MCP→Skills

AI能力堆栈分为三层：基础交互层（Token、提示词、上下文）处理文本交互；智能体与编排层（Agent、Harness、MCP）实现任务拆解和外部连接；业务应用层（Skills）封装具体功能。整个过程如同造车：从零件（Token）到控制系统（Agent+Harness），通过标准协议（MCP）连接外部资源，最终实现"自动泊车"等具体功能（Skills）。

avatar 2048 AI社区