【Agent 设计模式】多智能体协作

多智能体协作（Multi-Agent Collaboration）

单一 LLM 智能体难以应对复杂问题，缺乏多样化专长或工具，成为系统瓶颈，降低效率与可扩展性，难以完成多领域目标。多智能体协作模式通过将复杂问题拆分为可管理子问题，分配给具备专长的智能体，智能体通过顺序交接、并行处理或层级委托等协议协作，实现单一智能体无法完成的目标。

核心思想：专长分工 + 协作通信 ------ 多个专精智能体各司其职，通过协议协同完成复杂任务。

适用场景

当任务过于复杂，需拆分为需专长或工具的子任务时，适合采用该模式。适用于多领域、并行处理或多阶段结构化流程，如复杂研究、软件开发、创意内容生成等。

场景	协作方式
客户支持升级	前线支持智能体处理初步问题，复杂问题升级至专家智能体（如技术或账单专家），体现基于问题复杂度的顺序交接
供应链优化	智能体代表供应链各节点（供应商、制造商、分销商），协作优化库存、物流与排程，应对需求变化或突发事件
网络分析与修复	自治运维场景下，多智能体协作进行故障定位、分级处理与修复，可集成传统机器学习模型与工具

通过智能体专长划分与关系精细编排，开发者可构建具备更强模块化、可扩展性和复杂问题处理能力的系统。

智能体关系与通信结构

理解智能体间的交互与通信方式，是设计高效多智能体系统的基础。从最简单的单智能体到复杂的定制协作结构，呈现多样化选择。每种模型有独特优势与挑战，影响系统整体效率、健壮性与适应性。

1. 单智能体

最基础模型，智能体独立运行，无需与其他实体交互，适合可拆分为独立子问题的场景，但能力受限。

2. 网络型

多个智能体以去中心化方式直接交互，点对点通信，信息、资源和任务共享，具备弹性，但通信管理和决策一致性较难。

复制代码

[A] ←→ [B]
 ↕   ╲  ↕
[C] ←→ [D]

3. 监督者

专门智能体"监督者"协调下属智能体，负责通信、任务分配和冲突解决，层级结构清晰，易于管理，但存在单点故障和瓶颈风险。

复制代码

      [监督者]
     /   |   \
  [A]   [B]   [C]

4. 工具型监督者

监督者不直接指挥，而是为其他智能体提供资源、指导或分析支持，赋能而非强制控制，提升灵活性。

5. 层级型

多层监督者结构，高层监督者管理低层监督者，底层为操作智能体，适合复杂问题分层管理，便于扩展和分布式决策。

复制代码

         [总监督者]
        /         \
   [子监督者A]   [子监督者B]
    /    \        /    \
 [A1]  [A2]   [B1]  [B2]

6. 定制型

最灵活模型，针对具体问题或应用定制独特关系与通信结构，可混合前述模型或创新设计，适合优化特定性能、动态环境或领域知识集成。定制模型需深入理解多智能体原理，慎重设计通信协议、协调机制与涌现行为。

综上，多智能体系统的关系与通信模型选择至关重要，应结合任务复杂度、智能体数量、自治需求、健壮性和通信开销等因素权衡。

代码示例

示例 1：CrewAI 实现

python 复制代码

import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI


def setup_environment():
    """加载环境变量并检查 API 密钥。"""
    load_dotenv()
    if not os.getenv("OPENAI_API_KEY"):
        raise ValueError("OPENAI_API_KEY 未设置，请在 .env 文件中配置。")


def main():
    """
    初始化并运行内容创作 AI 团队。
    """
    setup_environment()

    # 指定语言模型
    llm = ChatOpenAI(model="gpt-4o-mini")

    # 定义 Agent 角色与目标
    researcher = Agent(
        role='高级研究分析师',
        goal='查找并总结 AI 最新趋势。',
        backstory="你是一名经验丰富的研究分析师，擅长发现关键趋势并整合信息。",
        verbose=True,
        allow_delegation=False,
    )

    writer = Agent(
        role='技术内容写作者',
        goal='根据研究结果撰写清晰易懂的博客。',
        backstory="你是一名技术写作高手，能将复杂技术转化为通俗内容。",
        verbose=True,
        allow_delegation=False,
    )

    # 定义任务
    research_task = Task(
        description="调研 2024-2025 年 AI 三大新兴趋势，关注实际应用与影响。",
        expected_output="详细总结三大 AI 趋势，包括要点与来源。",
        agent=researcher,
    )

    writing_task = Task(
        description="根据研究结果撰写一篇 500 字博客，内容通俗易懂。",
        expected_output="完整的 500 字 AI 趋势博客。",
        agent=writer,
        context=[research_task],
    )

    # 创建团队
    blog_creation_crew = Crew(
        agents=[researcher, writer],
        tasks=[research_task, writing_task],
        process=Process.sequential,
        llm=llm,
        verbose=True
    )

    # 执行团队任务
    print("## 运行博客创作团队... ##")
    try:
        result = blog_creation_crew.kickoff()
        print("\n------------------\n")
        print("## 团队最终输出 ##")
        print(result)
    except Exception as e:
        print(f"\n发生异常：{e}")


if __name__ == "__main__":
    main()

CrewAI 是专为多智能体协作设计的框架。示例展示如何定义一个 AI 协作团队生成 AI 趋势博客：

复制代码

[研究员] → research_task → [写作者] → writing_task → 博客输出

研究员（Agent）：查找并总结 AI 最新趋势
写作者（Agent）：根据研究结果撰写 500 字博客
任务依赖 ：writing_task 的 context=[research_task]，确保写作基于研究结果
顺序执行 ：Process.sequential 指定研究完成后再写作
团队执行 ：通过 crew.kickoff() 启动协作流程

示例 2：ADK 层级结构

python 复制代码

from google.adk.agents import LlmAgent, BaseAgent
from google.adk.agents.invocation_context import InvocationContext
from google.adk.events import Event
from typing import AsyncGenerator

GEMINI_MODEL = "gemini-2.0-flash-exp"


class TaskExecutor(BaseAgent):
    """自定义非 LLM 行为 Agent。"""
    name: str = "TaskExecutor"
    description: str = "执行预定义任务。"

    async def _run_async_impl(self, context: InvocationContext) -> AsyncGenerator[Event, None]:
        yield Event(author=self.name, content="任务成功完成。")


greeter = LlmAgent(
    name="Greeter",
    model=GEMINI_MODEL,
    instruction="你是一名友好的问候者。"
)

task_doer = TaskExecutor()

coordinator = LlmAgent(
    name="Coordinator",
    model=GEMINI_MODEL,
    description="协调问候与任务执行。",
    instruction="问候时委托 Greeter，执行任务时委托 TaskExecutor。",
    sub_agents=[
        greeter,
        task_doer
    ]
)

assert greeter.parent_agent == coordinator
assert task_doer.parent_agent == coordinator

print("Agent 层级关系创建成功。")

演示 Google ADK 中通过父子关系实现层级协作：

复制代码

     [Coordinator]
      /         \
[Greeter]   [TaskExecutor]

LlmAgent（Greeter）：负责问候
BaseAgent（TaskExecutor）：自定义非 LLM 智能体，执行预定义任务，返回"任务成功完成"事件
Coordinator ：父智能体，通过 sub_agents 参数建立父子关系，根据请求类型委托给对应子智能体

示例 3：ADK LoopAgent

python 复制代码

import asyncio
from typing import AsyncGenerator
from google.adk.agents import LoopAgent, LlmAgent, BaseAgent
from google.adk.events import Event, EventActions
from google.adk.agents.invocation_context import InvocationContext

GEMINI_MODEL = "gemini-2.0-flash-exp"


class ConditionChecker(BaseAgent):
    """检查流程是否完成并控制循环。"""
    name: str = "ConditionChecker"
    description: str = "检查流程完成状态并通知循环终止。"

    async def _run_async_impl(
        self, context: InvocationContext
    ) -> AsyncGenerator[Event, None]:
        status = context.session.state.get("status", "pending")
        is_done = (status == "completed")

        if is_done:
            yield Event(author=self.name, actions=EventActions(escalate=True))
        else:
            yield Event(author=self.name, content="条件未满足，继续循环。")


process_step = LlmAgent(
    name="ProcessingStep",
    model=GEMINI_MODEL,
    instruction="你是流程中的一步，完成任务。若为最后一步，将 session 状态设为 'completed'。"
)

poller = LoopAgent(
    name="StatusPoller",
    max_iterations=10,
    sub_agents=[
        process_step,
        ConditionChecker()
    ]
)

演示 LoopAgent 实现迭代流程：

复制代码

LoopAgent (max=10)
  ├→ [ProcessingStep] → 处理任务，最后一步设 status="completed"
  └→ [ConditionChecker] → status=="completed"? → 是: escalate 终止 / 否: 继续循环

ConditionChecker ：自定义 BaseAgent，检查 session 状态，若 status 为 completed 则通过 EventActions(escalate=True) 终止循环
ProcessingStep：LLM 智能体，负责处理任务并在最后一步设置状态
LoopAgent ：配置 max_iterations=10，循环执行直到条件满足或达到最大次数

示例 4：ADK 顺序与并行

python 复制代码

from google.adk.agents import Agent, SequentialAgent, ParallelAgent

GEMINI_MODEL = "gemini-2.0-flash-exp"

# ============================================================
# 示例 1：SequentialAgent 顺序执行
# step1 输出存入 session.state["data"]，step2 分析该数据
# ============================================================

step1 = Agent(name="Step1_Fetch", output_key="data")

step2 = Agent(
    name="Step2_Process",
    instruction="分析 state['data'] 信息并给出总结。"
)

pipeline = SequentialAgent(
    name="MyPipeline",
    sub_agents=[step1, step2]
)

# ============================================================
# 示例 2：ParallelAgent 并行执行
# 两个 Agent 同时获取天气和新闻，结果存入各自的 state key
# ============================================================

weather_fetcher = Agent(
    name="weather_fetcher",
    model=GEMINI_MODEL,
    instruction="获取指定地点天气，仅返回天气报告。",
    output_key="weather_data"
)

news_fetcher = Agent(
    name="news_fetcher",
    model=GEMINI_MODEL,
    instruction="获取指定主题头条新闻，仅返回新闻内容。",
    output_key="news_data"
)

data_gatherer = ParallelAgent(
    name="data_gatherer",
    sub_agents=[
        weather_fetcher,
        news_fetcher
    ]
)

SequentialAgent 顺序执行：

复制代码

[Step1_Fetch] → state["data"] → [Step2_Process] → 总结

step1 输出存入 session.state["data"]，step2 分析该数据并给出总结。

ParallelAgent 并行执行：

复制代码

ParallelAgent
  ├→ [weather_fetcher] → state["weather_data"]
  └→ [news_fetcher]    → state["news_data"]

两个 Agent 同时获取天气和新闻，结果存入各自的 state key。

示例 5：ADK 智能体即工具

python 复制代码

from google.adk.agents import LlmAgent
from google.adk.tools import agent_tool
from google.genai import types

GEMINI_MODEL = "gemini-2.0-flash"


def generate_image(prompt: str) -> dict:
    """模拟图片生成工具。"""
    print(f"TOOL: 正在为提示 '{prompt}' 生成图片")
    mock_image_bytes = b"mock_image_data_for_a_cat_wearing_a_hat"
    return {
        "status": "success",
        "image_bytes": mock_image_bytes,
        "mime_type": "image/png"
    }


# 子智能体：负责调用图片生成工具
image_generator_agent = LlmAgent(
    name="ImageGen",
    model=GEMINI_MODEL,
    description="根据详细文本提示生成图片。",
    instruction=(
        "你是图片生成专家，使用 `generate_image` 工具根据用户请求生成图片。"
        "用户请求作为工具的 'prompt' 参数。工具返回图片字节后，必须输出图片。"
    ),
    tools=[generate_image]
)

# 将子智能体包装为工具
image_tool = agent_tool.AgentTool(
    agent=image_generator_agent,
    description="用于生成图片，输入为描述性提示。"
)

# 父智能体：先创造提示，再通过工具调用子智能体生成图片
artist_agent = LlmAgent(
    name="Artist",
    model=GEMINI_MODEL,
    instruction=(
        "你是一名创意艺术家，先创造图片提示，再用 `ImageGen` 工具生成图片。"
    ),
    tools=[image_tool]
)

演示"智能体即工具"模式，父智能体通过 AgentTool 调用子智能体：

复制代码

[Artist 父智能体] → 生成创意提示 → 调用 ImageGen 工具
                                      ↓
                               [ImageGen 子智能体] → generate_image() → 返回图片

image_generator_agent ：子智能体，配备 generate_image 工具函数
AgentTool：将子智能体包装为工具，供父智能体调用
artist_agent：父智能体，先创造提示，再通过工具生成图片，实现分层协作

关键要点

多智能体协作即多个智能体共同实现目标
该模式利用专长分工、任务分布与智能体间通信
协作形式包括顺序交接、并行处理、辩论或层级结构
适用于需多领域专长或多阶段复杂问题
通信模型选择（网络型/监督者/层级型/定制型）应结合任务复杂度、智能体数量、健壮性等因素权衡

总结

本章介绍了多智能体协作模式，阐述了多专长智能体协同系统的优势。通过多种协作模型（顺序、并行、层级、智能体即工具），强调该模式在解决复杂、多元问题中的关键作用。理解智能体协作后，下一步将探讨其与外部环境的交互。