浅尝AutoGen

同步发表于个人站点：

1. https:panzhixiang.com
2. https:panzhixiang.cn

AutoGen介绍

AutoGen是2023年5月29日第一次在FLAML（A Fast Library for Automated Machine Learning & Tuning）中创建，是一个用于构建AI Agents以及简化多Agents合作的开源框架，目前主要由微软、宾夕法尼亚州立大学和华盛顿大学开发。AutoGen的目标是为开发和研究生成式AI提供一个便于使用的、灵活的框架。

在AutoGen官方的介绍中，把自己之于生成式AI比作PyTorch之于深度学习。

关于Agents的定义有很多，在AutoGen中，Agent是一个可以收消息、发消息以及利用大模型、工具、人类输入中的一个或者几个生成返回的实体。

AutoGen是由众多的研究员和工程师开发的，引入了多智能体研究的最新成果，并且被引入到多个实际应用中。如投资、AI员工、写作、区块链、客户服务、网络安全、数据分析等等。

初步尝试

使用之前需要先安装，

pip install pyautogen

下面是一段案例代码，我在代码中使用的Azure OPENAI gpt-4o, 替换其中的变量为自己的真实值即可运行。

import os
import autogen
from autogen import AssistantAgent, UserProxyAgent
from autogen import ConversableAgent


llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "base_url": os.environ.get("OPENAI_API_BASE"),
    "api_type": "azure",
    "api_version": "2023-03-15-preview",
    "temperature": 0.9,
}

assistant = AssistantAgent("assistant", llm_config=llm_config)
user_proxy = UserProxyAgent("user_proxy", code_execution_config=False)

user_proxy.initiate_chat(
    assistant,
    message="介绍一下多智能体协作相关的内容",
)

执行结果如下：

	user_proxy (to assistant):
	
	介绍一下多智能体协作相关的内容
	
	--------------------------------------------------------------------------------
	assistant (to user_proxy):
	
	多智能体协作（Multi-Agent Collaboration）是人工智能研究领域中的一个重要课题，它涉及多个自主智能体通过合作来完成某个任务或达到某个目标。以下是多智能体协作的一些关键内容和要点：
	
	### 1. 基本概念
	
	- **智能体（Agent）**：一个智能体是一个能够感知其环境并采取行动以实现其目标的自主实体。智能体可以是软件程序、机器人、传感器等。
	- **多智能体系统（MAS）**：这是指多个智能体通过相互作用、通信和协作，共同完成复杂任务的系统。
	
	### 2. 协作的类型
	
	- **集中式协作**：在这种模型中，有一个中央控制单元来协调各个智能体的活动。这种方法的优点是易于控制和管理，但缺点是中央控制单元的故障会影响整个系统。
	- **分布式协作**：智能体之间通过分布式通信和决策来实现协作。每个智能体都有一定的自主性，可以根据局部信息和其他智能体的反馈来决策。这种方法更具鲁棒性和扩展性。
	
	### 3. 协作策略
	
	- **任务分配**：将大任务分解为多个子任务，并将这些子任务分配给不同的智能体。
	- **资源共享**：智能体之间共享资源以提高效率和性能。
	- **通信和协调**：智能体通过通信来交换信息，协调行动。
	
	### 4. 协作的挑战
	
	- **通信开销**：在分布式系统中，智能体之间的通信可能会产生较大的开销。
	- **一致性**：如何确保智能体之间的决策一致性，避免冲突。
	- **鲁棒性**：在面对个别智能体失效的情况下，系统如何维持正常运行。
	- **学习和适应**：智能体如何通过学习和适应来提高协作效率。
	
	### 5. 应用领域
	
	- **机器人足球**：多个机器人在一个团队中协作，共同比赛。
	- **自动驾驶车队**：多辆自动驾驶汽车协同行驶，以提高道路安全和交通效率。
	- **供应链管理**：不同企业或部门之间的协作，以优化整个供应链的效率。
	
	### 6. 相关算法和技术
	
	- **强化学习**：用于训练智能体在复杂环境中通过试错学习最佳策略。
	- **博弈论**：分析智能体之间的策略和收益。
	- **拍卖算法**：用于解决任务分配等问题。
	
	下面是一个简单的Python示例代码，展示了两个智能体在一个共享环境中合作的基本概念：
	
	```python
	# filename: multi_agent_collaboration.py
	
	class Agent:
	    def __init__(self, name):
	        self.name = name
	    
	    def act(self, environment):
	        raise NotImplementedError
	
	class Environment:
	    def __init__(self):
	        self.state = 0
	        self.goal = 10
	    
	    def update(self, action):
	        self.state += action
	        return self.state
	    
	    def is_goal_reached(self):
	        return self.state >= self.goal
	
	class CooperativeAgent(Agent):
	    def act(self, environment):
	        if environment.state < environment.goal:
	            action = 1
	        else:
	            action = 0
	        print(f"{self.name} performs action: {action}")
	        return action
	
	def main():
	    env = Environment()
	    agents = [CooperativeAgent("Agent 1"), CooperativeAgent("Agent 2")]
	    
	    while not env.is_goal_reached():
	        for agent in agents:
	            action = agent.act(env)
	            env.update(action)
	            print(f"Environment state: {env.state}")
	            if env.is_goal_reached():
	                break
	
	if __name__ == "__main__":
	    main()
	```
	
	这段代码定义了一个简单的环境和两个合作智能体，每个智能体都执行一个简单的动作，直到达到环境的目标状态。通过这种方式展示了多智能体协作的基本概念。
	
	希望这些信息对你有所帮助！如果还有其他问题，欢迎继续提问。TERMINATE

我原本想问的是特指大模型领域多智能体，但是看起来，它不是这么认为的…

上面这个demo从效果上来说，跟通过浏览器与大模型对话没有区别，但是AutoGen还可以执行代码，看看下面这个例子。

import os
import autogen
from autogen import AssistantAgent, UserProxyAgent
from autogen import ConversableAgent


llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "base_url": os.environ.get("OPENAI_API_BASE"),
    "api_type": "azure",
    "api_version": "2023-03-15-preview",
    "temperature": 0.9,
}

assistant = AssistantAgent("assistant", llm_config=llm_config)
user_proxy = UserProxyAgent(
    "user_proxy",
    code_execution_config={
        "executor": autogen.coding.LocalCommandLineCodeExecutor(work_dir="coding")
    },
)

# Start the chat
user_proxy.initiate_chat(
    assistant,
    message="你所在的系统是一个ubuntu，请你查一下当前系统的版本、CPU和内存相关的信息",
)

以下是返回：

	user_proxy (to assistant):
	
	你所在的系统是一个ubuntu，请你查一下当前系统的版本、CPU和内存相关的信息
	
	--------------------------------------------------------------------------------
	assistant (to user_proxy):
	
	好的，我会通过一个shell脚本来获取当前系统的版本、CPU和内存信息。请执行以下脚本：
	
	```sh
	# filename: system_info.sh
	#!/bin/bash
	
	echo "系统版本信息："
	lsb_release -a
	
	echo -e "\nCPU信息："
	lscpu
	
	echo -e "\n内存信息："
	free -h
	```
	
	此脚本将会输出系统的版本信息、CPU信息以及内存信息。请执行脚本并告知结果。
	
	--------------------------------------------------------------------------------
	Replying as user_proxy. Provide feedback to assistant. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: 
	
>>>>>>>> 	NO HUMAN INPUT RECEIVED.
	
>>>>>>>> 	USING AUTO REPLY...
	
>>>>>>>> 	EXECUTING CODE BLOCK (inferred language is sh)...
	user_proxy (to assistant):
	
	exitcode: 0 (execution succeeded)
	Code output: No LSB modules are available.
	系统版本信息：
	Distributor ID: Ubuntu
	Description:    Ubuntu 20.04.4 LTS
	Release:        20.04
	Codename:       focal
	-e 
	CPU信息：
	Architecture:                    x86_64
	CPU op-mode(s):                  32-bit, 64-bit
	Byte Order:                      Little Endian
	Address sizes:                   39 bits physical, 48 bits virtual
	CPU(s):                          8
	On-line CPU(s) list:             0-7
	Thread(s) per core:              2
	Core(s) per socket:              4
	Socket(s):                       1
	Vendor ID:                       GenuineIntel
	CPU family:                      6
	Model:                           142
	Model name:                      Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz
	Stepping:                        12
	CPU MHz:                         2304.007
	BogoMIPS:                        4608.01
	Virtualization:                  VT-x
	Hypervisor vendor:               Microsoft
	Virtualization type:             full
	L1d cache:                       128 KiB
	L1i cache:                       128 KiB
	L2 cache:                        1 MiB
	L3 cache:                        8 MiB
	Vulnerability Itlb multihit:     KVM: Mitigation: VMX disabled
	Vulnerability L1tf:              Not affected
	Vulnerability Mds:               Not affected
	Vulnerability Meltdown:          Not affected
	Vulnerability Spec store bypass: Mitigation; Speculative Store Bypass disabled via prctl and seccomp
	Vulnerability Spectre v1:        Mitigation; usercopy/swapgs barriers and __user pointer sanitization
	Vulnerability Spectre v2:        Mitigation; Enhanced IBRS, IBPB conditional, RSB filling
	Vulnerability Srbds:             Mitigation; TSX disabled
	Vulnerability Tsx async abort:   Mitigation; TSX disabled
	Flags:                           fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology cpuid pni pclmulqdq vmx ssse3 fma cx16 pcid sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch invpcid_single ssbd ibrs ibpb stibp ibrs_enhanced tpr_shadow vnmi ept vpid ept_ad fsgsbase bmi1 avx2 smep bmi2 erms invpcid rdseed adx smap clflushopt xsaveopt xsavec xgetbv1 xsaves md_clear flush_l1d arch_capabilities
	-e 
	内存信息：
	              total        used        free      shared  buff/cache   available
	Mem:          7.6Gi       2.6Gi       3.5Gi        34Mi       1.5Gi       4.7Gi
	Swap:         2.0Gi          0B       2.0Gi
	
	
	--------------------------------------------------------------------------------
	assistant (to user_proxy):
	
	根据您提供的输出信息，我可以总结出当前系统的版本、CPU和内存信息如下：
	
	### 系统版本信息
	- **发行商**: Ubuntu
	- **版本描述**: Ubuntu 20.04.4 LTS
	- **发布版本**: 20.04
	- **代号**: focal
	
	### CPU 信息
	- **架构**: x86_64
	- **操作模式**: 32-bit, 64-bit
	- **字节顺序**: Little Endian
	- **CPU 数量**: 8
	- **在线 CPU 列表**: 0-7
	- **每个核心的线程数**: 2
	- **每个插槽的核心数**: 4
	- **插槽数**: 1
	- **厂商 ID**: GenuineIntel
	- **CPU 家族**: 6
	- **型号**: 142
	- **型号名称**: Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz
	- **步进**: 12
	- **CPU 频率**: 2304.007 MHz
	- **虚拟化**: VT-x
	
	### 内存信息
	- **总内存**: 7.6 GiB
	- **已用内存**: 2.6 GiB
	- **空闲内存**: 3.5 GiB
	- **共享内存**: 34 MiB
	- **缓冲/缓存**: 1.5 GiB
	- **可用内存**: 4.7 GiB
	- **交换分区**: 2.0 GiB（未使用）
	
	这些信息可以帮助您了解当前系统的基本情况。请告知是否还有其他需要帮助的事项。
	
	TERMINATE

可以看到，AutoGen的确可以执行代码，通过这种方式，AutoGen就在一定程度上有了跟物理世界交互的能力，能做的事情也就更多。

AutoGen执行代码有两种方式，一个是直接在当前环境中执行(Local Execution), 就像上面的案例那样；还有一个是在容器中执行(Docker Execution)，这主要是出于安全考虑，担心大模型生成的代码存在安全问题。

Multi Agents

上面的两个案例都是单个Agent，AutoGen支持多Agent的，下面是一个多Agent的案例，我在这个案例设置了两个Agent，一个是Python开发的角色，一个是前端开发的角色，让他们开发一个适用于个人的博客网站，代码如下：

import os
import autogen
from autogen import AssistantAgent, UserProxyAgent
from autogen import ConversableAgent


llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "base_url": os.environ.get("OPENAI_API_BASE"),
    "api_type": "azure",
    "api_version": "2023-03-15-preview",
    "temperature": 0.9,
}

cathy = ConversableAgent(
    "cathy",
    system_message="""
    你是一个Python开发专家，精通Python语法，善于写出高性能、易维护的Python代码，并且精通Django、Django Rest Framework、FastAPI等框架和VUE3、ElementPlus开发，请你完成我交给你的开发任务。
    你擅长选择和挑选最佳工具，并尽力避免不必要的重复和复杂性。
    请你完成我交给你的任务，在解决问题时，你会将问题分解成小的问题和改善项，并在每个步骤后建议进行小测试，以确保事情在正确的轨道上。
    如果有任何不清楚或模糊的地方，你总是会要求澄清。你会暂停讨论权衡和实现选项，如果有需要做出选择的情况。
    重要的是，你要遵循这种方法，并尽最大努力教会你的对话者如何做出有效的决策。你避免不必要的道歉，并在回顾对话时不重复早先的错误
    """,
    llm_config=llm_config,
    human_input_mode="NEVER",  # Never ask for human input.
)

joe = ConversableAgent(
    "joe",
    system_message="""
    你是Web开发方面的专家，包括CSS、JavaScript、React、Tailwind、Node.JS和Hugo/Markdown。你擅长选择和挑选最好的工具，并尽力避免不必要的重复和复杂性。
    在提出建议时，你将事情分解为离散的改变，并建议在每个阶段之后进行小测试，以确保事情走在正确的轨道上。
    编写代码以说明示例，或在对话中被指示时编写代码。如果可以不使用代码回答，这是优选的，并且在需要时你会被要求详细说明。
    最后，你会生成正确的输出，提供解决当前问题与保持通用性和灵活性之间的正确平衡。
    如果有任何不明确或模糊的地方，你总是要求澄清。在需要做出选择时，你会停下来讨论权衡和实现选项。
    遵循这一方法非常重要，并尽力教会你的对话者如何做出有效的决策。你避免不必要的道歉，并审查对话，以防止重复早期的错误。
    你非常重视安全，并确保在每个步骤中不做任何可能危及数据或引入新漏洞的事情。每当有潜在的安全风险（例如输入处理、身份验证管理）时，你会进行额外的审查
    最后，确保所有生成的东西在操作上是可靠的。我们会考虑如何托管、管理、监控和维护我们的解决方案。在每一步中，你都会考虑运营方面的问题，并在相关的地方强调它们。
    """,
    llm_config=llm_config,
    human_input_mode="NEVER",  # Never ask for human input.
)

result = joe.initiate_chat(
    cathy,
    message="Cathy, 我们要开发一个适用于个人的博客网站，我们一起协作吧",
    max_turns=2,
)

代码的最后 max_turns=2 是指只允许这两个Agent交互两个来回。

执行结果如下：

	joe (to cathy):
	
	Cathy, 我们要开发一个适用于个人的博客网站，我们一起协作吧
	
	--------------------------------------------------------------------------------
	cathy (to joe):
	
	当然，Cathy！我们可以一起开发一个适用于个人的博客网站。为了确保我们的合作顺利和高效，我建议我们先制定一个计划，并将项目分解为几个关键的部分：
	
	1. **需求分析**：
	   - 什么是网站的主要功能？
	   - 用户角色和权限 (作者，读者，管理员)。
	   - 需要哪些页面？（首页、文章列表页、文章详细页、作者介绍页等）
	   - 是否需要用户注册和登录功能？
	   - 是否需要搜索和过滤功能？
	   - 是否需要评论功能？
	
	2. **技术选型**：
	   - 后端：Django 或 FastAPI？（考虑到你的熟悉程度和项目需求）
	   - 前端：VUE3 + ElementPlus
	   - 数据库：SQLite（开发阶段）或 PostgreSQL（生产环境）
	   - 部署平台：Heroku、AWS、Docker等
	
	3. **项目初始化**：
	   - 创建Django项目和应用程序
	   - 创建VUE3项目
	   - 设置Django Rest Framework（如果使用Django）或者FastAPI来提供API接口
	   - 配置跨域请求（CORS）
	
	4. **基本功能实现**：
	   - 用户认证和权限管理
	   - 文章的CRUD（创建、读取、更新、删除）
	   - 评论系统
	   - 前端页面开发和API对接
	
	5. **高级功能和优化**：
	   - 搜索和过滤功能
	   - 富文本编辑器实现
	   - 图片上传和管理
	   - 性能优化和缓存
	
	6. **测试和部署**：
	   - 编写单元测试和集成测试
	   - 设置持续集成（CI）
	   - 部署到生产环境
	
	我们先从需求分析开始。你对上述功能和流程有什么特别的需求或修改意见吗？如果有任何问题或具体需求，请告诉我。
	
	--------------------------------------------------------------------------------
	joe (to cathy):
	
	这是一个非常全面和细致的计划。好，我们从需求分析开始，逐步推进每一步。首先让我们确认需求细节：
	
	### 1. 需求分析
	#### 主要功能：
	- **博客文章发布和管理**：允许作者撰写、编辑和删除博客文章。
	- **用户注册和登录**：实现用户注册、登录、登出和权限管理功能。
	- **评论功能**：读者可以在文章下方发表评论，支持评论回复。
	- **搜索和过滤功能**：用户可以通过关键词搜索特定的文章。
	- **文章分类和标签**：支持文章分类和标签管理。
	- **作者介绍页**：展示作者的个人信息和所有发布的文章。
	
	#### 用户角色和权限：
	- **管理员**：拥有所有权限，包括用户管理、文章管理等。
	- **作者**：可以发布和管理自己的文章。
	- **读者**：可以注册、登录、评论文章，但不能发布或编辑文章。
	
	#### 页面需求：
	- **首页**：展示最新的博客文章。
	- **文章列表页**：按分类和标签展示文章列表。
	- **文章详情页**：展示单篇文章的详细内容。
	- **作者介绍页**：展示作者个人信息和文章列表。
	- **用户登录/注册页**：用户进行登录和注册。
	- **后台管理页**：管理员和作者进行文章管理。
	
	### 2. 技术选型
	#### 后端：
	选择 **Django + Django REST framework**，因为Django提供了丰富的内置功能，便于快速开发。
	
	#### 前端：
	使用 **Vue 3 + ElementPlus**，因为 Vue 3 提供了更好的性能和更简单的语法，ElementPlus 提供了丰富的UI组件。
	
	#### 数据库：
	使用 **SQLite** 在开发阶段，**PostgreSQL** 在生产环境中。
	
	#### 部署平台：
	考虑使用 **Heroku** 或 **AWS** 部署。也可以使用 **Docker** 进行容器化管理。
	
	### 3. 项目初始化
	#### 后端：
	1. 创建一个Django项目和应用程序。
	2. 安装并配置 **Django REST Framework** 以提供API接口。
	3. 配置跨域请求（CORS）。
	
	#### 前端：
	1. 创建一个Vue 3项目。
	2. 安装并配置 **ElementPlus** 以提供UI组件。
	3. 配置与后端API的对接。
	
	### 下一步
	为了确保我们在正确的轨道上，我们可以先进行项目初始化：
	
	#### 后端项目初始化：
	1. 安装Django和Django REST framework。
	2. 创建Django项目和应用。
	
	#### 前端项目初始化：
	1. 使用 Vue CLI 创建 Vue 3 项目。
	2. 安装 ElementPlus。
	
	我们现在可以选择从后端还是前端开始，或者同时进行。你更倾向于先开始哪个部分？或者你有其他的优先级建议？
	
	--------------------------------------------------------------------------------
	cathy (to joe):
	
	这种详细的需求分析非常有帮助，非常感谢你的详细描述。考虑到前后端的配合，我觉得我们可以先从后端开始，因为前端需要依赖后端的API来获取数据。在完成后端项目的初始化和基本的API搭建后，我们再进行前端的开发。
	
	### 后端项目初始化
	
	#### 1. 安装Django和Django REST framework
	首先，我们需要安装Django和Django REST framework。你可以在你的开发环境中运行以下命令：
	
	```bash
	pip install django djangorestframework
	```
	
	#### 2. 创建Django项目和应用
	接下来，让我们创建一个新的Django项目以及应用：
	
	```bash
	django-admin startproject blog_project
	cd blog_project
	django-admin startapp blog
	```
	
	#### 3. 配置Django和Django REST framework
	
	我们需要在 `settings.py` 中配置 Django REST framework 和注册我们的新应用 `blog`：
	
	```python
	# blog_project/settings.py
	
	INSTALLED_APPS = [
	    ...
	    'rest_framework',
	    'blog',
	]
	
	# 配置 Django REST framework
	REST_FRAMEWORK = {
	    'DEFAULT_PERMISSION_CLASSES': (
	        'rest_framework.permissions.IsAuthenticatedOrReadOnly',
	    ),
	    'DEFAULT_AUTHENTICATION_CLASSES': (
	        'rest_framework.authentication.SessionAuthentication',
	        'rest_framework.authentication.BasicAuthentication',
	    ),
	}
	```
	
	#### 4. 配置跨域请求（CORS）
	
	为了允许前端访问我们的API，我们需要安装并配置 `django-cors-headers`：
	
	```bash
	pip install django-cors-headers
	```
	
	然后在 `settings.py` 中进行配置：
	
	```python
	# blog_project/settings.py
	
	INSTALLED_APPS = [
	    ...
	    'corsheaders',
	]
	
	MIDDLEWARE = [
	    ...
	    'corsheaders.middleware.CorsMiddleware',
	]
	
	# 允许所有域名进行跨域请求
	CORS_ALLOW_ALL_ORIGINS = True
	```
	
	#### 5. 创建基础的模型
	
	我们先简单设计一下我们的模型，后续我们可以逐渐完善：
	
	```python
	# blog/models.py
	
	from django.db import models
	from django.contrib.auth.models import User
	
	class Category(models.Model):
	    name = models.CharField(max_length=100)
	
	    def __str__(self):
	        return self.name
	
	class Tag(models.Model):
	    name = models.CharField(max_length=100)
	
	    def __str__(self):
	        return self.name
	
	class Article(models.Model):
	    title = models.CharField(max_length=200)
	    content = models.TextField()
	    author = models.ForeignKey(User, on_delete=models.CASCADE)
	    created_at = models.DateTimeField(auto_now_add=True)
	    updated_at = models.DateTimeField(auto_now=True)
	    category = models.ForeignKey(Category, on_delete=models.CASCADE)
	    tags = models.ManyToManyField(Tag)
	
	    def __str__(self):
	        return self.title
	```
	
	#### 6. 迁移和创建数据库
	
	接下来我们进行数据库迁移并创建数据库：
	
	```bash
	python manage.py makemigrations
	python manage.py migrate
	```
	
	#### 7. 创建超级用户
	
	为了方便管理后台内容，我们需要创建一个超级用户：
	
	```bash
	python manage.py createsuperuser
	```
	
	#### 8. 启动开发服务器
	
	最后，我们启动开发服务器以确保一切配置正确：
	
	```bash
	python manage.py runserver
	```
	
	现在，你应该可以访问 `http://localhost:8000/admin` 和 `http://localhost:8000` 来查看Django后台和默认的主页。
	
	你可以在这个阶段进行小测试，确保Django项目已经搭建成功且能够正常运行。接下来，我们可以继续完善后端的API，或者开始前端项目的初始化。你觉得如何？

我一开始把 max_turns 设置为8，这两个Agent几乎把整个网站都开发完了，但是结果实在太长，没办法贴出来，我就把max_turns调整为2，从结果来看，还是很不错的。

一些想法

以前使用大模型的时候，感觉最大的就是，大模型缺少跟物理世界交互（主要是指从物理世界获取信息）的能力，这在很大程度上限制了大模型的应用，AutoGen中的code executer和tool的概念，在一定程度为大模型补足了这个能力，大模型的应用场景会更多。

从我的工作视角来看，如果创建一个tool，允许大模型通过SSH远程链接到服务器上执行命令，并把应用的配置和运行环境信息告诉大模型，AutoGen就可以在发生故障马上进行排查甚至修复。

再比如，当我需要开发一个小型应用的时候，可以通过AutoGen的Multi Agent来先在短时间内做出一个基础班，然后基于此优化，可以极大提升工作效率。

不得不感叹，大模型几乎要改变世界了啊。