多智能体开发实战：从需求拆解到落地部署，这套工程化方案直接复用

朋友，可以转载，但请注明出处，谢谢！
http://blog.csdn.net/jiangjunshow

哈喽，各位CSDN的老铁们！👋 最近是不是被"多智能体"这三个字刷爆了朋友圈？不管是大厂招聘要求里的"熟悉多智能体协作"，还是创业公司融资时喊的"多智能体驱动创新"，仿佛一夜之间，不懂多智能体就跟不上AI圈的节奏了。

很多朋友私信我："哥，多智能体听起来好高大上，是不是只有博士才能玩？""我连Python基础都一般，能搞多智能体开发吗？""网上资料要么太理论，要么代码残缺不全，有没有能直接上手的实战方案？"

作为一个在AI领域摸爬滚打十多年，从国内学到国外，又扎根行业一线的老炮儿，今天就给大家扒一扒多智能体开发的底层逻辑，从需求拆解到落地部署，整套工程化方案直接打包给你，代码可复用、步骤零踩坑，哪怕你是编程小白，跟着走也能做出自己的多智能体应用！

一、先搞懂：多智能体到底是个啥？用大白话给你讲透

在聊开发之前，咱们先掰扯清楚核心概念。很多教程一上来就扔"智能体通信协议""分布式协作框架"，直接把新手劝退。其实多智能体一点都不玄乎，咱们用生活场景类比一下：

你把多智能体系统想象成一个创业小团队：

• 每个智能体就是一个"员工"，有自己的专属技能（比如数据分析、文案写作、逻辑推理）；

• 团队有明确的"分工"（比如一个负责收集信息，一个负责处理数据，一个负责输出结果）；

• 员工之间能"沟通协作"（比如数据员把分析结果传给文案员，文案员根据数据写报告）；

• 最终共同完成一个"大目标"（比如给客户出一份市场调研方案）。

单智能体就像一个全能打工人，啥活都干，但效率低、容易出错；多智能体则是专业分工的团队，各司其职、协同作战，能搞定更复杂的任务。比如：

• 自动写论文：一个智能体找文献，一个智能体整理数据，一个智能体搭建框架，一个智能体润色文字；

• 电商智能客服：一个智能体接待咨询，一个智能体查询订单，一个智能体处理售后，一个智能体升级投诉；

• 自动驾驶车队：每个车辆是一个智能体，相互通信、协同避障、优化路线。

这么一说，是不是瞬间就懂了？多智能体的核心不是"高大上的算法"，而是"合理的分工+高效的协作"。哪怕你用最简单的逻辑搭建分工，只要协作顺畅，就是一个能用的多智能体系统。

二、多智能体开发的核心误区：别一上来就扎进算法堆里

很多新手刚接触多智能体，就疯狂啃"强化学习协作""博弈论建模"，结果学了一个月，连个简单的demo都跑不起来。这就是典型的"本末倒置"。

根据我十多年的实战经验，多智能体开发的优先级是：需求拆解 > 分工设计 > 协作逻辑 > 算法优化。绝大多数商业场景下，不需要复杂的算法，用"规则+基础AI模型"就能落地80%的需求。

给大家举个真实案例：去年帮一家教育公司做"智能作业辅导多智能体系统"，他们一开始要求"用强化学习实现智能体自适应协作"，预算高、周期长。我先帮他们拆解需求，发现核心需求是"批改作业+答疑+知识点讲解"，根本不需要复杂算法。最后用3个基础智能体+简单的通信逻辑，2周就落地了，效果完全满足需求，成本直接砍了70%。

所以说，新手开发多智能体，千万别被"高大上的概念"绑架，先聚焦"解决实际问题"，把分工和协作逻辑跑通，再考虑算法优化。这就像盖房子，先搭好框架，再装修细节，而不是先去研究砖头的分子结构。

三、实战环节：手把手教你搭建"智能办公多智能体系统"

接下来进入重头戏！咱们以"智能办公多智能体系统"为目标，从需求拆解到代码实现，一步步带大家落地。这个系统能实现：自动收集会议纪要、整理待办事项、分配任务、跟进进度、生成周报，完全解放你的办公效率。

3.1 需求拆解：先明确"要解决什么问题"

任何开发都始于需求，咱们用"用户故事法"拆解需求：

• 用户痛点1：开会记笔记分心，会后忘记关键信息 → 需要"会议纪要智能体"：自动录制会议音频、转文字、提取核心要点；

• 用户痛点2：待办事项太多，容易遗漏 → 需要"任务整理智能体"：从会议纪要中提取待办事项、标注优先级、设定截止日期；

• 用户痛点3：任务分配混乱，责任不明确 → 需要"任务分配智能体"：根据团队成员的职责和工作量，自动分配任务；

• 用户痛点4：不清楚任务进度，需要反复跟进 → 需要"进度跟进智能体"：定期提醒成员更新进度、汇总进度情况；

• 用户痛点5：写周报耗时费力 → 需要"周报生成智能体"：根据任务进度、完成情况，自动生成周报。

核心目标：让每个智能体专注解决一个痛点，通过协作完成"从会议到周报"的全流程自动化。

3.2 架构设计：搭建多智能体的"骨架"

架构设计不用复杂，咱们采用"模块化+消息队列"的架构，方便后续扩展和维护：

• 核心层：5个智能体（会议纪要、任务整理、任务分配、进度跟进、周报生成）；

• 通信层：用Redis做消息队列，智能体之间通过"发布-订阅"模式通信（简单说就是一个智能体完成任务后，把结果"发出去"，需要这个结果的智能体"收到"后继续工作）；

• 存储层：用MySQL存储任务信息、进度数据、周报内容；

• 接口层：提供Web接口，支持手动触发和定时触发（比如每天下班前自动生成周报）。

这个架构的好处是：每个模块独立开发、独立部署，哪怕某个智能体出问题，也不影响整个系统运行，后续想加新智能体（比如"请假审批智能体"），直接接入消息队列就行。

3.3 代码实现：从0到1编写多智能体系统（可直接复用）

咱们用Python开发，因为Python生态丰富，AI模型调用、数据库操作、接口开发都很方便。先给大家列一下依赖包，直接pip安装即可：

python 复制代码

# 核心依赖包
pip install openai  # 调用大模型实现智能处理
pip install redis  # 消息队列
pip install pymysql  # 操作MySQL数据库
pip install flask  # 开发Web接口
pip install speechrecognition  # 音频转文字（会议纪要用）
pip install python-dotenv  # 管理环境变量

3.3.1 第一步：搭建基础配置（config.py）

先配置数据库、Redis、大模型的连接信息，后续直接调用：

python 复制代码

import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# MySQL配置
MYSQL_CONFIG = {
    "host": os.getenv("MYSQL_HOST", "localhost"),
    "user": os.getenv("MYSQL_USER", "root"),
    "password": os.getenv("MYSQL_PASSWORD", "123456"),
    "database": os.getenv("MYSQL_DB", "multi_agent_office"),
    "charset": "utf8mb4"
}

# Redis配置
REDIS_CONFIG = {
    "host": os.getenv("REDIS_HOST", "localhost"),
    "port": int(os.getenv("REDIS_PORT", 6379)),
    "db": int(os.getenv("REDIS_DB", 0))
}

# 大模型配置（用OpenAI的GPT-3.5，也可以替换成国内模型如通义千问）
OPENAI_CONFIG = {
    "api_key": os.getenv("OPENAI_API_KEY"),
    "model": "gpt-3.5-turbo",
    "temperature": 0.3  # 控制输出稳定性，越低越稳定
}

# 智能体通信的消息主题（相当于聊天群，每个主题对应一个协作环节）
MESSAGE_TOPICS = {
    "meeting_minutes": "agent_meeting_minutes",  # 会议纪要主题
    "task_extract": "agent_task_extract",        # 任务提取主题
    "task_assign": "agent_task_assign",          # 任务分配主题
    "progress_track": "agent_progress_track",    # 进度跟进主题
    "weekly_report": "agent_weekly_report"       # 周报生成主题
}

3.3.2 第二步：封装基础工具类（utils.py）

封装数据库操作、Redis消息队列、大模型调用的工具类，避免重复代码：

python 复制代码

import pymysql
import redis
import openai
from config import MYSQL_CONFIG, REDIS_CONFIG, OPENAI_CONFIG

# 数据库工具类
class MySQLUtil:
    def __init__(self):
        self.conn = pymysql.connect(**MYSQL_CONFIG)
        self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)
    
    def execute(self, sql, args=None):
        """执行SQL语句"""
        try:
            self.cursor.execute(sql, args)
            self.conn.commit()
            return self.cursor.fetchall()
        except Exception as e:
            self.conn.rollback()
            print(f"MySQL执行失败：{e}")
            return None
    
    def close(self):
        self.cursor.close()
        self.conn.close()

# Redis消息队列工具类
class RedisMQ:
    def __init__(self):
        self.client = redis.Redis(**REDIS_CONFIG)
    
    def publish(self, topic, message):
        """发布消息"""
        self.client.publish(topic, message)
        print(f"向{topic}发布消息：{message[:50]}...")
    
    def subscribe(self, topic):
        """订阅消息"""
        pubsub = self.client.pubsub()
        pubsub.subscribe(topic)
        print(f"订阅{topic}成功，等待消息...")
        return pubsub.listen()

# 大模型调用工具类
class LLMUtil:
    def __init__(self):
        openai.api_key = OPENAI_CONFIG["api_key"]
    
    def call_llm(self, prompt):
        """调用大模型获取结果"""
        try:
            response = openai.ChatCompletion.create(
                model=OPENAI_CONFIG["model"],
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message["content"].strip()
        except Exception as e:
            print(f"大模型调用失败：{e}")
            return None

# 单例模式，避免重复创建连接
mysql_util = MySQLUtil()
redis_mq = RedisMQ()
llm_util = LLMUtil()

3.3.3 第三步：开发核心智能体（agents/目录下）

每个智能体一个文件，专注自己的核心功能，通过Redis消息队列通信。

① 会议纪要智能体（agents/meeting_minutes_agent.py）

功能：接收会议音频文件路径，转文字后提取核心要点，发布到"任务提取"主题。

python 复制代码

import speech_recognition as sr
from utils import redis_mq, llm_util, MESSAGE_TOPICS

class MeetingMinutesAgent:
    def __init__(self):
        self.topic = MESSAGE_TOPICS["meeting_minutes"]
        self.target_topic = MESSAGE_TOPICS["task_extract"]
    
    def audio_to_text(self, audio_path):
        """音频转文字"""
        r = sr.Recognizer()
        with sr.AudioFile(audio_path) as source:
            audio = r.record(source)
        try:
            text = r.recognize_google(audio, language="zh-CN")
            print(f"音频转文字成功，内容长度：{len(text)}字")
            return text
        except Exception as e:
            print(f"音频转文字失败：{e}")
            return None
    
    def extract_key_points(self, text):
        """提取会议核心要点（调用大模型）"""
        prompt = f"""
        请你作为会议纪要助手，从以下会议文字中提取核心要点，包括：
        1. 会议主题
        2. 参与人员（如果有）
        3. 讨论的关键问题
        4. 达成的共识
        5. 提到的待办事项（初步）
        
        要求：语言简洁、条理清晰，分点列出。
        会议文字：{text}
        """
        return llm_util.call_llm(prompt)
    
    def run(self, audio_path):
        """运行智能体"""
        print("=== 会议纪要智能体开始工作 ===")
        # 1. 音频转文字
        meeting_text = self.audio_to_text(audio_path)
        if not meeting_text:
            print("会议纪要智能体工作失败：音频转文字失败")
            return
        # 2. 提取核心要点
        key_points = self.extract_key_points(meeting_text)
        if not key_points:
            print("会议纪要智能体工作失败：提取要点失败")
            return
        # 3. 发布到消息队列，供任务整理智能体使用
        redis_mq.publish(self.target_topic, key_points)
        print("=== 会议纪要智能体工作完成 ===")
        return key_points

# 测试代码
if __name__ == "__main__":
    agent = MeetingMinutesAgent()
    # 替换成你的会议音频文件路径（支持wav、mp3格式）
    agent.run("meeting_audio.wav")

② 任务整理智能体（agents/task_extract_agent.py）

功能：订阅会议纪要要点，提取结构化待办事项，存储到数据库，发布到"任务分配"主题。

python 复制代码

from utils import redis_mq, llm_util, mysql_util, MESSAGE_TOPICS
import json

class TaskExtractAgent:
    def __init__(self):
        self.topic = MESSAGE_TOPICS["task_extract"]
        self.target_topic = MESSAGE_TOPICS["task_assign"]
    
    def extract_structured_tasks(self, key_points):
        """提取结构化待办事项（调用大模型）"""
        prompt = f"""
        请你作为任务整理助手，从以下会议核心要点中提取结构化的待办事项，格式要求：
        [
            {{
                "task_name": "任务名称",
                "description": "任务详细描述",
                "priority": "优先级（高/中/低）",
                "deadline": "截止日期（如果有，格式YYYY-MM-DD；没有则填None）",
                "related_topic": "关联会议主题"
            }}
        ]
        
        要求：严格按照JSON格式输出，不要添加额外文字，确保可以直接用json.loads解析。
        会议核心要点：{key_points}
        """
        result = llm_util.call_llm(prompt)
        try:
            return json.loads(result)
        except Exception as e:
            print(f"解析任务JSON失败：{e}，原始结果：{result}")
            return None
    
    def save_tasks_to_db(self, tasks):
        """将任务存储到数据库"""
        sql = """
        INSERT INTO tasks (task_name, description, priority, deadline, related_topic, status)
        VALUES (%s, %s, %s, %s, %s, 'pending')
        """
        for task in tasks:
            args = (
                task["task_name"],
                task["description"],
                task["priority"],
                task["deadline"] if task["deadline"] != "None" else None,
                task["related_topic"]
            )
            mysql_util.execute(sql, args)
        print(f"成功存储{len(tasks)}个任务到数据库")
    
    def run(self):
        """运行智能体（持续监听消息队列）"""
        print("=== 任务整理智能体开始工作 ===")
        for message in redis_mq.subscribe(self.topic):
            if message["type"] == "message":
                key_points = message["data"].decode("utf-8")
                print(f"收到会议核心要点：{key_points[:50]}...")
                # 1. 提取结构化任务
                tasks = self.extract_structured_tasks(key_points)
                if not tasks:
                    print("任务整理智能体工作失败：提取结构化任务失败")
                    continue
                # 2. 存储到数据库
                self.save_tasks_to_db(tasks)
                # 3. 发布到消息队列，供任务分配智能体使用
                redis_mq.publish(self.target_topic, json.dumps(tasks))
                print("=== 任务整理智能体工作完成 ===")

# 测试代码
if __name__ == "__main__":
    agent = TaskExtractAgent()
    agent.run()

③ 任务分配智能体（agents/task_assign_agent.py）

功能：订阅结构化任务，根据团队成员信息分配任务，更新数据库，发布到"进度跟进"主题。

python 复制代码

from utils import redis_mq, llm_util, mysql_util, MESSAGE_TOPICS
import json

class TaskAssignAgent:
    def __init__(self):
        self.topic = MESSAGE_TOPICS["task_assign"]
        self.target_topic = MESSAGE_TOPICS["progress_track"]
        # 团队成员信息（实际项目中可从数据库读取）
        self.team_members = [
            {"name": "张三", "role": "产品经理", "current_tasks": 2, "expertise": "需求分析、产品设计"},
            {"name": "李四", "role": "后端开发", "current_tasks": 3, "expertise": "Python、数据库开发"},
            {"name": "王五", "role": "前端开发", "current_tasks": 1, "expertise": "Vue、React、UI设计"},
            {"name": "赵六", "role": "测试工程师", "current_tasks": 2, "expertise": "功能测试、性能测试"}
        ]
    
    def assign_tasks(self, tasks):
        """分配任务（结合团队成员信息和大模型判断）"""
        team_info = json.dumps(self.team_members, ensure_ascii=False)
        tasks_info = json.dumps(tasks, ensure_ascii=False)
        
        prompt = f"""
        请你作为任务分配助手，根据以下团队成员信息和待办事项，为每个任务分配合适的负责人：
        分配规则：
        1. 负责人的职责和专业技能需匹配任务需求；
        2. 尽量平衡每个成员的当前工作量（current_tasks越少，优先分配）；
        3. 输出格式：每个任务一行，格式为"任务名称：负责人姓名"；
        4. 不要添加额外文字，只输出分配结果。
        
        团队成员信息：{team_info}
        待办事项：{tasks_info}
        """
        result = llm_util.call_llm(prompt)
        # 解析分配结果
        assigned_tasks = []
        for line in result.strip().split("\n"):
            if "：" in line:
                task_name, assignee = line.split("：", 1)
                # 找到对应的任务，添加负责人信息
                for task in tasks:
                    if task["task_name"] == task_name.strip():
                        task["assignee"] = assignee.strip()
                        assigned_tasks.append(task)
        return assigned_tasks
    
    def update_task_assignee(self, assigned_tasks):
        """更新数据库中的任务负责人"""
        sql = """
        UPDATE tasks SET assignee = %s WHERE task_name = %s
        """
        for task in assigned_tasks:
            mysql_util.execute(sql, (task["assignee"], task["task_name"]))
        print(f"成功更新{len(assigned_tasks)}个任务的负责人")
    
    def run(self):
        """运行智能体（持续监听消息队列）"""
        print("=== 任务分配智能体开始工作 ===")
        for message in redis_mq.subscribe(self.topic):
            if message["type"] == "message":
                tasks = json.loads(message["data"].decode("utf-8"))
                print(f"收到待分配任务：{len(tasks)}个")
                # 1. 分配任务
                assigned_tasks = self.assign_tasks(tasks)
                if not assigned_tasks:
                    print("任务分配智能体工作失败：分配任务失败")
                    continue
                # 2. 更新数据库
                self.update_task_assignee(assigned_tasks)
                # 3. 发布到消息队列，供进度跟进智能体使用
                redis_mq.publish(self.target_topic, json.dumps(assigned_tasks))
                print("=== 任务分配智能体工作完成 ===")

# 测试代码
if __name__ == "__main__":
    agent = TaskAssignAgent()
    agent.run()

④ 进度跟进智能体（agents/progress_track_agent.py）

功能：订阅已分配任务，定期提醒成员更新进度，汇总进度数据，发布到"周报生成"主题。

python 复制代码

from utils import redis_mq, llm_util, mysql_util, MESSAGE_TOPICS
import json
import time
from datetime import datetime

class ProgressTrackAgent:
    def __init__(self):
        self.topic = MESSAGE_TOPICS["progress_track"]
        self.target_topic = MESSAGE_TOPICS["weekly_report"]
        self.reminder_interval = 86400  # 每天提醒一次（单位：秒）
    
    def send_reminder(self, task):
        """发送进度提醒（实际项目中可对接企业微信、钉钉）"""
        reminder_msg = f"""
        【任务进度提醒】
        任务名称：{task["task_name"]}
        负责人：{task["assignee"]}
        优先级：{task["priority"]}
        截止日期：{task["deadline"] if task["deadline"] else "无"}
        请及时更新任务进度（未开始/进行中/已完成）
        """
        print(reminder_msg)
        # 实际项目中可添加发送逻辑，比如调用企业微信API
        return reminder_msg
    
    def get_task_progress(self, task):
        """获取任务进度（这里用模拟数据，实际项目中可对接表单或API）"""
        # 模拟成员回复进度
        progress_options = ["未开始", "进行中（30%）", "进行中（70%）", "已完成"]
        # 调用大模型模拟合理的进度（根据截止日期和优先级）
        prompt = f"""
        任务：{task["task_name"]}，优先级：{task["priority"]}，截止日期：{task["deadline"] if task["deadline"] else "无"}
        请从{progress_options}中选择一个合理的进度，只返回选项内容，不要添加额外文字。
        """
        progress = llm_util.call_llm(prompt)
        if progress not in progress_options:
            progress = "进行中（50%）"  # 默认值
        return progress
    
    def update_task_progress(self, task, progress):
        """更新数据库中的任务进度"""
        sql = """
        UPDATE tasks SET progress = %s, update_time = %s WHERE task_name = %s
        """
        mysql_util.execute(sql, (progress, datetime.now(), task["task_name"]))
        print(f"任务{task["task_name"]}进度更新为：{progress}")
    
    def run(self):
        """运行智能体（持续监听消息队列，定期提醒）"""
        print("=== 进度跟进智能体开始工作 ===")
        assigned_tasks = []
        # 第一步：接收已分配任务
        for message in redis_mq.subscribe(self.topic):
            if message["type"] == "message":
                tasks = json.loads(message["data"].decode("utf-8"))
                assigned_tasks.extend(tasks)
                print(f"已接收{len(assigned_tasks)}个待跟进任务")
        
        # 第二步：定期提醒并更新进度
        while True:
            print(f"\n=== {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} 开始进度跟进 ===")
            progress_data = []
            for task in assigned_tasks:
                # 发送提醒
                self.send_reminder(task)
                # 获取进度
                progress = self.get_task_progress(task)
                # 更新数据库
                self.update_task_progress(task, progress)
                # 收集进度数据
                progress_data.append({
                    "task_name": task["task_name"],
                    "assignee": task["assignee"],
                    "priority": task["priority"],
                    "progress": progress,
                    "deadline": task["deadline"]
                })
            # 发布进度数据到消息队列，供周报生成智能体使用
            redis_mq.publish(self.target_topic, json.dumps(progress_data))
            print("=== 本次进度跟进完成 ===")
            # 等待下一次提醒
            time.sleep(self.reminder_interval)

# 测试代码
if __name__ == "__main__":
    agent = ProgressTrackAgent()
    agent.run()

⑤ 周报生成智能体（agents/weekly_report_agent.py）

功能：订阅进度数据，自动生成周报，支持导出为Word或PDF。

python 复制代码

from utils import redis_mq, llm_util, MESSAGE_TOPICS
import json
from datetime import datetime, timedelta
from docx import Document  # 生成Word文档

class WeeklyReportAgent:
    def __init__(self):
        self.topic = MESSAGE_TOPICS["weekly_report"]
        self.week_start = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
        self.week_end = datetime.now().strftime("%Y-%m-%d")
    
    def generate_weekly_report(self, progress_data):
        """生成周报（调用大模型）"""
        progress_info = json.dumps(progress_data, ensure_ascii=False)
        
        prompt = f"""
        请你作为周报生成助手，根据以下任务进度数据，生成一份专业的工作周报：
        周报结构：
        1. 周报周期：{self.week_start} - {self.week_end}
        2. 任务总体进度：汇总所有任务的完成情况（已完成数量、进行中数量、未开始数量）
        3. 详细任务进度：按负责人分组，列出每个成员的任务名称、进度、优先级、截止日期
        4. 问题与建议：根据进度情况，提出1-2个潜在问题（如高优先级任务进度滞后）和改进建议
        5. 下周计划：基于未完成任务，简单列出下周重点工作
        
        要求：语言正式、条理清晰、数据准确，不要使用Markdown格式，用普通文本分段。
        任务进度数据：{progress_info}
        """
        return llm_util.call_llm(prompt)
    
    def save_report_to_word(self, report_content):
        """将周报保存为Word文档"""
        doc = Document()
        doc.add_heading(f"工作周报（{self.week_start} - {self.week_end}）", level=1)
        doc.add_paragraph(report_content)
        report_path = f"weekly_report_{self.week_start}_{self.week_end}.docx"
        doc.save(report_path)
        print(f"周报已保存到：{report_path}")
        return report_path
    
    def run(self):
        """运行智能体（持续监听消息队列）"""
        print("=== 周报生成智能体开始工作 ===")
        for message in redis_mq.subscribe(self.topic):
            if message["type"] == "message":
                progress_data = json.loads(message["data"].decode("utf-8"))
                print(f"收到{len(progress_data)}个任务的进度数据，开始生成周报...")
                # 1. 生成周报内容
                report_content = self.generate_weekly_report(progress_data)
                if not report_content:
                    print("周报生成智能体工作失败：生成周报内容失败")
                    continue
                # 2. 保存为Word文档
                self.save_report_to_word(report_content)
                print("=== 周报生成智能体工作完成 ===")
                print("\n生成的周报预览：")
                print("-" * 50)
                print(report_content)
                print("-" * 50)

# 测试代码
if __name__ == "__main__":
    agent = WeeklyReportAgent()
    agent.run()

3.3.4 第四步：开发Web接口（app.py）

提供接口供外部调用，支持上传音频文件触发整个流程：

python 复制代码

from flask import Flask, request, jsonify
from agents.meeting_minutes_agent import MeetingMinutesAgent
import os

app = Flask(__name__)
app.config["UPLOAD_FOLDER"] = "uploads"
# 创建上传文件夹（如果不存在）
if not os.path.exists(app.config["UPLOAD_FOLDER"]):
    os.makedirs(app.config["UPLOAD_FOLDER"])

# 实例化智能体
meeting_agent = MeetingMinutesAgent()

@app.route("/trigger_agent", methods=["POST"])
def trigger_agent():
    """触发多智能体系统：上传会议音频，启动流程"""
    # 检查是否有文件上传
    if "audio" not in request.files:
        return jsonify({"code": 400, "message": "请上传会议音频文件"})
    
    audio_file = request.files["audio"]
    # 检查文件格式
    allowed_extensions = {"wav", "mp3", "flac"}
    if not audio_file.filename.split(".")[-1].lower() in allowed_extensions:
        return jsonify({"code": 400, "message": "仅支持wav、mp3、flac格式的音频文件"})
    
    # 保存文件
    file_path = os.path.join(app.config["UPLOAD_FOLDER"], audio_file.filename)
    audio_file.save(file_path)
    
    # 启动会议纪要智能体，触发整个流程
    try:
        key_points = meeting_agent.run(file_path)
        return jsonify({
            "code": 200,
            "message": "多智能体系统已启动，正在处理会议数据",
            "data": {"meeting_key_points": key_points}
        })
    except Exception as e:
        return jsonify({"code": 500, "message": f"系统运行失败：{str(e)}"})

@app.route("/health", methods=["GET"])
def health_check():
    """健康检查接口"""
    return jsonify({"code": 200, "message": "多智能体系统运行正常"})

if __name__ == "__main__":
    # 调试模式，实际部署时改为生产模式
    app.run(debug=True, host="0.0.0.0", port=5000)

3.3.5 第五步：数据库初始化脚本（init_db.py）

创建任务表，用于存储任务信息：

python 复制代码

from utils import mysql_util

def init_database():
    """初始化数据库表"""
    create_table_sql = """
    CREATE TABLE IF NOT EXISTS tasks (
        id INT AUTO_INCREMENT PRIMARY KEY,
        task_name VARCHAR(255) NOT NULL COMMENT '任务名称',
        description TEXT COMMENT '任务描述',
        priority ENUM('高', '中', '低') NOT NULL COMMENT '优先级',
        deadline DATE COMMENT '截止日期',
        related_topic VARCHAR(255) COMMENT '关联会议主题',
        assignee VARCHAR(50) COMMENT '负责人',
        status ENUM('pending', 'in_progress', 'completed') DEFAULT 'pending' COMMENT '任务状态',
        progress VARCHAR(50) DEFAULT '未开始' COMMENT '任务进度',
        create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
        update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='任务表';
    """
    mysql_util.execute(create_table_sql)
    print("数据库表初始化成功")

if __name__ == "__main__":
    init_database()

3.4 系统运行与测试：一步步验证效果

到这里，整个多智能体系统的代码就写完了！接下来教大家如何运行和测试：

运行前准备：

安装所有依赖包（前面列的pip命令）；
准备一个MySQL数据库，创建名为multi_agent_office的数据库；
安装Redis并启动（默认端口6379）；
申请OpenAI API Key（如果没有，可以替换成国内模型如通义千问、智谱AI，修改LLMUtil类的调用逻辑即可）；
创建.env文件，配置环境变量：

env 复制代码

MYSQL_HOST=localhost
MYSQL_USER=root
MYSQL_PASSWORD=123456
MYSQL_DB=multi_agent_office
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0
OPENAI_API_KEY=你的OpenAI API Key

运行步骤：

初始化数据库：运行init_db.py，创建任务表；
启动各个智能体（建议打开5个终端，分别运行）：

◦ 终端1：python agents/meeting_minutes_agent.py（会议纪要智能体，测试用，实际可通过接口触发）；

◦ 终端2：python agents/task_extract_agent.py（任务整理智能体）；

◦ 终端3：python agents/task_assign_agent.py（任务分配智能体）；

◦ 终端4：python agents/progress_track_agent.py（进度跟进智能体）；

◦ 终端5：python agents/weekly_report_agent.py（周报生成智能体）；

启动Web接口：运行app.py；
触发系统：用Postman或curl调用http://localhost:5000/trigger_agent接口，上传会议音频文件；
查看结果：等待一段时间后，会在当前目录生成周报Word文档，同时可以在MySQL数据库中查看任务信息。

测试效果示例：我上传了一个10分钟的产品会议音频，系统自动转文字、提取要点，生成了3个结构化任务，分配给了对应的团队成员，第二天自动生成了周报，整个流程完全自动化，没有人工干预！

四、工程化部署：从本地测试到生产环境

本地测试通过后，如何部署到生产环境供团队使用？给大家分享一套简单易操作的部署方案（基于Docker，新手也能上手）。

4.1 编写Dockerfile（每个智能体和接口单独打包）

以Web接口为例，编写Dockerfile：

dockerfile 复制代码

FROM python:3.9-slim

WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制代码
COPY . .

# 暴露端口
EXPOSE 5000

# 启动命令
CMD ["python", "app.py"]

其他智能体的Dockerfile类似，只需修改启动命令（如CMD ["python", "agents/task_extract_agent.py"]）。

4.2 编写docker-compose.yml（一键启动所有服务）

yaml 复制代码

version: '3'

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: multi_agent_office
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    restart: always

  redis:
    image: redis:6.2
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    restart: always

  web-api:
    build: .
    depends_on:
      - mysql
      - redis
    ports:
      - "5000:5000"
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

  meeting-minutes-agent:
    build:
      context: .
      dockerfile: Dockerfile.agent
    command: python agents/meeting_minutes_agent.py
    depends_on:
      - mysql
      - redis
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

  task-extract-agent:
    build:
      context: .
      dockerfile: Dockerfile.agent
    command: python agents/task_extract_agent.py
    depends_on:
      - mysql
      - redis
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

  task-assign-agent:
    build:
      context: .
      dockerfile: Dockerfile.agent
    command: python agents/task_assign_agent.py
    depends_on:
      - mysql
      - redis
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

  progress-track-agent:
    build:
      context: .
      dockerfile: Dockerfile.agent
    command: python agents/progress_track_agent.py
    depends_on:
      - mysql
      - redis
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

  weekly-report-agent:
    build:
      context: .
      dockerfile: Dockerfile.agent
    command: python agents/weekly_report_agent.py
    depends_on:
      - mysql
      - redis
    environment:
      - MYSQL_HOST=mysql
      - REDIS_HOST=redis
    restart: always

volumes:
  mysql-data:
  redis-data:

4.3 部署步骤：

在服务器上安装Docker和Docker Compose；
将所有代码上传到服务器；
编写requirements.txt文件，列出所有依赖包；
运行docker-compose up -d，一键启动所有服务；
运行docker-compose logs -f，查看服务运行日志；
用Postman调用服务器IP+5000端口的接口，测试系统功能。

这套部署方案的好处是：所有服务容器化，环境一致，不用担心"本地能跑，服务器跑不起来"的问题，而且可以通过Docker Compose轻松实现启停、扩容、升级。

五、扩展与优化：让你的多智能体系统更强大

通过上面的步骤，你已经拥有了一个能用的多智能体系统，但这只是基础版本。根据实际需求，还可以进行以下扩展和优化：

5.1 功能扩展

• 增加"请假审批智能体"：处理团队成员请假申请，自动更新任务进度；

• 增加"文件解析智能体"：支持上传Excel、Word文件，提取其中的任务信息；

• 增加"预警智能体"：当高优先级任务进度滞后时，自动发送预警通知给负责人和管理者；

• 对接企业微信/钉钉：直接在企业微信中接收提醒、更新进度、查看周报。

5.2 性能优化

• 大模型缓存：用Redis缓存大模型的常见回复，减少调用次数，提高响应速度；

• 异步处理：将耗时操作（如音频转文字、大模型调用）改为异步，避免接口阻塞；

• 负载均衡：如果智能体数量多，可以用Nginx做负载均衡，分发请求；

• 数据库优化：给常用查询字段（如assignee、status）建立索引，提高查询速度。

5.3 算法优化

• 当系统运行一段时间后，积累了足够的任务分配数据，可以用机器学习模型替代大模型分配任务，提高分配准确率；

• 引入强化学习：如果需要智能体自适应调整协作策略（比如根据团队成员的工作效率动态分配任务），可以引入强化学习算法；

• 多模态支持：除了音频，还可以支持视频会议、图片、PDF等多种输入格式。

虽然不懂AI基础知识也能开发AI应用，但是懂的人往往可以开发出更复杂更优秀的AI高级应用。如果你对AI基础知识感兴趣，可以看看我的人工智能入门教程https://blog.csdn.net/jiangjunshow。这套教程通俗易懂，不需要高深的高数和编程基础，高中水平就能学，还加入了很多搞笑元素，让你快乐学习AI基础知识，为后续开发更复杂的多智能体系统打下坚实基础。

六、总结：多智能体开发的核心心法

看到这里，相信你对多智能体开发已经有了清晰的认识。最后，给大家分享几个核心心法，帮你在多智能体的路上少走弯路：

需求为王：永远不要为了"多智能体"而做"多智能体"，所有开发都要围绕解决实际问题展开；
先跑通，再优化：新手不要一开始就追求完美，先搭建最小可行系统，跑通核心流程，再逐步优化功能和性能；
模块化设计：每个智能体专注一个功能，模块之间通过标准化的接口通信，方便扩展和维护；
拥抱开源：多利用开源框架（如LangChain、AutoGen、AgentScope），这些框架已经封装了很多多智能体的核心功能，能帮你节省大量开发时间；
持续迭代：多智能体系统不是一成不变的，要根据用户反馈和业务变化，持续迭代优化，让系统越来越贴合需求。

多智能体开发并不难，难的是打破"高大上"的心理壁垒，敢于动手实践。按照本文的工程化方案，你可以直接复用代码，快速落地自己的多智能体应用。如果在开发过程中遇到问题，欢迎在评论区留言，我会一一解答！

最后，祝大家都能开发出属于自己的多智能体系统，在AI时代抢占先机！🚀