10个标记为"AutoGen"的帖子

致所有的合作者和社区成员，

有许多请求澄清并区分各种AutoGen分支和克隆与当前的pyautogen包。以下是一些重要信息：

AutoGen项目的官方GitHub仓库仍然是github.com/microsoft/autogen。我们正在积极开发和维护AutoGen 0.2，并且最近在AutoGen 0.4（AutoGen-Core，Autogen-AgentChat）中引入了新的创新，以及作为项目路线图一部分的AutoGen-Studio和Magentic-One。开发将在MIT许可证下继续在开源中进行。我们感谢所有过去的贡献者，并欢迎任何人使用或为项目做出贡献。

我们目前正在重组我们的Python包，详情请参见这里。不幸的是，管理员目前无法访问pyautogen。请注意，当前版本的pyautogen与microsoft/autogen项目无关。

我们无法在原AutoGen Discord服务器上进行交流，因为我们的许多成员不再具有查看或发布权限。如有疑问和讨论，请通过GitHub Discussions、电子邮件autogen@microsoft.com、我们的新Discord或在周三太平洋时间上午10点/东部时间下午1点/中部欧洲时间下午7点加入我们的社区办公时间—Teams meeting link与我们联系。

自从创建以来，AutoGen 一直是一个高度协作的项目，从一开始参与 AutoGen 的大部分团队至今仍然深度参与。虽然我们想澄清微软没有任何人参与该项目的任何分支或克隆，但我们也认识到这些变体反映了社区中多样化的兴趣和不断演进的商业努力。我们的团队继续致力于与帮助塑造这个项目的优秀社区合作。

感谢您的持续支持，请继续关注即将发布的新版本。

有用的链接​

• 官方 GitHub 仓库
• Discord
• 文档
• Python packages by Microsoft

一年前，我们推出了AutoGen，一个旨在构建代理型AI系统的编程框架。AutoGen的发布在开发者社区引起了巨大的兴趣。作为早期发布版本，它为我们提供了一个难得的机会，可以深入与用户互动，收集宝贵的反馈，并从各种用例和贡献中学习。通过倾听和与社区的互动，我们了解到人们正在构建或试图构建什么，他们如何接近代理型系统的创建，以及他们在哪些地方遇到困难。这段经历既令人谦卑又富有启发，揭示了我们在初始设计中的重大改进机会，特别是对于使用AutoGen开发生产级应用程序的高级用户。

通过与社区的互动，我们学到了许多经验教训：

• 开发者们重视模块化和可重用的代理。例如，我们内置的代理可以直接插入或轻松定制以适应特定用例，这一点尤其受欢迎。同时，开发者们也希望有更多的可定制性，例如集成使用其他编程语言或框架构建的自定义代理。
• 基于聊天的代理到代理通信是一种直观的协作模式，使开发人员可以轻松上手并让人类参与其中。随着开发人员在更广泛的场景中使用代理，他们寻求在协作模式中更多的灵活性。例如，开发人员希望与代理构建可预测的、有序的工作流，并将它们与非基于聊天的新用户界面集成。
• 虽然开发者很容易开始使用 AutoGen，但调试和扩展代理团队应用程序却更具挑战性。
• 有许多机会可以提高代码质量。

这些经验教训，以及来自微软其他代理工作的许多其他经验，促使我们退一步，为新方向奠定基础。几个月前，我们开始投入时间，将这些经验提炼成AutoGen未来的路线图。这导致了AutoGen 0.4的开发，这是一个从基础开始的框架的全面重新设计。AutoGen 0.4采用计算参与者模型，以支持分布式、高度可扩展、事件驱动的代理系统。这种方法提供了许多优势，例如：

• 可组合性。以这种方式设计的系统更具可组合性，允许开发者引入他们自己在不同框架或编程语言中实现的代理，并利用复杂的代理模式构建更强大的系统。
• 灵活性. 它允许创建确定性的、有序的工作流程以及事件驱动或去中心化的工作流程，使客户能够更容易地引入自己的编排或与其他系统集成。它还为人在环场景（无论是主动还是被动）提供了更多机会。
• 调试和可观测性。事件驱动的通信将消息传递从代理转移到集中化组件，使得无论代理实现如何，都能更容易地观察和调试它们的行为。
• 可扩展性. 基于事件的架构使得分布式和云部署的代理成为可能，这对于构建可扩展的AI服务和应用程序至关重要。

今天，我们很高兴与大家分享我们的进展，并邀请所有人一起合作，提供反馈以改进AutoGen，并帮助塑造多代理系统的未来。

作为第一步，我们正在向主分支提交一个pull request，包含0.4版本的当前开发状态。大约一周后，我们计划将其合并到主分支并继续开发。尽管在0.4版本准备好发布之前还有很多工作要做，但请记住这仍然是一个进行中的工作。

从 AutoGen 0.4 开始，该项目将有三个主要库：

• 核心 - 一个事件驱动代理系统的基础构建模块。
• AgentChat - 一个任务驱动的高级API，基于核心构建，包括群组聊天、代码执行、预构建代理等。这是与AutoGen 0.2最相似的API，也将是最容易迁移的API。
• 扩展 - 核心接口的实现和第三方集成（例如，Azure代码执行器和OpenAI模型客户端）。

AutoGen 0.2 仍然可用，它在 0.2 分支 中进行开发和维护。对于寻找稳定版本的用户，我们建议暂时继续使用 0.2。它可以通过以下方式安装：

pip install autogen-agentchat~=0.2

使用这个新的包名称是为了与即将发布的0.4版本中的新包保持一致：autogen-core, autogen-agentchat, 和 autogen-ext。

最后，我们将使用GitHub Discussion作为新版本的官方社区论坛，并且今后所有与AutoGen项目相关的讨论也将在此进行。我们期待在那里与您见面。

TL;DR​

• AutoGen® 提供了通过 AgentOps 的详细多代理可观察性。
• AgentOps 为开发者提供了在仅两行代码中使用 AutoGen 的最佳体验。
• 企业现在可以在生产环境中信任AutoGen，同时通过AgentOps进行详细的监控和日志记录。

AutoGen 很高兴地宣布与 AgentOps 进行整合，AgentOps 是代理可观测性和合规性领域的行业领导者。早在二月份，彭博社就宣布 2024 年是 AI 代理年。确实如此！我们已经看到 AI 从简单的聊天机器人转变为代表用户自主决策和完成任务。

然而，与大多数新技术一样，公司和工程团队在制定流程和最佳实践时可能会进展缓慢。我们坚信代理工作流程中非常重要的一部分是可观测性。让你的代理随意运行可能在业余项目中可行，但如果你在为生产环境构建企业级代理，了解你的代理在哪些方面成功和失败是至关重要的。可观测性不仅仅是一个选项；它是必需的。

随着代理演变成更加强大和复杂的工具，你应该越来越多地将其视为设计来增强团队能力的工具。代理将承担更突出的角色和责任，采取行动，并提供巨大的价值。然而，这意味着你必须像好的管理者监控他们的员工一样监控你的代理。AgentOps为开发者提供了可观察性，用于调试和检测故障。它提供了工具，可以在一个易于阅读的仪表板上监控所有代理使用的关键指标。监控不仅仅是“有总是好的”；它是任何希望构建和扩展AI代理的团队的关键组成部分。

什么是Agent Observability？​

代理的可观测性，在其最基本的形式中，允许您监视、排查和明确代理在操作期间的行为。能够观察到代理活动的每一个细节，直至时间戳，使您能够精确追踪其行为，识别改进的领域，并了解任何失败背后的原因——这是有效调试的关键方面。除了提高诊断精度之外，这种级别的可观测性对于系统的可靠性至关重要。将其视为在问题失控之前识别和解决问题的能力。可观测性不仅仅是保持系统平稳运行和最大化正常运行时间；它还关乎加强基于代理的解决方案。

为什么选择AgentOps？​

AutoGen 已经简化了构建代理的过程，但我们意识到需要一个易于使用的原生工具来进行可观测性。我们之前讨论过 AgentOps，现在我们很高兴与 AgentOps 合作，作为我们官方的代理可观测性工具。将 AgentOps 与 AutoGen 集成简化了您的工作流程，并通过清晰的可观测性提高了您代理的性能，确保它们能够以最佳状态运行。更多详细信息，请查看我们的 AgentOps 文档。

企业和爱好者信任AutoGen作为构建代理的领导者。通过与AgentOps的合作，开发人员现在可以本地调试代理以提高效率并确保合规性，为您的所有代理活动提供全面的审计跟踪。AgentOps允许您从一个仪表板监控LLM调用、成本、延迟、代理故障、多代理交互、工具使用、会话范围内的统计信息等。

通过将AutoGen的代理构建能力与AgentOps的可观测性工具相结合，我们为用户提供了一个全面的解决方案，以增强代理的性能和可靠性。这种合作确保了企业可以自信地在生产环境中部署AI代理，因为他们拥有最好的工具来监控、调试和优化他们的代理。

最棒的部分是只需要两行代码。您需要做的就是在您的环境中设置一个AGENTOPS_API_KEY（在此获取API密钥：https://app.agentops.ai/account）并调用agentops.init()：

import os
import agentops

agentops.init(os.environ["AGENTOPS_API_KEY"])

AgentOps的功能​

AgentOps包含了你需要的所有功能，以确保你的代理适用于现实世界中的可扩展解决方案。

• 分析仪表板: AgentOps 分析仪表板允许您配置和分配代理，并自动跟踪每个代理同时采取的操作。当与 AutoGen 一起使用时，AgentOps 会自动配置为多代理兼容性，使用户能够轻松跟踪多个代理的运行情况。与终端级别的屏幕不同，AgentOps 通过其直观的界面提供了卓越的用户体验。
• 跟踪LLM成本：成本跟踪在AgentOps中原生设置并提供累计总数。这使开发人员能够查看和跟踪他们的运行成本，并准确预测未来的成本。
• 递归思维检测： 代理程序最令人沮丧的方面之一是它们陷入循环并连续几个小时重复执行同一任务。AgentOps 可以识别代理程序何时陷入无限循环，确保效率并防止浪费计算。

AutoGen 用户还可以使用 AgentOps 中的以下功能：

• 回放分析：观看逐步执行的代理执行图。
• 自定义报告：关于代理绩效的自定义分析。
• 公共模型测试： 在基准测试和排行榜上测试你的代理。
• 自定义测试： 针对特定领域的测试运行你的代理。
• 合规与安全： 创建审计日志并检测潜在威胁，例如侮辱性语言和个人身份信息泄露。
• 提示注入检测： 识别潜在的代码注入和秘密泄露。

结论​

通过将AgentOps集成到AutoGen中，我们为用户提供了一切所需，以创建生产级代理、改进它们，并跟踪它们的性能，确保它们完全按照您的需求运行。没有它，您将盲目操作，无法了解代理的成功或失败之处。AgentOps提供了监控、调试和优化代理以实现企业级性能所需的可观察性工具。它为开发人员提供了扩展AI解决方案所需的一切，从成本跟踪到递归思想检测。

你觉得这篇笔记有帮助吗？你愿意分享你的想法、使用案例和发现吗？请加入我们在AutoGen Discord中的可观测性频道。

有限状态机（FSM）群聊允许用户约束代理的转换。

TL;DR​

最近，FSM群聊功能发布，允许用户输入一个转换图来约束代理的转换。随着代理数量的增加，这非常有用，因为转换对的数量（N选2的组合）呈指数增长，增加了次优转换的风险，从而导致令牌的浪费和/或不良结果。

过渡图可能的使用场景​

1. 一次性工作流程，即我们希望每个代理只在问题上进行一次传递，代理 A -> B -> C。
2. 决策树流程，就像一个决策树，我们从根节点（代理）开始，沿着决策树向下流动，代理作为节点。例如，如果查询是SQL查询，交给SQL代理，否则如果查询是RAG查询，交给RAG代理。
3. 顺序团队操作。假设我们有一个由3个开发者代理组成的团队，每个代理负责一个不同的GitHub仓库。我们还有一个业务分析师团队，他们讨论并辩论用户的总体目标。我们可以让开发者团队的管理代理与业务分析团队的管理代理进行交流。这样，讨论会更加集中在团队层面，可以预期产生更好的结果。

请注意，我们并没有强制要求使用有向无环图；用户可以指定图为无环的，但是循环的工作流程也可能对迭代解决问题和在解决方案上添加额外的分析层非常有用。

使用指南​

我们添加了两个参数allowed_or_disallowed_speaker_transitions和speaker_transitions_type。

• allowed_or_disallowed_speaker_transitions：是一个字典，类型期望为{Agent: [Agent]}。键指的是源代理，而列表中的值指的是目标代理。如果未指定，则假定为完全连接图。
• speaker_transitions_type: 是一个字符串类型的参数，具体取值为["allowed", "disallowed"]。我们希望用户能够提供一个允许或禁止的转换字典，以提高易用性。在代码库中，我们会将禁止的转换反转为一个允许的转换字典allowed_speaker_transitions_dict。

有限状态机（FSM）特性的应用​

一个快速演示，展示了如何在AutoGen框架中启动基于有限状态机的GroupChat。在这个演示中，如果我们将每个代理视为一个状态，并且每个代理根据某些条件发言。例如，User总是首先启动任务，紧接着Planner创建计划。然后Engineer和Executor交替工作，当必要时Critic介入，并且在Critic之后，只有Planner应该修订额外的计划。每个状态只能在一段时间内存在，并且状态之间存在转换条件。因此，GroupChat可以很好地抽象为有限状态机（FSM）。

用法​

0. 先决条件

pip install autogen[graph]

1. 导入依赖项

   from autogen.agentchat import GroupChat, AssistantAgent, UserProxyAgent, GroupChatManager
   from autogen.oai.openai_utils import config_list_from_dotenv
   

2. Configure LLM parameters

   # Please feel free to change it as you wish
   config_list = config_list_from_dotenv(
           dotenv_file_path='.env',
           model_api_key_map={'gpt-4-1106-preview':'OPENAI_API_KEY'},
           filter_dict={
               "model": {
                   "gpt-4-1106-preview"
               }
           }
       )
   
   gpt_config = {
       "cache_seed": None,
       "temperature": 0,
       "config_list": config_list,
       "timeout": 100,
   }
   

3. 定义任务

   # 描述任务
   task = """Add 1 to the number output by the previous role. If the previous number is 20, output "TERMINATE"."""
   

4. 定义代理

   # agents configuration
   engineer = AssistantAgent(
       name="Engineer",
       llm_config=gpt_config,
       system_message=task,
       description="""I am **ONLY** allowed to speak **immediately** after `Planner`, `Critic` and `Executor`.
   If the last number mentioned by `Critic` is not a multiple of 5, the next speaker must be `Engineer`.
   """
   )
   
   planner = AssistantAgent(
       name="Planner",
       system_message=task,
       llm_config=gpt_config,
       description="""I am **ONLY** allowed to speak **immediately** after `User` or `Critic`.
   If the last number mentioned by `Critic` is a multiple of 5, the next speaker must be `Planner`.
   """
   )
   
   executor = AssistantAgent(
       name="Executor",
       system_message=task,
       is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").rstrip().endswith("FINISH"),
       llm_config=gpt_config,
       description="""I am **ONLY** allowed to speak **immediately** after `Engineer`.
   If the last number mentioned by `Engineer` is a multiple of 3, the next speaker can only be `Executor`.
   """
   )
   
   critic = AssistantAgent(
       name="Critic",
       system_message=task,
       llm_config=gpt_config,
       description="""I am **ONLY** allowed to speak **immediately** after `Engineer`.
   If the last number mentioned by `Engineer` is not a multiple of 3, the next speaker can only be `Critic`.
   """
   )
   
   user_proxy = UserProxyAgent(
       name="User",
       system_message=task,
       code_execution_config=False,
       human_input_mode="NEVER",
       llm_config=False,
       description="""
   Never select me as a speaker.
   """
   )
   
   1. 在这里，我将system_messages配置为"task"，因为每个代理都应该知道它需要做什么。在这个例子中，每个代理都有相同的任务，即按顺序计数。
   2. 最重要的一点是description参数，在这里我使用自然语言描述了FSM的转换条件。因为管理者根据图的约束知道接下来哪些代理是可用的，所以在每个候选代理的description字段中，我描述了它何时可以说话，从而有效地描述了FSM中的转换条件。

5. 定义图表

   graph_dict = {}
   graph_dict[user_proxy] = [planner]
   graph_dict[planner] = [engineer]
   graph_dict[engineer] = [critic, executor]
   graph_dict[critic] = [engineer, planner]
   graph_dict[executor] = [engineer]
   
   1. 这里的图和上面提到的转换条件共同构成了一个完整的FSM。两者都是必不可少的，不能缺失。
   2. 您可以根据自己的意愿进行可视化，如下所示

   

6. Define a GroupChat and a GroupChatManager

   agents = [user_proxy, engineer, planner, executor, critic]
   
   # create the groupchat
   group_chat = GroupChat(agents=agents, messages=[], max_round=25, allowed_or_disallowed_speaker_transitions=graph_dict, allow_repeat_speaker=None, speaker_transitions_type="allowed")
   
   # create the manager
   manager = GroupChatManager(
       groupchat=group_chat,
       llm_config=gpt_config,
       is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE"),
       code_execution_config=False,
   )
   

7. 启动聊天

   # 启动任务
   user_proxy.initiate_chat(
       manager,
       message="1",
       clear_history=True
   )
   

8. You may get the following output(I deleted the ignorable warning):

   User (to chat_manager):
   
   1
   
   --------------------------------------------------------------------------------
   Planner (to chat_manager):
   
   2
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   3
   
   --------------------------------------------------------------------------------
   Executor (to chat_manager):
   
   4
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   5
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   6
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   7
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   8
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   9
   
   --------------------------------------------------------------------------------
   Executor (to chat_manager):
   
   10
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   11
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   12
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   13
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   14
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   15
   
   --------------------------------------------------------------------------------
   Executor (to chat_manager):
   
   16
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   17
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   18
   
   --------------------------------------------------------------------------------
   Engineer (to chat_manager):
   
   19
   
   --------------------------------------------------------------------------------
   Critic (to chat_manager):
   
   20
   
   --------------------------------------------------------------------------------
   Planner (to chat_manager):
   
   TERMINATE
   

笔记本示例​

更多的例子可以在notebook中找到。该笔记本包含了更多可能的转换路径示例，例如（1）中心辐射型，（2）顺序团队操作，以及（3）大声思考和辩论。它还使用了autogen.graph_utils中的函数visualize_speaker_transitions_dict来可视化各种图形。

Anny 是一个由 AutoGen 驱动的 Discord 机器人，用于帮助 AutoGen 的 Discord 服务器。

TL;DR​

我们正在添加一个名为Anny的新示例应用程序——一个由AutoGen驱动的简单Discord机器人，旨在帮助AutoGen开发者。详情请参见samples/apps/auto-anny。

介绍​

在过去几个月里，AutoGen在用户数量以及社区请求和反馈方面都经历了巨大的增长。 然而，满足这些需求和反馈需要手动筛选GitHub上的问题、PR和讨论，以及管理来自Discord上AutoGen 14000+社区成员的消息。 AutoGen的开发者社区每天需要执行许多任务，以下是一些常见的任务：

• 回答问题
• 识别并优先处理错误和功能
• 为我们令人惊叹的社区保持响应性
• 跟踪增长

这需要大量的努力。Agentic-workflows和接口承诺为许多任务添加巨大的增值自动化，所以我们想为什么不用AutoGen让我们的生活更轻松呢？！ 因此，我们转向自动化来帮助我们，并让我们专注于最关键的事情。

Anny的当前版本​

当前版本的Anny非常简单——它使用Discord API和AutoGen来实现一个能够响应一组命令的机器人。

例如，它支持像 /heyanny help 这样的命令来列出命令，/heyanny ghstatus 用于 GitHub 活动摘要，/heyanny ghgrowth 用于 GitHub 仓库增长指标，以及 /heyanny ghunattended 用于列出未处理的问题和 PR。大多数这些命令使用多个 AutoGen 代理来完成这些任务。

要使用 Anny，请按照 samples/apps/auto-anny 中的说明操作。

它不仅适用于AutoGen​

如果你是一个管理自己项目的开源开发者，你可能能够理解我们所面临的挑战。我们邀请你查看Anny并为其开发和路线图做出贡献。

TL;DR​

AutoGen 现在支持自定义模型！此功能使用户能够定义和加载自己的模型，从而实现更灵活和个性化的推理机制。通过遵循特定协议，您可以集成自定义模型以与 AutoGen 一起使用，并通过使用您想要的任何模型/API 调用/硬编码响应来响应提示。

注意：根据您使用的模型，您可能需要调整Agent的默认提示

快速入门​

一个交互且简单的方式是通过跟随这里的笔记本来开始，该笔记本从HuggingFace加载一个本地模型到AutoGen中并使用它进行推理，并对提供的类进行更改。

第一步：创建自定义模型客户端类​

要开始在AutoGen中使用自定义模型，你需要创建一个遵循client.py中定义的ModelClient协议的模型客户端类。新的模型客户端类应实现这些方法：

• create(): 返回一个实现了ModelClientResponseProtocol的响应对象（更多详情请参阅协议部分）。
• message_retrieval(): 处理响应对象并返回一个字符串列表或消息对象列表（更多详细信息请参见协议部分）。
• cost(): 返回响应的成本。
• get_usage(): 返回一个字典，其键为RESPONSE_USAGE_KEYS = ["prompt_tokens", "completion_tokens", "total_tokens", "cost", "model"]。

例如，一个简单的虚拟自定义类：

class CustomModelClient:
    def __init__(self, config, **kwargs):
        print(f"CustomModelClient config: {config}")

    def create(self, params):
        num_of_responses = params.get("n", 1)

        # can create my own data response class
        # here using SimpleNamespace for simplicity
        # as long as it adheres to the ModelClientResponseProtocol

        response = SimpleNamespace()
        response.choices = []
        response.model = "model_name" # should match the OAI_CONFIG_LIST registration

        for _ in range(num_of_responses):
            text = "this is a dummy text response"
            choice = SimpleNamespace()
            choice.message = SimpleNamespace()
            choice.message.content = text
            choice.message.function_call = None
            response.choices.append(choice)
        return response

    def message_retrieval(self, response):
        choices = response.choices
        return [choice.message.content for choice in choices]

    def cost(self, response) -> float:
        response.cost = 0
        return 0

    @staticmethod
    def get_usage(response):
        return {}

步骤 2：将配置添加到 OAI_CONFIG_LIST​

必要的字段是将model_client_cls设置为新类的名称（作为字符串）"model_client_cls":"CustomModelClient"。其他所有字段将传递给类的构造函数，因此您可以完全控制指定哪些参数以及如何使用它们。例如：

{
    "model": "Open-Orca/Mistral-7B-OpenOrca",
    "model_client_cls": "CustomModelClient",
    "device": "cuda",
    "n": 1,
    "params": {
        "max_length": 1000,
    }
}

第三步：将新的自定义模型注册到将使用它的代理​

如果已将带有字段 "model_client_cls":"<class name>" 的配置添加到 Agent 的配置列表中，则必须在创建代理之后且在初始化对话之前注册具有所需类的相应模型：

my_agent.register_model_client(model_client_cls=CustomModelClient, [other args that will be forwarded to CustomModelClient constructor])

model_client_cls=CustomModelClient 参数与 OAI_CONFIG_LIST 中指定的参数匹配，CustomModelClient 是遵循 ModelClient 协议的类（有关该协议的更多详细信息如下）。

如果在初始化聊天时新模型客户端在配置列表中但未注册，则会引发错误。

协议详情​

一个自定义模型类可以通过多种方式创建，但需要遵循在client.py中定义并如下所示的ModelClient协议和响应结构。

当前的响应协议使用了autogen代码库中与OpenAI响应结构匹配的最小必需字段。任何与OpenAI响应结构匹配的响应协议可能更适应未来的变化，但我们从最小要求开始，以使该功能的采用更加容易。

class ModelClient(Protocol):
    """
    A client class must implement the following methods:
    - create must return a response object that implements the ModelClientResponseProtocol
    - cost must return the cost of the response
    - get_usage must return a dict with the following keys:
        - prompt_tokens
        - completion_tokens
        - total_tokens
        - cost
        - model

    This class is used to create a client that can be used by OpenAIWrapper.
    The response returned from create must adhere to the ModelClientResponseProtocol but can be extended however needed.
    The message_retrieval method must be implemented to return a list of str or a list of messages from the response.
    """

    RESPONSE_USAGE_KEYS = ["prompt_tokens", "completion_tokens", "total_tokens", "cost", "model"]

    class ModelClientResponseProtocol(Protocol):
        class Choice(Protocol):
            class Message(Protocol):
                content: Optional[str]

            message: Message

        choices: List[Choice]
        model: str

    def create(self, params) -> ModelClientResponseProtocol:
        ...

    def message_retrieval(
        self, response: ModelClientResponseProtocol
    ) -> Union[List[str], List[ModelClient.ModelClientResponseProtocol.Choice.Message]]:
        """
        Retrieve and return a list of strings or a list of Choice.Message from the response.

        NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,
        since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.
        """
        ...

    def cost(self, response: ModelClientResponseProtocol) -> float:
        ...

    @staticmethod
    def get_usage(response: ModelClientResponseProtocol) -> Dict:
        """Return usage summary of the response using RESPONSE_USAGE_KEYS."""
        ...

故障排除步骤​

如果某些功能无法正常工作，请按照检查清单进行操作：

• Make sure you have followed the client protocol and client response protocol when creating the custom model class
  • create() 方法：在 create 调用期间返回推理响应时，必须遵循 ModelClientResponseProtocol。
  • message_retrieval() 方法：返回一个字符串列表或消息对象列表。如果返回的是消息对象列表，它们目前必须包含 OpenAI 的 ChatCompletion Message 对象的字段，因为在当前代码库的其余部分中，除非使用自定义代理，否则这是函数或工具调用所期望的。
  • cost()方法：返回一个整数，如果你不关心成本跟踪，你可以直接返回0。
  • get_usage(): 返回一个字典，如果不关心使用情况跟踪，可以只返回一个空字典 {}。
• 确保在OAI_CONFIG_LIST中有相应的条目，并且该条目包含"model_client_cls":"<custom-model-class-name>"字段。
• 确保你已经使用相应的配置条目注册了客户端，以及你的新类 agent.register_model_client(model_client_cls=<class-of-custom-model>, [其他可选参数])
• 确保在OAI_CONFIG_LIST中定义的所有自定义模型都已注册。
• 任何其他故障排除可能需要在自定义代码本身中进行。

结论​

通过使用自定义模型的能力，AutoGen现在为您的AI应用程序提供了更大的灵活性和功能。无论您是训练了自己的模型还是希望使用特定的预训练模型，AutoGen都能满足您的需求。编程愉快！

AutoGenBench 是一个独立工具，用于在常见基准上评估 AutoGen 代理和工作流程。

TL;DR​

今天我们发布了AutoGenBench - 一个用于在已建立的大语言模型（LLM）和代理基准上评估AutoGen代理和工作流程的工具。

AutoGenBench 是一个独立的命令行工具，可以从 PyPI 安装，它负责下载、配置、运行和报告支持的基准测试。AutoGenBench 在与 Docker 一起运行时效果最佳，因为它使用 Docker 来隔离测试之间的相互影响。

• 查看AutoGenBench README以获取有关安装和运行基准测试的信息。
• 请参阅 AutoGenBench 贡献指南 获取有关开发或贡献基准数据集的信息。

快速开始​

通过在bash终端中运行以下命令快速开始。

注意：您可能需要根据实际情况调整OAI_CONFIG_LIST的路径。

export OAI_CONFIG_LIST=$(cat ./OAI_CONFIG_LIST)
pip install autogenbench
autogenbench clone HumanEval
cd HumanEval
cat README.md
autogenbench run --subsample 0.1 --repeat 3 Tasks/human_eval_two_agents.jsonl
autogenbench tabulate Results/human_eval_two_agents

介绍​

测量和评估是每个主要AI或ML研究项目的核心组成部分。对于AutoGen也是如此。为此，今天我们发布AutoGenBench，这是一个独立的命令行工具，我们一直用它来指导AutoGen的开发。方便的是，AutoGenBench处理：下载、配置、运行和报告各种公共基准数据集上的代理结果。除了报告主要数字外，每次AutoGenBench运行都会生成一套全面的日志和遥测数据，可用于调试、性能分析、计算自定义指标，并作为AgentEval的输入。在本博客文章的其余部分中，我们概述了AutoGenBench的核心设计原则（理解其操作的关键）；提供了安装和运行AutoGenBench的指南；概述了评估的路线图；并以一个公开的贡献呼吁作为结尾。

设计原则​

AutoGenBench围绕三个核心设计原则构建。了解这些原则将帮助您理解该工具、其操作及其输出。这三个原则是：

• 重复性： 大型语言模型（LLMs）具有随机性，在很多情况下，它们编写的代码也具有随机性。例如，一个Python脚本可能调用外部搜索引擎，每次运行的结果可能不同。这可能导致代理性能的差异。重复性是衡量和理解这种差异的关键。为此，AutoGenBench从设计之初就考虑到任务可能需要多次运行，而差异是我们经常希望测量的一个指标。

• 隔离性： 代理与它们的环境以微妙和明显的方式进行交互。例如，代理可能会安装一个Python库或将文件写入磁盘。这可能导致顺序效应，影响后续的测量结果。例如，考虑在同一个基准测试上比较两个代理。一个代理可能看起来比另一个更高效，仅仅是因为它是第二个运行的，并且受益于第一个代理在安装和调试必要的Python库时所做的艰苦工作。为了解决这个问题，AutoGenBench将每个任务隔离在其自己的Docker容器中。这确保了所有运行都从相同的初始条件开始。（一般来说，Docker也是运行代理生成代码的更安全的方式。）

• 监测： 尽管顶层指标非常适合比较代理或模型，但我们通常需要更多关于代理如何执行、它们在何处卡住以及如何改进的信息。我们随后也可能会想到需要计算不同指标集的新研究问题。为此，AutoGenBench 设计为记录所有内容，并从这些日志中计算指标。这确保人们始终可以返回日志以回答发生了什么的问题，运行分析软件，或将日志输入像 AgentEval 这样的工具。

安装和运行AutoGenBench​

如上所述，隔离是一个关键的设计原则，因此AutoGenBench必须在支持Docker的环境中运行（桌面版或Engine版）。它不会在GitHub codespaces中运行，除非您选择本地执行（强烈不推荐）。要安装Docker Desktop，请参见https://www.docker.com/products/docker-desktop/。 一旦安装了Docker，AutoGenBench就可以从PyPI中作为独立工具进行安装。使用pip，安装可以通过以下方式完成：

pip install autogenbench

安装完成后，您必须配置您的API密钥。与其他AutoGen应用程序一样，AutoGenBench将在当前工作目录中的OAI_CONFIG_LIST文件或OAI_CONFIG_LIST环境变量中查找OpenAI密钥。可以使用命令行参数覆盖此行为。

如果您将运行多个基准测试，通常最方便的方式是利用环境变量选项。您可以通过执行以下命令将密钥加载到环境变量中：

export OAI_CONFIG_LIST=$(cat ./OAI_CONFIG_LIST)

一个典型的会话​

一旦AutoGenBench和必要的密钥安装完成，典型的会话将如下所示：

autogenbench clone HumanEval
cd HumanEval
cat README.md
autogenbench run --subsample 0.1 --repeat 3 Tasks/human_eval_two_agents.jsonl
autogenbench tabulate results/human_eval_two_agents

其中：

• autogenbench clone HumanEval 下载并展开HumanEval基准测试场景。
• cd HumanEval; cat README.md 导航到基准测试目录，并打印README（你应该经常阅读它！）
• autogenbench run --subsample 0.1 --repeat 3 Tasks/human_eval_two_agents.jsonl 运行Tasks/human_eval_two_agents.jsonl中定义的任务的10%子样本。每个任务运行3次。
• autogenbench tabulate results/human_eval_two_agents 汇总运行的结果。

在运行上述tabulate命令后，您应该会看到类似于以下的输出：

                 Trial 0    Trial 1    Trial 2
Task Id          Success    Success    Success
-------------  ---------  ---------  ---------
HumanEval_107       False      True       True
HumanEval_22        True       True       True
HumanEval_43        True       True       True
HumanEval_88        True       True       True
HumanEval_14        True       True       True
HumanEval_157       True       True       True
HumanEval_141       True       True       True
HumanEval_57        True       True       True
HumanEval_154       True       True       True
HumanEval_153       True       True       True
HumanEval_93        False      True      False
HumanEval_137       True       True       True
HumanEval_143       True       True       True
HumanEval_13        True       True       True
HumanEval_49        True       True       True
HumanEval_95        True       True       True
-------------  ---------  ---------  ---------
Successes             14         16         15
Failures               2          0          1
Missing                0          0          0
Total                 16         16         16

CAUTION: 'autogenbench tabulate' is in early preview.
Please do not cite these values in academic work without first inspecting and verifying the results in the logs yourself.

从这个输出中，我们可以看到每个任务的三个单独重复的结果，以及每次运行的最终汇总统计信息。在这种情况下，结果是通过GPT-4生成的（根据提供的OAI_CONFIG_LIST定义），并使用了TwoAgents模板。重要的是要记住，AutoGenBench评估的是特定的端到端代理配置（而不是更广泛地评估模型或认知框架）。

最后，完整的执行跟踪和日志可以在Results文件夹中找到。有关命令行选项和输出格式的更多详细信息，请参阅AutoGenBench README。每个命令还通过以下方式提供了广泛的内联帮助：

• autogenbench --help
• autogenbench clone --help
• autogenbench run --help
• autogenbench tabulate --help

路线图​

在我们宣布AutoGenBench的同时，我们注意到它本身就是一个不断发展的项目。在接下来的几周和几个月里，我们希望：

• 在现有基础上，增加更多的基准测试
• 大幅改进日志记录和遥测
• 引入新的核心指标，包括总成本、任务完成时间、对话轮次等。
• 提供与 AgentEval 和 AutoGen Studio 的更紧密集成

要查看我们在此项目上的最新工作项，请参阅 AutoGenBench Work Items

参与邀请​

最后，我们想以开放呼吁贡献的方式结束这篇博客文章。AutoGenBench 还处于初期阶段，有很大的改进空间。新的基准测试不断发布，需要不断添加。每个人可能都有自己最关心的优化指标，这些指标应该被纳入。为此，我们欢迎对 AutoGen 项目的这个部分做出任何贡献。如果你对贡献感兴趣，请查看贡献者指南并加入我们在#autogenbench频道的Discord讨论！

TL;DR​

AutoGen 0.2.8 通过将“在Docker容器内执行代码”设为默认设置来增强操作安全性，重点在于向用户通报其操作，并使他们能够在代码执行方面做出明智的决策。

新版本引入了一个重大变化，即在执行代码的代理中，默认将use_docker参数设置为True。这一变化突显了我们在AutoGen中优先考虑安全性和可靠性的承诺。

介绍​

AutoGen 具有代码执行代理，通常定义为 UserProxyAgent，其中代码执行默认是开启的。到目前为止，除非用户明确指定，否则其他代理生成的任何代码将由代码执行代理在本地执行，即在 AutoGen 执行的地方。如果 AutoGen 恰好在 Docker 容器中运行，那么运行代码的风险会被最小化。然而，如果 AutoGen 在 Docker 之外运行，特别是对于新用户来说，很容易忽视代码执行的风险。

AutoGen 现在默认会将任何代码在 Docker 容器内执行（除非代码已经在 Docker 容器内执行）。它将启动一个 Docker 镜像（用户提供或默认的），执行新代码，然后终止镜像，为下一个代码执行周期做准备。

我们理解并非所有人都关心这一点，尤其是在初次尝试使用AutoGen时。我们提供了简单的方法来关闭这一要求。但我们相信，确保用户意识到代码将在本地执行，并提示他们思考在本地运行代码的安全影响，对于AutoGen来说是正确的步骤。

示例​

该示例显示了默认行为，即由助手代理生成并由user_proxy代理执行的任何代码，将尝试使用Docker容器来执行代码。如果Docker未运行，则会抛出错误。用户可以决定激活Docker或选择本地代码执行。

from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
user_proxy = UserProxyAgent("user_proxy", code_execution_config={"work_dir": "coding"})
user_proxy.initiate_chat(assistant, message="Plot a chart of NVDA and TESLA stock price change YTD.")

要退出此默认行为，有一些选项。

完全禁用代码执行​

• 将每个代码执行代理的code_execution_config设置为False。例如：

user_proxy = autogen.UserProxyAgent(name="user_proxy", llm_config=llm_config, code_execution_config=False)

在本地运行代码执行​

• 在code_execution_config中，可以为每个代码执行代理设置use_docker为False。
• 要为所有代码执行代理一次性设置：将AUTOGEN_USE_DOCKER设置为False作为环境变量。

例如：

user_proxy = autogen.UserProxyAgent(name="user_proxy", llm_config=llm_config,
    code_execution_config={"work_dir":"coding", "use_docker":False})

相关文档​

• 使用Docker进行代码执行
• 如何在docker中禁用代码执行

结论​

AutoGen 0.2.8 现在提高了代码执行的安全性，并确保用户能够清楚地了解 autogen 的操作，并能够围绕代码执行做出决策。

TL;DR​

AutoGen 0.2.2 在 ConversableAgent（及其所有子类）中引入了 description 字段，并修改了 GroupChat，使其在选择下一个发言的代理时使用代理的 description，而不是 system_message。

这有望简化GroupChat的工作，改善编排，并使实现新的GroupChat或类似GroupChat的替代方案更加容易。

如果你是开发者，且一切工作正常，无需采取任何行动——因为当未提供描述时，description字段默认使用system_message，确保了向后兼容性。

然而，如果您在使用GroupChat时遇到困难，现在可以尝试更新description字段。

介绍​

随着AutoGen的成熟和开发者构建越来越复杂的代理组合，编排成为一个重要的能力。目前，GroupChat和GroupChatManager是用于在三个或更多代理之间编排对话的主要内置工具。为了使像GroupChat这样的编排器能够很好地工作，它们需要了解每个代理的一些信息，以便决定谁应该在何时发言。在AutoGen 0.2.2之前，GroupChat依赖于每个代理的system_message和name来了解每个参与的代理。当系统提示简短而精炼时，这可能没有问题，但当指令非常长（例如，与AssistantAgent一起使用时）或不存在（例如，与UserProxyAgent一起使用时），可能会导致问题。

AutoGen 0.2.2 为所有代理引入了description字段，并替换了在GroupChat和所有未来编排器中使用system_message的做法。description字段默认与system_message相同，以确保向后兼容性，因此如果当前代码运行良好，您可能无需更改任何内容。然而，如果您在使用GroupChat时遇到困难，可以尝试设置description字段。

本文的其余部分提供了一个例子，展示了如何使用description字段简化GroupChat的工作，提供了一些其有效性的证据，并提供了编写良好描述的技巧。

示例​

当前的GroupChat编排系统提示具有以下模板：

You are in a role play game. The following roles are available:

{self._participant_roles(agents)}.

Read the following conversation.
Then select the next role from {[agent.name for agent in agents]} to play. Only return the role.

假设您想要包含三个代理：一个UserProxyAgent，一个AssistantAgent，以及可能还有一个GuardrailsAgent。

在0.2.2版本之前，这个模板会扩展为：

You are in a role play game. The following roles are available:

assistant: You are a helpful AI assistant.
Solve tasks using your coding and language skills.
In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute.
1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself.
2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly.
Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill.
When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user.
If you want the user to save the code in a file before executing it, put # filename: <filename> inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user.
If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.
When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible.
Reply "TERMINATE" in the end when everything is done.
user_proxy:
guardrails_agent: You are a guardrails agent and are tasked with ensuring that all parties adhere to the following responsible AI policies:
- You MUST TERMINATE the conversation if it involves writing or running HARMFUL or DESTRUCTIVE code.
- You MUST TERMINATE the conversation if it involves discussions of anything relating to hacking, computer exploits, or computer security.
- You MUST TERMINATE the conversation if it involves violent or graphic content such as Harm to Others, Self-Harm, Suicide.
- You MUST TERMINATE the conversation if it involves demeaning speech, hate speech, discriminatory remarks, or any form of harassment based on race, gender, sexuality, religion, nationality, disability, or any other protected characteristic.
- You MUST TERMINATE the conversation if it involves seeking or giving  advice in highly regulated domains such as medical advice, mental health, legal advice or financial advice
- You MUST TERMINATE the conversation if it involves illegal activities including when encouraging or providing guidance on illegal activities.
- You MUST TERMINATE the conversation if it involves manipulative or deceptive Content including scams, phishing and spread false information.
- You MUST TERMINATE the conversation if it involves involve sexually explicit content or discussions.
- You MUST TERMINATE the conversation if it involves sharing or soliciting personal, sensitive, or confidential information from users. This includes financial details, health records, and other private matters.
- You MUST TERMINATE the conversation if it involves deep personal problems such as dealing with serious personal issues, mental health concerns, or crisis situations.
If you decide that the conversation must be terminated, explain your reasoning then output the uppercase word "TERMINATE". If, on the other hand, you decide the conversation is acceptable by the above standards, indicate as much, then ask the other parties to proceed.

Read the following conversation.
Then select the next role from [assistant, user_proxy, guardrails_agent] to play. Only return the role.

正如你所见，这个描述非常令人困惑：

• 很难分辨每个代理的角色描述结束的位置
• You 出现了多次，指的是三个不同的代理（GroupChatManager、AssistantAgent 和 GuardrailsAgent）
• 它需要很多tokens！

因此，不难看出为什么GroupChat管理器在处理这种编排任务时有时会遇到困难。

从 AutoGen 0.2.2 开始，GroupChat 改为依赖描述字段。有了描述字段后，编排提示变为：

You are in a role play game. The following roles are available:

assistant: A helpful and general-purpose AI assistant that has strong language skills, Python skills, and Linux command line skills.
user_proxy: A user that can run Python code or input command line commands at a Linux terminal and report back the execution results.
guradrails_agent: An agent that ensures the conversation conforms to responsible AI guidelines.

Read the following conversation.
Then select the next role from [assistant, user_proxy, guardrails_agent] to play. Only return the role.

这样更容易解析和理解，而且几乎不消耗太多标记。此外，以下实验提供了初步证据，表明它是有效的。

分心实验​

为了说明description字段的影响，我们使用HumanEval基准测试的一个26问题子集设置了一个三代理实验。在这里，三个代理被添加到一个GroupChat中以解决编程问题。这三个代理分别是：

• 程序员（默认助手提示）
• UserProxy（配置为执行代码）
• ExecutiveChef（作为干扰项添加）

Coder 和 UserProxy 使用了 AssistantAgent 和 UserProxy 的默认设置（如上所述），而 ExecutiveChef 则被赋予系统提示：

You are an executive chef with 28 years of industry experience. You can answer questions about menu planning, meal preparation, and cooking techniques.

在这个情境中，ExecutiveChef显然是一个干扰因素——鉴于HumanEval问题无一与食物相关，GroupChat应该很少会咨询厨师。然而，当配置使用GPT-3.5-turbo-16k时，我们可以清楚地看到GroupChat在协调方面遇到困难：

在0.2.2版本之前，使用system_message:​

• 代理们在第一回合解决了26个问题中的3个
• ExecutiveChef 被调用了54次！（几乎和Coder的68次一样多）

在版本0.2.2中，使用description:​

• 代理在第一轮解决了26个问题中的7个
• ExecutiveChef 被调用了27次！（而Coder被调用了84次）

使用 description 字段可以使此任务的性能翻倍，并减少调用干扰代理的次数。

撰写优秀描述的技巧​

由于descriptions的用途与system_message不同，因此值得回顾一下什么是一个好的代理描述。尽管描述是新的，但以下技巧似乎能带来好的效果：

• 避免使用第一或第二人称视角。描述中不应包含“我”或“你”，除非“你”指的是GroupChat / orchestrator
• 包含任何可能帮助协调者知道何时调用代理的详细信息
• 保持描述简洁（例如，“一个具有强大自然语言和Python编程技能的AI助手。”）。

主要要记住的是描述是为了GroupChatManager的利益，而不是为了Agent自己的使用或指导。

结论​

AutoGen 0.2.2 引入了一个 description，成为代理向像 GroupChat 这样的协调器描述自己的主要方式。由于 description 默认与 system_message 相同，如果您已经对群聊的工作方式感到满意，那么您无需进行任何更改。然而，我们预计此功能将普遍改善协调效果，因此如果您在使用 GroupChat 时遇到困难或希望提高性能，请考虑尝试使用 description 字段。

AutoGen Studio: 使用多个代理解决任务，生成带有图像的PDF文档。

TL;DR​

为了帮助你快速为任务构建多智能体解决方案的原型，我们引入了由 AutoGen 驱动的 AutoGen Studio 界面。它允许你：

• 通过点击和拖放的界面，声明式地定义和修改代理和多代理工作流程（例如，你可以选择两个将进行通信以解决你任务的代理的参数）。
• 使用我们的UI与指定代理创建聊天会话并查看结果（例如，查看聊天记录、生成的文件和所用时间）。
• 明确地为您的代理添加技能，并完成更多任务。
• 将您的会话发布到本地画廊。

详情请参阅官方AutoGen Studio文档 这里。

AutoGen Studio 是开源的 代码在这里，可以通过 pip 安装。试试看吧！

pip install autogenstudio

介绍​

技术的加速发展引领我们进入了一个数字助手（或代理）逐渐成为我们生活中不可或缺部分的时代。AutoGen作为一个编排代理能力的领先框架已经崭露头角。本着扩展这一前沿并普及这一能力的精神，我们非常兴奋地推出一个新的用户友好界面：AutoGen Studio。

使用AutoGen Studio，用户可以快速创建、管理和与能够学习、适应和协作的代理进行交互。当我们向开源社区发布此界面时，我们的目标不仅是提高生产力，还要激发人类与代理之间的个性化互动水平。

注意: AutoGen Studio旨在帮助您快速原型化多代理工作流，并展示使用AutoGen构建的终端用户界面示例。它并不打算成为一个生产就绪的应用程序。

开始使用 AutoGen Studio​

以下指南将帮助您在您的系统上启动并运行AutoGen Studio。

配置LLM供应商​

要开始使用，你需要访问一个语言模型。你可以按照AutoGen文档此处的步骤进行设置。使用OPENAI_API_KEY或AZURE_OPENAI_API_KEY配置你的环境。

例如，在终端中，你可以像这样设置API密钥：

export OPENAI_API_KEY=<your_api_key>

你也可以直接在代理的配置中指定模型，如下所示。

llm_config = LLMConfig(
    config_list=[{
        "model": "gpt-4",
        "api_key": "<azure_api_key>",
        "base_url": "<azure api base url>",
        "api_type": "azure",
        "api_version": "2024-02-01"
    }],
    temperature=0,
)

安装​

有两种安装AutoGen Studio的方式——通过PyPi或从源代码安装。除非你计划修改源代码，否则我们推荐通过PyPi安装。

1. 从PyPi安装

   我们建议使用虚拟环境（例如conda）以避免与现有的Python包冲突。在您的虚拟环境中激活Python 3.10或更新版本后，使用pip安装AutoGen Studio：

   pip install autogenstudio
   

2. 从源代码安装

   注意：此方法需要对在React中构建界面有一定的了解。

   如果您更喜欢从源代码安装，请确保您已安装Python 3.10+和Node.js（版本高于14.15.0）。以下是您开始的方法：

   • 克隆 AutoGen Studio 仓库并安装其 Python 依赖：

     pip install -e .
     

   • 导航到samples/apps/autogen-studio/frontend目录，安装依赖并构建用户界面：

     npm install -g gatsby-cli
     npm install --global yarn
     yarn install
     yarn build
     

   对于Windows用户，要构建前端，您可能需要autogen studio readme中提供的替代命令。

运行应用程序​

安装完成后，通过终端输入以下命令来运行web UI：

autogenstudio ui --port 8081

这将在指定的端口上启动应用程序。打开您的网页浏览器并访问http://localhost:8081/以开始使用AutoGen Studio。

现在你已经安装并运行了AutoGen Studio，你可以开始探索它的功能，包括定义和修改代理工作流、与代理和会话进行交互，以及扩展代理技能。

AutoGen Studio能做什么？​

AutoGen Studio 的用户界面分为三个主要部分 - 构建, 游乐场, 和 画廊.

构建​

本节重点介绍定义代理和代理工作流的属性。它包括以下概念：

技能: 技能是指用于描述如何解决任务的函数（例如Python函数）。通常，一个好的技能应具有描述性名称（如generate_images）、详细的文档字符串和良好的默认设置（例如将文件写入磁盘以实现持久化和重用）。你可以通过提供的用户界面将新技能添加到AutoGen Studio中。在推理时，这些技能将被提供给助手代理，以帮助你完成任务。

AutoGen Studio 构建视图：查看、添加或编辑代理在解决任务时可以使用的技能。

代理: 这提供了一个接口，用于以声明方式指定一个autogen代理的属性（反映了大多数基础AutoGen conversable agent类的成员）。

代理工作流: 代理工作流是一组代理协同工作以完成任务的一种规范。最简单的版本是由两个代理组成的设置——一个用户代理（代表用户，即它编译代码并打印结果）和一个可以处理任务请求的助手（例如，生成计划、编写代码、评估响应、提出错误恢复步骤等）。更复杂的流程可能是一个群聊，其中更多的代理共同寻求解决方案。

Playground​

AutoGen Studio 游乐场视图：代理协作，使用可用技能（生成图像的能力）来处理用户任务（生成PDF文件）。

playground部分专注于交互之前build部分定义的代理工作流。它包含以下概念：

会话: 会话指的是与代理工作流程的持续互动或参与的一段时间，通常以一系列旨在实现特定目标的活动或操作为特征。它包括代理工作流程配置、用户与代理之间的互动。会话可以“发布”到“画廊”。

聊天视图: 聊天是用户和代理之间的一系列交互。它是会话的一部分。

图库​

本节重点介绍分享和重用工件（例如，工作流配置、会话等）。

AutoGen Studio 配备了3个示例技能：fetch_profile, find_papers, generate_images。请随意查看仓库以了解更多关于它们如何工作的信息。

AutoGen Studio API​

虽然AutoGen Studio是一个Web界面，但它由一个底层Python API驱动，该API是可重用和模块化的。重要的是，我们实现了一个API，其中可以以声明方式（使用JSON）指定、加载和运行代理工作流。下面显示了当前API的一个示例。更多详情请参阅AutoGen Studio仓库。

import json
from autogenstudio import AutoGenWorkFlowManager, AgentWorkFlowConfig

# load an agent specification in JSON
agent_spec = json.load(open('agent_spec.json'))

# Create an AutoGen Workflow Configuration from the agent specification
agent_work_flow_config = FlowConfig(**agent_spec)

# Create a Workflow from the configuration
agent_work_flow = AutoGenWorkFlowManager(agent_work_flow_config)

# Run the workflow on a task
task_query = "What is the height of the Eiffel Tower?"
agent_work_flow.run(message=task_query)

路线图和下一步​

随着我们继续开发和优化AutoGen Studio，以下路线图概述了未来版本计划的一系列增强功能和新特性。用户可以期待以下内容：

• 复杂代理工作流程：我们正在努力集成对更复杂代理工作流程的支持，例如GroupChat，允许多个代理之间进行更丰富的交互或动态拓扑结构。
• 改进的用户体验: 这包括流式传输中间模型输出以提供实时反馈、更好地总结代理响应、每次互动的成本信息等功能。我们还将投资于改进代理组合和重用工作流程。我们还将探索支持更多交互式的人在内的循环反馈给代理。
• 扩展代理技能：我们将努力改进编写、组合和重用代理技能的工作流程。
• 社区功能：在AutoGen Studio用户社区内促进分享和协作是一个关键目标。我们正在探索如何更轻松地在用户之间分享会话和结果，并为共享的技能、代理和代理工作流库做出贡献。

贡献指南​

我们欢迎对AutoGen Studio的贡献。我们建议按照以下一般步骤来为项目做出贡献：

• 查看AutoGen项目的整体贡献指南。
• 请查阅 AutoGen Studio 的路线图，了解项目的当前优先级。特别是带有help-wanted标签的 Studio 问题，您的帮助将非常感激。
• 请在路线图问题或新问题上发起讨论，以讨论您提出的贡献。
• 请查看此处的 autogenstudio 开发分支 [dev branch] (https://github.com/microsoft/autogen/tree/autogenstudio)，并将其作为您贡献的基础。这样，您的贡献将与 AutoGen Studio 项目的最新更改保持一致。
• 提交一个包含您贡献的拉取请求！
• 如果你在VSCode中修改AutoGen Studio，它有自己的devcontainer来简化开发工作。请参阅.devcontainer/README.md中的使用说明。
• 请使用标签 studio 来处理与 Studio 相关的任何问题、疑问和 PR。

常见问题解答​

问：我可以在哪里调整默认的技能、代理和工作流配置？ 答：您可以直接通过UI修改代理配置，或者通过编辑autogentstudio/utils/dbdefaults.json文件来初始化数据库。

问：如果我想重置与代理的整个对话，我该怎么做？ 答：要重置您的对话历史记录，您可以删除database.sqlite文件。如果您需要清除用户特定的数据，请删除相关的autogenstudio/web/files/user/<user_id_md5hash>文件夹。

问：是否可以查看代理在交互过程中生成的输出和消息？ 答：是的，您可以在Web UI的调试控制台中查看生成的消息，以了解代理之间的交互情况。或者，您可以检查database.sqlite文件以获取消息的完整记录。

问：在哪里可以找到AutoGen Studio的文档和支持？ 答：我们不断努力改进AutoGen Studio。有关最新更新，请参阅AutoGen Studio自述文件。如需更多支持，请在GitHub上提交问题或在Discord上提问。

问：我可以在AutoGen Studio中使用其他模型吗？ 是的。AutoGen 标准化了 openai 模型 api 格式，你可以使用任何提供 openai 兼容端点的 api 服务器。在 AutoGen Studio 用户界面中，每个代理都有一个 llm_config 字段，你可以在其中输入模型端点的详细信息，包括 模型名称、api 密钥、基础 URL、模型类型 和 api 版本。对于 Azure OpenAI 模型，你可以在 Azure 门户中找到这些详细信息。需要注意的是，对于 Azure OpenAI，模型名称 是部署 ID 或引擎，模型类型 是 "azure"。 对于其他开源模型，我们建议使用像 vllm 这样的服务器来实例化一个 openai 兼容的端点。

问：服务器启动但我无法访问界面 答：如果您在远程机器上运行服务器（或本地机器无法正确解析localhost），则可能需要指定主机地址。默认情况下，主机地址设置为localhost。您可以使用--host <host>参数指定主机地址。例如，要在端口8081和本地地址上启动服务器，以便可以从网络上的其他机器访问，您可以运行以下命令：

autogenstudio ui --port 8081 --host 0.0.0.0