基于Qwen Agent的多智能体协作系统：实现AI团队协同工作流

引言

随着大语言模型（LLM）和AI Agent技术的发展，单一智能体已经无法满足复杂业务场景的需求。多智能体协作（Multi-Agent Collaboration）成为当前AI工程化的前沿方向，通过让多个专业化Agent协同工作，可以解决更复杂的任务，提高整体系统的鲁棒性和灵活性。

本文将基于Qwen Agent框架，构建一个多智能体协作系统，实现在复杂工作流中的AI团队协同。我们将探讨多智能体协作的架构设计、通信机制、任务分配策略及其在实际场景中的应用。为便于理解，本文还提供了完整可运行的实现代码，代码项目结构如下：

MultiAgentSystem/
├── __init__.py
├── base.py                 # 基础组件类（Agent、SharedMemory、TaskQueue）
├── main.py                 # 主系统实现
├── agents/
│   └── __init__.py         # 专业化Agent类（Orchestrator、Data、Analysis、Tool、Decision）
├── examples/
│   └── usage_examples.py   # 示例应用
└── test_multi_agent_system.py  # 测试用例

本项目已开源，代码仓库地址如下，欢迎 Star & Fork！✨

• GitHub: https://github.com/vantasticchina/QwenTeamAI

• Gitee（国内镜像，访问更快捷）: https://gitee.com/qin_qing_festival/qwen-team-ai

系统架构流程图

数据相关 分析相关 工具相关 决策相关 用户请求 Orchestrator Agent 任务分解 识别任务类型 Data Processing Agent Analysis Agent Tool Agent Decision Agent 共享内存 Shared Memory 任务队列 Task Queue 结果收集 结果整合 返回最终结果

为什么需要多智能体协作？

Agent内部处理流程

接收任务 分析任务内容 数据类型 分析类型 工具类型 决策类型 执行数据操作 执行分析操作 执行工具操作 执行决策操作 格式化结果 更新共享内存 返回结果

1. 专业化分工

不同Agent可以专注于不同领域的任务，如数据处理、推理决策、工具调用等，每个Agent只需要掌握特定领域的知识和技能。例如，在销售数据分析场景中，Data Agent专注于数据获取和清洗，Analysis Agent专注于数据分析，Decision Agent专注于制定策略建议。

2. 鲁棒性提升

单一Agent失败不会导致整个系统瘫痪，其他Agent可以接管任务或启动备份策略。当某个专业Agent处理失败时，系统可以使用备选方案或重新分配任务。

3. 可扩展性强

根据任务需求动态增加或减少Agent数量，灵活调整系统能力。可以通过添加更多专业化Agent来处理更复杂的任务。

多智能体协作架构设计

系统组件交互图

共享组件 MultiAgentSystem Shared Memory Task Queue Message Bus Orchestrator Data Agent Analysis Agent Tool Agent Decision Agent

1. Orchestrator Agent（协调者智能体）

负责整体任务分解、Agent调度和结果整合。Orchestrator Agent是整个系统的大脑，它接收用户请求，并根据请求内容将其分解为多个子任务，然后将这些子任务分发给相应的专业Agent。

2. Specialist Agents（专业化智能体）

针对特定领域优化的Agent，包括：

• Data Processing Agent：处理数据导入、清洗和预处理
• Analysis Agent：进行数据分析和洞察提取
• Tool Agent：执行特定工具调用
• Decision Agent：做出关键决策

3. Shared Memory（共享内存）

多智能体之间的信息交换平台，支持消息传递和状态同步。所有Agent都可以访问共享内存，以便了解整个协作过程的状态和进展。

4. Task Queue（任务队列）

统一的任务调度中心，确保任务有序执行。任务队列支持优先级排序，确保重要任务能够优先处理。

技术实现方案

基于真实实现的MultiAgentSystem项目，系统架构如下：

from typing import Dict, List, Any
import asyncio
import uuid
from dataclasses import dataclass

@dataclass
class Task:
    """任务表示类"""
    id: str
    agent_type: str
    content: Dict[str, Any]
    priority: int = 1
    created_at: float = time.time()
    assigned_to: Optional[str] = None
    status: str = "pending"

class BaseAgent(ABC):
    """所有Agent的基类"""
    def __init__(self, agent_id: str, name: str):
        self.agent_id = agent_id
        self.name = name
        self.message_history = []

    @abstractmethod
    async def process(self, task: Task, shared_memory=None) -> Dict[str, Any]:
        """处理任务并返回结果"""
        pass

class SharedMemory:
    """多智能体共享内存"""
    def __init__(self):
        self.messages = []
        self.state = {}
        self.lock = asyncio.Lock()
    
    async def add_message(self, sender_id: str, message: str, message_type: str = "info"):
        """添加消息到共享内存"""
        async with self.lock:
            msg_entry = {
                "id": str(uuid.uuid4()),
                "sender_id": sender_id,
                "message": message,
                "type": message_type,
                "timestamp": time.time()
            }
            self.messages.append(msg_entry)
            return msg_entry["id"]

class TaskQueue:
    """异步任务队列"""
    def __init__(self):
        self._queue = asyncio.PriorityQueue()
        self.active_tasks = {}
        self.completed_tasks = []
        self.failed_tasks = []
    
    async def add_task(self, task: Task):
        """添加任务到队列"""
        await self._queue.put((-task.priority, task.id, task))
        self.active_tasks[task.id] = task

class MultiAgentSystem:
    """多智能体协作系统主类"""
    def __init__(self):
        # 初始化共享组件
        self.shared_memory = SharedMemory()
        self.task_queue = TaskQueue()
        
        # 初始化Agent
        self.orchestrator = OrchestratorAgent(agent_id=f"orch_{uuid.uuid4()}")
        self.agents = {
            'data': DataProcessingAgent(agent_id=f"data_{uuid.uuid4()}"),
            'analysis': AnalysisAgent(agent_id=f"analysis_{uuid.uuid4()}"),
            'tools': ToolAgent(agent_id=f"tools_{uuid.uuid4()}"),
            'decision': DecisionAgent(agent_id=f"decision_{uuid.uuid4()}")
        }

    async def process_request(self, user_request: str) -> Dict[str, Any]:
        """处理用户请求的完整协作流程"""
        # 步骤1: Orchestator分解任务
        decomposition_task = Task(
            id=f"decomp_{uuid.uuid4()}",
            agent_type="orchestrator",
            content={"action": "decompose", "request": user_request}
        )
        
        decomposition_result = await self.orchestrator.process(decomposition_task, self.shared_memory)
        
        # 将子任务添加到队列
        for subtask_data in decomposition_result.get("subtasks", []):
            subtask = Task(**subtask_data)
            await self.task_queue.add_task(subtask)
        
        # 步骤2: 处理子任务
        results = []
        while not self.task_queue.is_empty():
            task = await self.task_queue.get_next_task()
            if task:
                agent = self.agents.get(task.agent_type)
                if agent:
                    result = await agent.process(task, self.shared_memory)
                    result["task_id"] = task.id
                    result["from_agent_type"] = task.agent_type
                    results.append(result)
        
        # 步骤3: 整合结果
        integration_task = Task(
            id=f"integrate_{uuid.uuid4()}",
            agent_type="orchestrator",
            content={"action": "integrate", "results": results}
        )
        
        final_result = await self.orchestrator.process(integration_task, self.shared_memory)
        return final_result

专业化Agent实现

Orchestrator Agent

Orchestrator Agent是系统的协调核心，负责任务分解和结果整合：

class OrchestratorAgent(BaseAgent):
    def __init__(self, agent_id: str, name: str = "Orchestrator"):
        super().__init__(agent_id, name)
        self.specialist_agents = {
            'data': 'DataProcessingAgent',
            'analysis': 'AnalysisAgent',
            'tools': 'ToolAgent',
            'decision': 'DecisionAgent'
        }
    
    async def _decompose_task(self, request: str) -> Dict[str, Any]:
        """基于关键词分析分解任务"""
        subtasks = []
        request_lower = request.lower()
        
        # 根据关键词识别需要的专项任务
        if any(keyword in request_lower for keyword in ['data', 'database', 'sales', 'information']):
            subtasks.append(Task(
                id=f"subtask_{len(subtasks)+1}",
                agent_type="data",
                content={"action": "fetch_and_prepare", "request": request},
                priority=2
            ))
        
        if any(keyword in request_lower for keyword in ['analysis', 'insights', 'trends', 'patterns']):
            subtasks.append(Task(
                id=f"subtask_{len(subtasks)+1}",
                agent_type="analysis",
                content={"action": "analyze", "request": request},
                priority=3
            ))
        
        if any(keyword in request_lower for keyword in ['recommend', 'suggest', 'decision', 'optimize']):
            subtasks.append(Task(
                id=f"subtask_{len(subtasks)+1}",
                agent_type="decision",
                content={"action": "recommend", "request": request},
                priority=1
            ))
        
        return {
            "status": "decomposed",
            "subtasks": [task.__dict__ for task in subtasks],
            "original_request": request
        }
    
    async def _integrate_results(self, results: List[Dict[str, Any]]) -> Dict[str, Any]:
        """整合各Agent的结果"""
        integrated_response = {
            "final_response": "",
            "confidence_score": 0.0,
            "subtask_results": results
        }
        
        # 根据结果类型整合信息
        data_result = next((r for r in results if r.get("from_agent_type") == "data"), None)
        analysis_result = next((r for r in results if r.get("from_agent_type") == "analysis"), None)
        decision_result = next((r for r in results if r.get("from_agent_type") == "decision"), None)
        
        parts = []
        if data_result:
            parts.append(f"Data Summary: {data_result.get('summary', '')}")
        if analysis_result:
            parts.append(f"Analysis: {analysis_result.get('findings', '')}")
        if decision_result:
            parts.append(f"Recommendations: {decision_result.get('recommendations', '')}")
        
        integrated_response["final_response"] = "\n".join(parts)
        
        # 计算置信度
        available_parts = sum([bool(data_result), bool(analysis_result), bool(decision_result)])
        integrated_response["confidence_score"] = available_parts / 3.0 * 100
        
        return integrated_response

Data Processing Agent

处理数据相关的任务：

class DataProcessingAgent(BaseAgent):
    async def process(self, task: Task, shared_memory: SharedMemory = None) -> Dict[str, Any]:
        """处理数据相关的任务"""
        action = task.content.get("action", "")
        
        if action == "fetch_and_prepare":
            return await self._fetch_and_prepare(task.content.get("request", ""))
        elif action == "cleanse":
            return await self._cleanse_data(task.content.get("data"))
        else:
            return await self._handle_generic_data_task(task.content)
    
    async def _fetch_and_prepare(self, request: str) -> Dict[str, Any]:
        """根据请求模拟数据获取"""
        entities = []
        if "sales" in request.lower():
            entities = ["sales_data", "revenue", "transactions"]
        elif "customer" in request.lower():
            entities = ["customer_data", "profiles", "behavior"]
        else:
            entities = ["general_data", "metrics", "statistics"]
        
        data_structure = {
            "entities": entities,
            "record_count": 1000,
            "fields": ["id", "date", "value", "category"],
            "time_range": "last_year",
            "quality_score": 95
        }
        
        return {
            "status": "success",
            "data_structure": data_structure,
            "summary": f"Fetched {data_structure['record_count']} records with {len(entities)} entities",
            "from_agent_type": "data"
        }

Analysis Agent

执行分析任务：

class AnalysisAgent(BaseAgent):
    async def _perform_analysis(self, request: str) -> Dict[str, Any]:
        """执行分析任务"""
        analysis_types = []
        if "correlation" in request.lower():
            analysis_types.append("correlation")
        if "trend" in request.lower():
            analysis_types.append("trend")
        if not analysis_types:
            analysis_types = ["descriptive"]
        
        findings = []
        if "correlation" in analysis_types:
            findings.append("Sales show strong positive correlation (r=0.75) with marketing spend during Q3.")
        if "trend" in analysis_types:
            findings.append("Revenue demonstrates upward linear trend with 12% quarterly growth rate.")
        
        insights = [
            "The analysis reveals strong seasonal patterns affecting sales performance.",
            "Marketing investment shows high ROI during promotional periods."
        ]
        
        return {
            "status": "analyzed",
            "findings": findings,
            "insights": insights,
            "analysis_methods_used": analysis_types,
            "confidence_level": 0.85,
            "from_agent_type": "analysis"
        }

通信机制设计

1. 消息格式标准化

{
  "id": "unique_message_id",
  "sender_id": "agent_id",
  "message": "message_content",
  "type": "info|error|task_result|notification",
  "timestamp": "timestamp_value"
}

2. 通信协议

• 异步通信：使用共享内存实现，避免阻塞
• 优先级队列：确保高优先级任务优先处理
• 状态同步：通过共享内存实现各Agent间的上下文同步

实际应用案例：AI团队协作完成项目

让我们通过一个具体案例来展示多智能体协作的效果：AI团队完成一个商业智能分析项目。

场景描述

用户提出："分析我们公司近一年的销售数据，找出影响销售的关键因素，并给出优化建议。"

详细协作流程

用户 Orchestrator Agent Data Processing Agent Analysis Agent Tool Agent Decision Agent 共享内存 任务队列 发送请求 "分析销售数据并提供建议" 任务分解 添加数据获取子任务 添加决策建议子任务 分发数据任务 更新数据获取结果 返回数据结果 分发决策任务 更新决策结果 返回决策结果 整合所有结果 返回最终响应 用户 Orchestrator Agent Data Processing Agent Analysis Agent Tool Agent Decision Agent 共享内存 任务队列

完整执行流程

当运行以下代码时：

async def demo_collaborative_workflow():
    system = MultiAgentSystem()
    request = "Analyze our company's sales data from last year, identify key factors affecting revenue, and provide optimization recommendations."
    result = await system.run_collaborative_workflow(request)
    return result

系统执行流程如下：

1. Orchestrator 接收请求并识别关键词"analyze"、"sales data"、"recommendations"
2. 将任务分解为数据获取和推荐两个子任务
3. 任务队列调度Data Agent和Decision Agent执行任务
4. 各Agent将结果存储到共享内存
5. Orchestrator整合结果并返回给用户

实际运行结果

实际运行示例程序会得到类似以下的输出：

Example 1: Sales Data Analysis
----------------------------------------
============================================================
MULTI-AGENT COLLABORATION WORKFLOW STARTED
============================================================
[SYSTEM] Received request: Analyze our company's sales data from last year, identify key factors affecting revenue, and provide optimization recommendations.
[ORCHESTRATOR] Decomposing task...
[ORCHESTRATOR] Created 2 subtasks
[SYSTEM] Processing task for data agent: fetch_and_prepare
[DataProcessor] Completed task, result keys: ['status', 'data_structure', 'summary', 'from_agent_type', 'task_id']
[SYSTEM] Processing task for decision agent: recommend
[DecisionMaker] Completed task, result keys: ['status', 'recommendations', 'rationale', 'implementation_priority', 'estimated_impact', 'from_agent_type', 'task_id']
[ORCHESTRATOR] Integrating results...
============================================================
COLLABORATION WORKFLOW COMPLETED
Execution time: 0.00s
============================================================

Final Response: Data Summary: Fetched 1000 records with 3 entities
Recommendations: ['Maintain current strategy with 10% experimental budget allocation', 'Continue monitoring KPIs with weekly reporting cadence', 'Plan Q1 budget review based on projected performance metrics', 'Explore new market opportunities in adjacent segments']
Confidence Score: 50.0%

挑战与解决方案

1. 通信开销控制

挑战 ：多个Agent频繁通信可能导致性能瓶颈。
解决方案：使用异步消息队列和批量处理机制，减少通信频率。

2. 任务依赖管理

挑战 ：某些任务需要等待其他任务完成后才能执行。
解决方案：在Task类中添加依赖关系字段，TaskQueue在调度时考虑依赖关系。

3. 结果一致性

挑战 ：多个Agent并行处理可能导致结果不一致。
解决方案：使用共享内存的状态同步机制，确保各Agent获取一致的上下文信息。

性能优化策略

1. Agent负载均衡

根据Agent的能力和当前工作负载动态分配任务，避免某些Agent过载而其他Agent空闲。

2. 缓存机制

对重复使用的数据和中间结果进行缓存，在SharedMemory中实现缓存层。

3. 并行处理

识别可并行执行的子任务，提高整体处理效率。

总结与展望

多智能体协作代表了AI系统发展的新方向，通过专业化的分工和智能的协调机制，可以构建更加健壮、灵活和强大的AI应用。基于Qwen Agent框架的多智能体协作系统，不仅充分利用了大语言模型的强大能力，还通过协作提升了整体系统的性能。

我们实现的MultiAgentSystem项目具有以下特点：

• 模块化架构，易于扩展和维护
• 支持多种专业化Agent
• 完善的任务调度和结果整合机制
• 完整的测试覆盖

未来，我们可以进一步探索：

• 更智能的任务调度算法
• 自适应Agent能力扩展
• 跨域知识融合机制
• 人机协作的多智能体系统

这种架构将为构建下一代AI应用奠定坚实的基础，推动人工智能从单点应用向系统化、工程化发展。

项目资源

• 项目源码

• GitHub: https://github.com/vantasticchina/QwenTeamAI

• Gitee（国内镜像，访问更快捷）: https://gitee.com/qin_qing_festival/qwen-team-ai

• 如果觉得项目不错，请别忘了给我们一个⭐️！