06 Memory → 07 Team Collaboration

当任务太大
就 分给队友

一个 Agent 能做的事有限,但一群 Agent 协同合作,就能完成不可思议的复杂任务——就像一支默契的厨房团队。

👨‍🍳
→
🍳
🥘
🍰
→
🍽️
SECTION 01

核心理念:太大了?分给队友

🍽️ 类比 · 餐厅厨房团队

一家繁忙的餐厅,主厨(Head Chef)不亲自做每道菜。他把订单分配给炒锅师傅、蒸锅师傅、甜点师,每人专注自己的拿手好菜。主厨负责协调、确保每道菜按时出餐、味道一致。

💡 什么是团队协作?

团队协作就是多个 Agent 分工合作,共同完成单个 Agent 无法独立完成的复杂任务。核心思想很简单:

"太大了?分给队友"

每个 Agent 有自己的能力标签(Capabilities),协调器根据这些标签智能分配任务,就像主厨根据每位厨师的专长来安排菜式。

🧩 三大核心组件

组件角色类比
MessageBus发布-订阅消息总线📮 邮局分拣中心
AsyncMailbox每个 Agent 的异步信箱📬 个人邮政信箱
TeamCoordinator团队协调管理器👨‍🍳 主厨 / 🎼 指挥家
SECTION 02

三种协作模式

不同的任务场景需要不同的协作结构。AgentForge 支持三种经典模式:

👑

主从模式 Master-Worker

M
↙↓↘
W1
W2
W3

主 Agent 分配任务,工人 Agent 执行并汇报结果。适合分工明确的场景。

🤝

对等模式 Peer-to-Peer

A
⇄
B
⇄
C

所有 Agent 地位平等,互相协商。适合讨论决策类场景。

🔄

流水线模式 Pipeline

采集
→
分析
→
输出

每个 Agent 处理一个阶段,结果传递给下一个。适合有序流程类任务。

SECTION 03

MessageBus · 消息总线

📮 类比 · 邮局分拣中心

消息总线就像邮局的分拣中心。寄件人(发布者)把信件投到总线,分拣中心根据地址(Topic)把信分发到对应的收件人(订阅者)。

MessageBus 提供四种核心操作:

Python
class MessageBus:
    """发布-订阅消息总线"""

    def subscribe(self, topic: str, agent: Agent):
        """订阅某个主题 — '我想收到关于 X 的消息'"""
        self.subscriptions[topic].append(agent)
        agent.mailbox.register(topic)  # 注册到邮箱

    def publish(self, topic: str, message: Message):
        """发布消息到主题 — '广播给所有订阅者'"""
        for agent in self.subscriptions.get(topic, []):
            agent.mailbox.deliver(message)

    def send(self, sender: str, target: str, message: Message):
        """点对点发送 — '只给你一个人'"""
        target_agent = self.agents[target]
        target_agent.mailbox.deliver(message)

    def broadcast(self, sender: str, message: Message):
        """全员广播 — '所有人都听到'"""
        for agent in self.agents.values():
            if agent.id != sender:
                agent.mailbox.deliver(message)

subscribe:Agent 注册感兴趣的主题,之后该主题的消息都会自动投递到它的邮箱。

publish:一对多广播,所有订阅了该主题的 Agent 都会收到消息。

send:一对一精准投递,适合请求-响应模式。

SECTION 04

AsyncMailbox · 异步邮箱

📬 类比 · 个人邮政信箱

每个 Agent 都有自己的邮箱(PO Box)。别人寄来的信不会直接到你手里,而是放进信箱里,你随时可以去取。如果没人寄信,你可以设定一个等待时间。

Python
class AsyncMailbox:
    """每个 Agent 的异步消息队列"""

    def __init__(self, agent_id: str):
        self.agent_id = agent_id
        self.inbox = deque()   # 📥 收件箱
        self.outbox = deque()  # 📤 发件箱
        self._event = asyncio.Event()

    def deliver(self, message: Message):
        """投递消息到收件箱"""
        self.inbox.append(message)
        self._event.set()  # 🔔 通知:有新邮件!

    async def receive(self, timeout: float = 30.0):
        """异步等待收取消息(带超时)"""
        try:
            await asyncio.wait_for(
                self._event.wait(), timeout=timeout
            )
            self._event.clear()
            return self.inbox.popleft()
        except asyncio.TimeoutError:
            return None  # ⏰ 超时,没有消息

    def send(self, message: Message):
        """放入发件箱,等待总线取走"""
        self.outbox.append(message)

inbox / outbox:双端队列(deque),支持高效地两端进出消息。

receive + timeout:异步等待消息,带超时防止永久阻塞——这是防止死锁的关键设计。

_event:asyncio 事件通知机制,让 Agent 不需要轮询,有消息时自动唤醒。

SECTION 05

TeamCoordinator · 团队协调器

🎼 类比 · 乐团指挥

TeamCoordinator 就像乐团指挥。他知道每位乐手的专长(小提琴、钢琴、长笛),安排他们演奏各自擅长的段落,并在必要时指挥谁先谁后。

Python
class TeamCoordinator:
    """管理 Agent 团队的核心控制器"""

    def add_member(self, agent: Agent, capabilities: list[str]):
        """招募队员 — 注册能力和身份"""
        self.members[agent.id] = {
            "agent": agent,
            "capabilities": capabilities,
            "status": "idle"
        }
        self.bus.subscribe(agent.id, agent)  # 注册消息通道

    def assign_task(self, task: Task) -> str:
        """智能分配任务 — 按能力和空闲状态匹配"""
        for mid, member in self.members.items():
            caps = member["capabilities"]
            is_idle = member["status"] == "idle"
            has_skill = task.required_skill in caps

            if is_idle and has_skill:
                member["status"] = "busy"
                self.bus.send("coordinator", mid, task.to_message())
                return mid

        raise NoAvailableAgent(f"无人可接: {task}")

    def route_message(self, message: Message):
        """路由消息 — 根据目标分发"""
        if message.target == "*":
            self.bus.broadcast(message.sender, message)
        else:
            self.bus.send(message.sender, message.target, message)

add_member:注册 Agent 时需要声明其能力列表(capabilities),如 ["python", "数据分析"]。

assign_task:核心调度逻辑——遍历所有成员,找到空闲且具备所需能力的 Agent 来执行任务。

route_message:消息路由,支持点对点和广播两种模式。

SECTION 06

真实案例

💻 软件开发团队

想象一个自动化的开发团队:

需求分析 Agent 架构设计 Agent 代码编写 Agent 测试 Agent 部署 Agent

用户提交需求 → 分析 Agent 拆解任务 → 架构 Agent 设计方案 → 编码 Agent 写代码 → 测试 Agent 跑测试 → 部署 Agent 上线。这就是流水线模式。

🔬 科研团队

一个 AI 驱动的科研助手团队:

文献检索 Agent 数据采集 Agent 数据分析 Agent 论文撰写 Agent

导师 Agent(主从模式)分配子课题,每个科研 Agent 各自搜索文献、分析数据、撰写段落,最后由导师 Agent 整合审阅。

SECTION 07

消息类型一览

Agent 之间传递的消息有五种标准类型,每种都有明确的语义:

📤
REQUEST

请求
请你帮我做某事

📥
RESPONSE

响应
任务完成,结果如下

📢
NOTIFICATION

通知
告诉你一件事

❌
ERROR

错误
出问题了,原因如下

💓
HEARTBEAT

心跳
我还活着,状态正常

Python
from enum import Enum

class MessageType(Enum):
    REQUEST     = "request"      # 📤 任务请求
    RESPONSE    = "response"     # 📥 任务响应
    NOTIFICATION = "notification" # 📢 状态通知
    ERROR       = "error"        # ❌ 错误报告
    HEARTBEAT   = "heartbeat"    # 💓 存活检测

class Message:
    def __init__(self, sender, target, msg_type, payload, priority=0):
        self.sender = sender      # 谁发的
        self.target = target      # 发给谁
        self.type = msg_type      # 消息类型
        self.payload = payload    # 内容
        self.priority = priority  # 优先级(越高越先处理)
SECTION 08

小测验

检验一下你对团队协作的理解:

Q1

TeamCoordinator 分配任务时,主要依据哪两个条件?

A. Agent 的创建时间和内存大小
B. Agent 的能力标签和空闲状态
C. Agent 的 ID 和消息类型
D. Agent 的运行速度和网络延迟

Q2

AsyncMailbox 中 receive 方法带 timeout 参数的主要目的是什么?

A. 提高消息接收速度
B. 加密传输的消息
C. 防止 Agent 永久阻塞(死锁预防)
D. 压缩消息大小

Q3

以下哪种协作模式最适合"需求分析 → 设计 → 编码 → 测试"这种有序流程?

A. 流水线模式(Pipeline)
B. 主从模式(Master-Worker)
C. 对等模式(Peer-to-Peer)
D. 随机模式

Q4

MessageBus 的 publish 方法和 send 方法有什么区别?

A. publish 是同步的,send 是异步的
B. publish 发送的消息更大
C. publish 只发送给主 Agent
D. publish 一对多广播,send 点对点发送

Q5

HEARTBEAT 消息类型的主要用途是什么?

A. 传递大量数据
B. 检测 Agent 是否存活、状态是否正常
C. 请求执行任务
D. 通知团队成员变更
SECTION 09

深入探索

🔒 深入一:死锁预防

当两个 Agent 互相等待对方的消息时,就会发生死锁——谁也收不到消息,系统卡住。

查看解决方案 ▼

解决方案:

  • 超时机制:receive 必须设置 timeout,超时返回 None
  • 优先级排序:按 priority 排序消息,避免互相阻塞
  • 心跳检测:定期发送 HEARTBEAT,发现无响应则跳过
  • 死锁检测器:监控等待图,发现环路时强制中断

🎯 深入二:基于能力的路由

如何让任务精准匹配到最合适的 Agent?答案是能力标签(Capability Tags)。

查看详细机制 ▼
# 注册时声明能力
coordinator.add_member(coder_agent, ["python", "javascript", "代码编写"])
coordinator.add_member(analyst_agent, ["数据分析", "可视化", "python"])

# 分配时自动匹配
task = Task(required_skill="python")
assigned_id = coordinator.assign_task(task)
# → 匹配到 coder_agent 或 analyst_agent(谁空闲选谁)

支持模糊匹配:即使标签不完全一致,也可以通过语义相似度找到最接近的 Agent。

🔐 深入三:权限冒泡

当子 Agent 需要执行敏感操作时(如删除文件、发送邮件),它不能自行决定——需要向上级请示。

查看冒泡机制 ▼

权限请求沿着 Agent 层级逐级向上冒泡:

子 Agent → 请求冒泡 → 父 Agent → 继续冒泡 → 顶层 Agent / 用户
  • 每一层都可以批准或拒绝请求
  • 拒绝后,子 Agent 收到 ERROR 消息,不会执行该操作
  • 这确保了敏感操作始终受到人类或高层 Agent 的控制
SECTION 10

本章总结

🎉 恭喜完成模块 07!

← 上一节 MODULE 7/11 下一节 →