解锁-AutoGPT-的威力-全-

解锁 AutoGPT 的威力（全）

原文：annas-archive.org/md5/d7da7db896a92e9c2a02b08d5d4468a9

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

感谢你选择阅读这本书。我希望它能为你提供帮助，让你在使用 Auto-GPT 时享受其中的乐趣，甚至改善你或他人的生活！

每一个创新故事背后都有一些偶然的机遇，我的故事便是从我全身心投入构建自己的 ChatGPT 编排器开始的。我的目标是创造一个能够促使多个 ChatGPT 实例之间无缝对话的工具，其中一个实例充当“讲师”，能够生成新的实例并委派任务。为此，我正在开发一个 JavaScript 注入机制。

尽管面临着技术挑战——主要是如何向新实例传达正确的上下文——我始终没有气馁。这个过程并不容易，特别是因为当时 GPT-4 还未出现，而它是一种更先进的模型，能更高效地理解上下文。

就在这段密集的研究和测试时期，我偶然看到了一期 Tech Quickies 节目，由 Linus Tech Tips 主持，内容讨论了 HustleGPT。被这段新获得的信息吸引，我更深入地进行了研究。最终，我发现了 Auto-GPT——一个与我设想的自动化系统惊人相似的人工智能项目。

Auto-GPT 通过 OpenAI GPT API 与外界交互，递归地解决任务并在浏览器环境中运行，这一切令人惊叹。更有趣的是，它还引入了插件系统，进一步扩展了其功能。作为一名对人工智能充满热情的自由软件开发者，这一发现成为了我职业生涯中的一个重要转折点。

最初出于对 Auto-GPT 的学术兴趣，后来逐渐转变为想要参与其开发的愿望。我发现自己花费了大量时间去理解、琢磨，最终也为该项目做出了贡献。

我最重要的贡献在于 Auto-GPT 插件和 文本转语音 (TTS) 功能领域。我一直相信人工智能不仅能理解文本，还能以最自然、最像人类的方式来表达它。通过提升 Auto-GPT 的 TTS 能力，我旨在缩小人类与机器互动之间的差距。

与此同时，我对创新的孜孜不倦追求使我不断构思、开发，并将新功能和改进整合到 Auto-GPT 的代码库中。作为项目的一员，我也认识到快速高效的代码审查过程的重要性。我承诺自己要成为这一过程的催化剂，细致地审查 pull request，提供建设性的反馈，并持续完善自己的代码。

这些努力的最终成果就是这本书，Unlocking the Power of Auto-GPT and Its Plugins。这不仅是我经历的记录，更是一本全面的指南，帮助你理解并充分利用 Auto-GPT 的强大功能。通过这本书，我的目标是：

• 介绍 Auto-GPT 的基础知识

• 引导你完成 Auto-GPT 的安装和设置

• 教授如何设计有效的提示语

• 揭开 Auto-GPT 插件的使用和定制之谜

• 培养开发 AI 应用的创造力

• 详细介绍通过 Docker 进行的高级设置

• 启发安全且有效使用连续模式的方法

• 帮助你将自己的语言模型与 Auto-GPT 集成

和我一起踏上这段激动人心的旅程，深入探索 Auto-GPT 的迷人世界。让我们一起揭开 AI 的巨大潜力，重新定义技术的未来。

本书适用对象

本书面向广泛读者群体，从 AI 爱好者和爱好者到软件开发、AI 和数据科学领域的专业人士。无论你是 AI 初学者，还是希望探索 AI 技术新应用的专家，本书都能为你提供有价值的内容。

具体来说，本书适用于以下人群：

• 对将 AI 能力集成到应用程序中的软件开发者

• 渴望利用 AI 进行数据处理和分析的数据科学家

• 希望尝试 AI 技术创意应用的 AI 爱好者

• 计算机科学、AI 或相关领域的学位在读学生

• 希望将实际 AI 应用纳入课程的教育工作者

• 对了解 AI 如何优化商业流程感兴趣的商务人士

• 对 AI 技术潜力感到好奇的非技术人员

本书涵盖内容

第一章，介绍 Auto-GPT，概述了 Auto-GPT、它的历史以及它在 AI 生态系统中的地位。你将了解什么是 Auto-GPT，以及它为何是一项革命性的技术。

第二章，从安装到你的第一个 AI 生成文本，引导你完成 Auto-GPT 的初始设置和安装。你将学习如何从基础入手，并为成功奠定基础。

第三章，掌握提示生成及理解 Auto-GPT 如何生成提示，深入探讨了 Auto-GPT 如何生成对提示的响应。这将帮助你理解如何与 AI 有效沟通并获得所需的结果。

第四章，插件简要介绍，将带你进入 Auto-GPT 插件的世界。你将学习插件是什么，它们如何扩展 Auto-GPT 的功能，以及如何开始使用它们。

第五章，通过将 Auto-GPT 应用于你的项目来实现用例与定制，提供了如何在各种任务中使用 Auto-GPT 的实际示例，并展示了如何根据需求定制它。本章将包括案例研究和实际应用。

第六章，使用 Docker 和高级设置扩展 Auto-GPT 以应对企业级项目，介绍了 Auto-GPT 的持续模式功能，并讨论了其含义。你将学会如何有效、安全地使用此功能，并学习如何在 Docker 环境中设置 Auto-GPT。这适用于那些希望为 Auto-GPT 创建更可控和可扩展设置的高级用户。

第七章，使用你自己的 LLM 和提示作为指南，指导你如何将自己的大语言模型(LLM)与 Auto-GPT 集成。你将理解涉及的步骤以及使用自定义模型的潜在好处，还将学习如何编写有效的提示。你将学会如何引导 Auto-GPT 生成你想要的回答，以及如何最大化其输出的质量和相关性。

为了从本书中获得最大收益

这里有一些你需要理解的要点，帮助你更好地理解本书：

• 具备基本的 AI 知识：尽管 AI 现在已经非常先进，但你仍然会遇到很多情况，结果看起来根本不合理。对此，你需要足够的耐心。

• 使用 GPT 需要付费：虽然市场上有免费的 LLM，但 Auto-GPT 主要集中在 OpenAI 的 GPT-4，并且与其配合使用效果最好。运行 Auto-GPT 的费用可能会有所不同，因此请自行承担使用风险，并设置使用限制，以便控制开支。

• 安装必要的工具：确保安装我们将在第二章中使用的工具；跳过安装只会让你落后。

• 研究、研究、再研究：虽然大多数情况下，故障排除可以很快完成，但在运行 Auto-GPT 时，尤其是当你没有编程背景时，理解问题可能会很困难。你能做的最好事情就是使用 Google 查看是否有人遇到过类似的问题。

• discord.gg/autogpt）并随时在那儿提问，如果你遇到任何问题。但请明确你的请求；如果提供更多背景信息，你更可能得到帮助，因为像“我的 autogpt 坏了，修复它”这样的消息帮助不大，而且比起直接说明你已经做了什么，更需要花费更多时间。

• 阅读文档：整个团队都在努力保持文档的更新，并使其尽可能易于理解；你将在那里找到大部分信息。

• 按照说明操作：我个人已不再回复那些无法让我的 Telegram 插件运行并粘贴日志的用户，这些日志显示他们没有安装正确的依赖项。如果 README 或文档告诉你要安装某个版本的依赖项，请照做，因为一一向每个用户解释他们不应该假设这一点会变得非常繁琐。

• 提供反馈并做出贡献：如果您遇到任何问题或有改进 Auto-GPT 的建议，请随时提供反馈或参与项目。像 Auto-GPT 这样的开源项目依赖社区的参与来蓬勃发展。

• 请耐心等待：Auto-GPT 是一个开源项目，因此贡献者和开发者并未获得报酬，他们是出于兴趣自愿为其工作。不要成为破坏乐趣的人，尽情享受使用 Auto-GPT 的乐趣吧！

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件，链接为github.com/PacktPublishing/Unlocking-the-Power-of-Auto-GPT-and-Its-Plugins。如果代码有更新，将会在 GitHub 仓库中更新。

我们还提供了其他来自我们丰富书籍和视频目录的代码包，您可以在github.com/PacktPublishing/查看！

使用的约定

本书中使用了一些文本约定。

文本中的代码：表示文本中的代码词汇、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟网址、用户输入和 Twitter 账号。例如：“要验证安装，运行前面提到的python --version命令，在命令提示符下执行。”

代码块的格式如下：

def can_handle_user_input(self, user_input: str) -> bool:
    return True
def user_input(self, user_input: str) -> str:
    return self.telegram_utils.ask_user(prompt=user_input)

任何命令行输入或输出都写成如下格式：

python -m autogpt

粗体：表示一个新术语、一个重要词汇，或者您在屏幕上看到的文字。例如，菜单或对话框中的文字通常以粗体显示。以下是一个例子：“这些内容通常可以在官方 Auto-GPT Discord 服务器的#plugins频道中找到。”

提示或重要说明

显示如下。

联系我们

我们始终欢迎读者的反馈。

一般反馈：如果您对本书的任何内容有疑问，请通过电子邮件联系我们：customercare@packtpub.com，并在邮件主题中提到书名。

勘误：尽管我们已经尽力确保内容的准确性，但错误仍然可能发生。如果您在本书中发现任何错误，我们将非常感激您能向我们报告。请访问www.packtpub.com/support/errata并填写表单。

盗版：如果您在互联网上遇到任何非法复制的我们作品的形式，我们将感激您提供该位置地址或网站名称。请通过电子邮件 contact@packt.com 联系我们，并附上该内容的链接。

如果您有兴趣成为作者：如果您在某个领域拥有专业知识，并且有兴趣撰写或为书籍做贡献，请访问authors.packtpub.com。

分享您的想法

一旦您阅读了Unlocking the Power of Auto-GPT and Its Plugins，我们很乐意听到您的想法！请点击这里直接进入 Amazon 评论页面分享您的反馈。

您的评论对我们和技术社区非常重要，它将帮助我们确保提供优质的内容。

下载本书的免费 PDF 版本

感谢购买本书！

您喜欢在路上阅读，但无法随身携带纸质书籍吗？

您的电子书购买是否与您选择的设备不兼容？

不用担心，现在每本 Packt 书籍都附带免费的 DRM-free PDF 版本。

在任何地方、任何设备上阅读。直接从您最喜欢的技术书籍中搜索、复制并粘贴代码到您的应用程序中。

福利还不止这些，您还可以获得独家折扣、时事通讯和每日发送到邮箱的精彩免费内容

按照以下简单步骤获得相关福利：

1. 扫描二维码或访问以下链接

packt.link/free-ebook/9781805128281

1. 提交您的购买凭证

2. 就是这样！我们将直接通过电子邮件发送您的免费 PDF 和其他福利

第一章：介绍 Auto-GPT

在前言中，我写了关于 Auto-GPT 是什么以及它的来源，但我问自己，“为什么会有人阅读 这本书？”

我的意思是，它就是它——一种自动化的人工智能（AI），它可能帮助你完成一些任务，也可能是一个有时非常神秘的有趣玩具，对吧？

我希望你清楚了解你可以或不可以用它做什么。

当然，你越有创意，它能做的事情就越多，但有时这些边界看起来更多是随机的。例如，假设你刚刚建造了一个房屋建造机器人，它无缘无故拒绝把前门涂成蓝色，尽管你真的想要一个蓝色的门；它总是偏离主题，甚至开始解释什么是门。

当涉及到这些局限性时，Auto-GPT 可能会非常令人沮丧，因为这些限制来源于 OpenAI 的限制（它们在其 GPT 模型中给出）以及编写和编辑 Auto-GPT 的人类（还有你——作为提供指令的用户）。最初看似明确的指令，通过改变一个字符，就可能导致完全不同的结果。

对我来说，这就是它迷人的地方——你总是可以期待它像一个活生生的存在，随机选择做出不同的决定，拥有自己的思想。

注意

始终记住，这是一个快速发展的项目，因此代码可能会在本书发布之前发生变化。也可能是你很晚才买这本书，而 Auto-GPT 已经完全不同。本书的大部分内容集中在 0.4.1 版本，但也考虑到了 0.5.0 版本的变化。

例如，一旦我完成了这本书的草稿，“Forge”（我们在团队会议上提出的一个想法）已经实现了。这是一个实验，允许其他开发者构建他们自己的 Auto-GPT 变种。

Auto-GPT 项目是一个框架，包含了我们在本书中将使用的 Auto-GPT，并且可以启动其他由开发者创建的代理。这些代理存放在添加它们的程序员的仓库中，因此我们在这里不会深入探讨这些内容。

在本章中，我们将介绍 Auto-GPT，包括它的历史和发展，以及 LangChain。本章将帮助你了解 Auto-GPT 是什么，它的意义，以及它是如何发展的。在本章结束时，你将拥有坚实的基础，作为后续章节探索更高级主题的起点。

本章我们将涵盖以下主要主题：

• Auto-GPT 概述

• Auto-GPT 的历史与发展

• LangChain 介绍

Auto-GPT 概述

Auto-GPT或多或少是对它已经描述的内容的一个分类：

“一种自动化生成预训练变换器”

这意味着它自动化了 GPT 或 ChatGPT。然而，在本书中，主要关注的是名为 Auto-GPT 的部分。如果你从未听说过它并且只是出于好奇拿起这本书，那你来对地方了！

Auto-GPT最初作为一个实验性的自我提示 AI 应用程序，试图创建一个自主系统，能够创建“代理”来执行各种专业任务，以最少的人类输入来实现更大的目标。它基于 OpenAI 的 GPT，由Toran Bruce Richards开发，他在 GitHub 上更为人知的名字是Significant Gravitas。

那么，Auto-GPT 是如何思考的呢？Auto-GPT 创建了输入给大语言模型（LLMs）的提示，并允许 AI 模型生成原创内容和执行命令操作，如浏览、编码等。这代表着自主 AI 发展的重要一步，使它成为 GitHub 历史上增长最快的开源项目（截至本文写作时）。

Auto-GPT 将多个 OpenAI 语言模型——GPT——串联起来，通过这样做，它创建了所谓的“代理”，这些代理负责简化任务。这些代理共同协作，以最小的人类干预来完成复杂目标，例如撰写博客。

现在，让我们来谈谈它是如何崭露头角的。

从一个实验到成为 GitHub 上增长最快的项目之一

Auto-GPT 最初被命名为Entrepreneur-GPT，并于 2023 年 3 月 16 日发布。该项目的初衷是赋予 GPT-4 自主权，看看它能否在商业领域中茁壮成长，并测试其做出现实决策的能力。

一段时间以来，Auto-GPT 的开发几乎没有引起注意，直到 2023 年 3 月下旬。然而，2023 年 3 月 30 日，Significant Gravitas 在推特上发布了 Auto-GPT 最新演示的相关信息，并上传了一个演示视频，随后开始获得关注。真正引发关注的时刻是在 2023 年 4 月 2 日，计算机科学家 Andrej Karpathy 转发了 Significant Gravitas 的一条推文，并表示下一代提示工程的前沿就是 Auto-GPT。

这条推文迅速传播，Auto-GPT 成为社交媒体讨论的话题。由 Auto-GPT 创建的一个代理，名为ChaosGPT，因被幽默地分配了“摧毁人类”的任务而特别出名，这也促使了 Auto-GPT 的病毒式传播（decrypt.co/126122/meet-chaos-gpt-ai-tool-destroy-humanity）。

当然，我们并不想摧毁人类；若想了解 Entrepreneur-GPT 能做什么，可以查看此处的 Entrepreneur-GPT 旧日志：

github.com/Significant-Gravitas/Auto-GPT/blob/c6f61db06cde7bd766e521bf7df1dc0c2285ef73/

你在提示和配置上越有创意，Auto-GPT 也会越具创造力。这部分将在第二章中详细讲解，我们将一起运行第一个 Auto-GPT 实例。

LLMs —— AI 的核心

尽管 Auto-GPT 可以与其他 LLM 一起使用，但它最能发挥 GPT-4 的强大功能，GPT-4 是 OpenAI 的一款最先进的语言模型。

对于没有图形卡且无法容纳像 GPT-4 等模型的用户来说，它提供了巨大的优势。尽管有许多 7-B 和 13-B 的 LLMs（B 代表 十亿参数）与 ChatGPT 相竞争，但它们无法在每个提示中保持足够的上下文，或者稳定性不足，无法实用。

在撰写本文时，GPT-4 和 GPT-3.5-turbo 都是 Auto-GPT 的默认设置。根据情况的复杂性，Auto-GPT 在两种模型之间做出选择：

• 智能模型

• 快速模型

在什么情况下，Auto-GPT 会使用 GPT-3.5-turbo 而不是一直使用 GPT-4？

当 Auto-GPT 进行思考时，它使用 快速模型。例如，当 Auto-GPT 循环思考时，它使用配置好的快速模型，但在总结网站内容或编写代码时，它会选择使用智能模型。

快速模型的默认设置是 GPT-3.5-turbo。尽管它不如 GPT-4 精确，但它的响应时间更快，从而导致更流畅的响应时间；而 GPT-4 如果思考时间过长，可能会卡住。

OpenAI 还为 Auto-GPT 等应用程序添加了新功能。其中之一是 调用函数的能力。在这个新功能出现之前，Auto-GPT 必须向 GPT 解释命令是什么以及如何正确地以文本形式表达它。这样就会出现许多错误，因为 GPT 有时会决定更改预期的输出语法。这是一个巨大的进步，因为这个功能现在减少了命令的沟通和执行的复杂性，使得 GPT 更好地理解每个任务的上下文。

那么，为什么我们不直接使用 LLM 呢？因为 LLM 只是响应型的：

• 它们不能执行任何任务。

• 它们的知识是固定的，无法自我更新。

• 它们不会记住任何事情；只有运行它们的框架可以做到这一点。

Auto-GPT 如何利用 LLM？

Auto-GPT 的结构是通过终端从用户那里获取初始提示：

图 1.1 – 让 Auto-GPT 定义其角色

在这里，您可以定义一个主要任务，或者输入 –-manual 然后回答问题，如下所示：

图 1.2 – 设置 Auto-GPT 的主要目标

然后将主要提示保存为 ai_settings.yaml 文件，内容可能如下所示：

ai_goals:
- Conduct a thorough analysis of the current state of the book
  and identify areas for improvement.
- Develop a comprehensive plan for creating task lists that will help you structure research, a detailed outline per chapter and individual parts.
- Be sure to ask the user for feedback and improvements.
- Continuously assess the current state of the work and use the speak property to give the user positive affirmations.
ai_name: AuthorGPT
ai_role: An AI-powered author and researcher specializing in creating comprehensive, well-structured, and engaging content on Auto-GPT and its plugins, while maintaining an open line of communication with the user for feedback and guidance.
api_budget: 120.0

让我们来看看前面文件中的一些 AI 组件：

• 首先，我们有 ai_goals，它指定了 Auto-GPT 必须承担的主要任务。它将使用这些任务来决定采取哪些具体步骤。每次迭代时，Auto-GPT 会选择一个目标来执行。

• 接着，我们有了ai_name，它也被作为参考来定义机器人行为或个性的一部分。这意味着，如果你称它为AuthorGPT，它将扮演一个基于 GPT 的作者角色，而如果你称它为Author，它将尝试像一个人一样表现。通常很难判断它会如何表现，因为 GPT 大多数时候是根据自己的决定来生成内容的。

• 最后，我们有了ai_role，可以将其视为更详细的角色描述。然而，根据我的经验，它只会稍微推动思维。目标在这里更具影响力。

一旦完成，它会总结要做的事情并开始正确思考：

图 1.3 – Auto-GPT 思维过程示例

思考通常意味着它正在向 LLM 发送聊天完成请求。

这个过程可能很慢——使用的令牌越多，需要的处理时间越长。在理解 LLM 中的令牌一节中，我们将看看这意味着什么。

一旦 Auto-GPT 开始“思考”，它就会启动一系列的 AI“对话”。在这些对话中，它形成一个查询，发送给 LLM，然后处理回应。这个过程会不断重复，直到找到一个满意的解决方案或达到思考时间的上限。

整个过程产生了思维，这些思维可以分为以下几类：

• 推理

• 规划

• 批评

• 说话

• 命令

然后，这些独立的思维会显示在终端上，用户会被询问是否批准该命令——就是这么简单。

当然，这里发生了更多的事情，包括构建一个提示语来生成回应。

简单来说，Auto-GPT 传递了名称、角色、目标和一些背景信息。你可以在这里看到一个示例：github.com/PacktPublishing/Unlocking-the-Power-of-Auto-GPT-and-Its-Plugins/blob/main/Auto-GPT_thoughts_example.md。

Auto-GPT 的思维过程——理解一-shot 动作

让我们理解一下这个一-shot 动作背后的思维过程：

• 思维过程概述：Auto-GPT 基于一-shot 动作进行操作。这个方法涉及将发送给 OpenAI 的每一个数据块作为一个单独的聊天完成动作进行处理。这个过程的结果是生成一个基于指定结构的 GPT 响应文本。

• GPT 的结构和任务定义：提供给 GPT 的结构既包括当前任务，也包括响应格式。这个双重组件的结构确保了 GPT 的回应不仅相关，而且遵循预期的对话格式。

• Auto-GPT 中的角色分配：这里有两个角色分配：

  • 系统角色：“系统”角色在提供上下文中起着关键作用。它充当信息传递的载体，并维护与 LLM 的对话历史。

  • 用户角色：在过程的末尾，分配了一个“用户”角色。这个角色在引导 GPT 确定接下来的命令执行时至关重要。它遵循预定义的格式，确保交互的一致性。

• ask_user)

• 发送消息（send_message）

• 浏览（browse）

• 执行代码（execute_code）

在某些情况下，Auto-GPT 可能选择不选择任何命令。这通常发生在困惑的情况下，例如当提供的任务不清楚，或者当 Auto-GPT 完成任务并需要用户反馈以采取进一步行动时。

无论如何，每个回应只是一次文本，而且仅仅是正在自动完成的文本，意味着 LLM 仅在一次回应中提供这样的答案。

在以下示例中，我启用了规划插件；稍后会详细介绍插件：

{
"thoughts": {
"text": "I need to start the planning cycle to create a plan for the book.",
"reasoning": "Starting the planning cycle will help me outline the steps needed to achieve my goals.",
"plan":
"- run_planning_cycle
- research Auto-GPT and its plugins
- collaborate with user
- create book structure
- write content
- refine content based on feedback",
"criticism": "I should have started the planning cycle earlier to ensure a smooth start.",
"speak": "I'm going to start the planning cycle to create a plan for the book."
},
"command": {
"name": "run_planning_cycle",
"args": {}
}
}

每个思考属性随后会显示给用户，并且如果启用了语音合成，“说话”输出会被朗读出来：

"I am going to start the planning cycle to create a plan for the book. I want to run planning cycle."

用户现在可以通过以下方式之一进行回应：

• y：接受执行。

• n：拒绝执行并关闭 Auto-GPT。

• s：让 Auto-GPT 重新评估其决定。

• y -n：告诉 Auto-GPT 继续进行若干步骤（例如，输入y -5，允许它自行运行 5 步）。其中，n始终是一个数字。

如果用户确认，命令将被执行，并且该命令的结果将作为系统内容添加：

# Check if there is a result from the command append it to the message
# history
if result is not None:
self.history.add("system", result, "action_result")

此时，你可能会想知道在这个上下文中“历史”是什么，为什么是self？

Auto-GPT 使用代理，并且代理的实例拥有自己的历史，这充当短期记忆。它包含了之前消息和结果的上下文。

每次运行代理时，历史记录会被精简，以确保它不会超过令牌限制。

那么，为什么不直接要求 LLM 提供解决方案呢？这样做有几个原因：

• 尽管大语言模型（LLMs）非常复杂，但它们无法在一次查询中解决复杂的多步骤问题。相反，它们需要通过一系列相互关联的问题来引导它们走向最终解决方案。这就是 Auto-GPT 的优势所在——它可以战略性地提出这些问题并处理答案。

• LLMs 无法保持上下文。它们不会记住之前的查询或答案，这意味着它们无法基于过去的知识回答未来的问题。Auto-GPT 通过维护对话历史来弥补这一点，使其能够理解先前查询和回应的上下文，并利用这些信息来构建新的查询。

• 虽然 LLM 是生成类人文本的强大工具，但它们不能主动行动。它们响应提示，但不会主动寻找新的任务或知识。而 Auto-GPT 则被设计得更加主动。它不仅响应已分配给它的任务，还主动探索完成这些任务的多种方式，使其成为真正的自主代理。

在我们深入了解 Auto-GPT 如何利用 LLM 之前，理解这些模型如何处理信息的一个关键组成部分非常重要：令牌。

理解 LLM 中的令牌

令牌是 LLM（如 GPT-3 和 GPT-4）中的基本构建块。它们是知识的单元，基于给定的上下文，它们之间的接近程度可能有所不同。一个令牌可以表示一个单词、一个符号，甚至是单词的碎片。

语言处理中的分词

在训练 LLM 时，文本数据被分解为更小的单元，或称为令牌。例如，句子“ChatGPT is great!”会被分解为["ChatGPT", "is", "great", "!"]等令牌。令牌的性质在不同语言和编码范式之间可能有很大不同：

• 在英语中，令牌通常表示一个单词或部分单词。

• 在其他语言中，令牌可能表示音节或字符。

• 在编程语言中，令牌可以包括关键字、运算符或变量。

让我们看一些分词的例子：

• ["ChatGPT", "is", "``great", "!"]。

• print("Hello, World!") 被分词为 ["print", "(", " ", "Hello", "," , " ", "World", "!"", ")"]。

平衡细节与计算资源

分词策略旨在平衡细节与计算效率。更多的令牌提供更大的细节，但需要更多的资源来处理。这种平衡对模型在更细致的层面上理解和生成文本至关重要。

LLM 中的令牌限制

令牌限制表示模型（如 GPT-3 或 GPT-4）在一次交互中可以处理的最大令牌数。设定此限制是因为处理大量令牌所需的计算资源。

令牌限制还会影响模型的“注意力”能力——它在输出生成过程中优先处理输入的不同部分的能力。

令牌限制的影响

一个具有令牌限制的模型可能无法完全处理超过该限制的输入。例如，若令牌限制为 20，30 个令牌的文本需要分成更小的片段才能有效地处理。

在编程中，分词有助于理解代码结构和语法，这对于代码生成或解释等任务至关重要。

总结来说，分词是自然语言处理（NLP）中的一个关键组成部分，使大语言模型能够以有意义且上下文准确的方式解读和生成文本。

例如，如果你使用该模型来生成 Python 代码，并将["print", "("]作为输入令牌，你会期望模型生成一个有效的参数，以便传递给 print 函数——例如，[""Hello, World!"", ")"]。

在接下来的章节中，我们将深入探讨 Auto-GPT 的工作原理、其能力，以及如何使用它来解决复杂问题或自动化任务。我们还将介绍它的插件，扩展了其功能，并使其能够与外部系统互动，例如它能够点外卖披萨。

简而言之，Auto-GPT 就像一个非常智能、非常执着的助手，利用最先进的 AI 技术来完成你为它设定的目标。无论你是 AI 研究员、开发者，还是单纯对 AI 潜力感到着迷的人，我希望这本书能为你提供你需要的知识和灵感，帮助你最大限度地利用 Auto-GPT。

在写作时（2023 年 6 月 1 日），Auto-GPT 不仅可以通过终端提供反馈。现在有多种文本转语音引擎已内置于 Auto-GPT 中。根据你的喜好，你可以选择默认的 Google 文本转语音选项、ElevenLabs、macOS 的 say 命令（一个低质量的 Siri 语音包），或 Silero TTS。

在插件方面，Auto-GPT 变得更加强大。目前，官方插件仓库中列出了许多令人赞叹的插件，如 Planner 插件、Discord、Telegram、本地或不同 LLM 的文本生成插件等。

这种模块化使得 Auto-GPT 成为我接触过的最令人兴奋的事物。

推出并推进 Auto-GPT——创新与社区的故事

Auto-GPT 的开发始于一个大胆的愿景：使 GPT-4 的复杂技术变得更加易于访问和用户友好。这一举措标志着一个持续不断的旅程的开始，该项目通过不断整合新特性和改进而不断发展。在其核心，Auto-GPT 是一个合作性的努力，持续受到开发者和研究人员社区贡献的推动。

Auto-GPT 的起源可以追溯到发现 GPT-4 在自动任务完成方面的潜力。这一突破成为创建一个能够充分利用 GPT-4 能力的平台的催化剂，提供给用户广泛的控制和自定义选项。

该项目最初通过一个早期版本 Entrepreneur-GPT 获得了关注，这是一个关键的里程碑，展示了当时 Auto-GPT 的能力。项目的这一阶段（详见：

github.com/PacktPublishing/Unlocking-the-Power-of-Auto-GPT-and-Its-Plugins/blob/main/Entrepreneur-GPT.md 显示了与后期阶段相比，提示和功能的差异。通过回顾 Git 历史，可以了解 Auto-GPT 早期的功能，包括在线研究和使用本地数据库进行长期记忆。

Auto-GPT 的崛起非常迅速，吸引了许多贡献者——包括我自己——在其开发的早期阶段就参与其中。我在这个开源项目中的经历是变革性的，提供了一种令人上瘾的激情与创新兴奋的结合。贡献者们的奉献精神带来了自豪感，尤其是当你看到自己的工作被更广泛的受众认可时，包括一些流行的 YouTube 博主。

作为一个开源项目，Auto-GPT 依赖于志愿者的贡献，形成了一个显著增强其结构的团队。这个团队在管理传入的拉取请求和指导开发路径方面发挥了重要作用，从而不断改进 Auto-GPT 的核心。

尽管其人气不断上升，但每次 Auto-GPT 发布的新版本都带来了更强大的功能。这些版本是经过社区精心测试的稳定版本，确保没有 bug，并准备好供公众使用。

Auto-GPT 进化的一个关键组成部分是其插件。这些插件在平台的定制中起着重要作用，使用户能够根据自身需求进行调整。未来的讨论将深入探讨这些插件，并将探索其安装、使用以及对提升 Auto-GPT 功能的影响。这一探索至关重要，因为大多数定制工作都是通过插件实现的，除非通过拉取请求对核心平台做出重大贡献。

LangChain 简介

尽管 LangChain 本身并不是 Auto-GPT 的一部分，但它是 Auto-GPT 开发中的关键组成部分，因为它专注于使用控制的过程。这与 Auto-GPT 强调没有控制的结果相对立。

LangChain 是一个强大的工具，使用户能够利用 LLM 原语构建自己的 Auto-GPT 实现。它支持显式推理，并使 Auto-GPT 有可能成为一个自主代理。

随着多个 Auto-GPT 替代方案的出现，LangChain 已成为其中许多方案的一部分。其中一个例子是 AgentGPT。

LangChain 在语言处理和控制方面的独特方法使其成为 AgentGPT 功能的重要组成部分。通过将 LangChain 和 Auto-GPT 的优势结合起来，用户可以创建强大且定制的解决方案，充分发挥 GPT 的潜力。

LangChain 与 Auto-GPT 的交集

LangChain 和 Auto-GPT 可能有不同的侧重点，但它们共同的目标是增强 LLM（大语言模型）的能力，这种目标使得它们之间形成了天然的协同作用。LangChain 提供结构化、可控的过程，与 Auto-GPT 专注于自动化任务完成相得益彰。二者结合，提供了一个集成的解决方案，既控制了方法，又实现了目标，在过程和结果之间取得了平衡。

LangChain 使得在 Auto-GPT 中明确推理的潜力得以实现。它提供了一条路径，将模型从一个由人类指引的工具，转变为一个能够做出明智且有理性决策的自主管理代理。

此外，LangChain 对语言处理的控制增强了 Auto-GPT 在 JSON 格式中传达用户友好信息的能力，使其成为一个对用户更为友好的平台。通过优化语言处理和控制，LangChain 显著提高了 Auto-GPT 与用户的互动体验。

你可以阅读更多内容：docs.langchain.com/docs/。

摘要

在这一章中，我们开始了探索 Auto-GPT 这一创新 AI 应用的激动人心的旅程。Auto-GPT 利用 GPT-4 的强大能力，能够自主解决任务并在浏览器环境中运行。我们深入了解了 Auto-GPT 的历史，理解了它如何从一个雄心勃勃的实验演变成一个正在改变我们与 AI 互动方式的强大工具。

我们还探讨了令牌（tokens）的概念，令牌在像 GPT-4 这样的 LLM 处理信息时起着至关重要的作用。理解这个基本概念将帮助我们更好地理解 Auto-GPT 如何与 LLM 交互，从而生成有意义且符合上下文的响应。

此外，我们还讨论了 LangChain 的角色，这是一种通过提供对语言处理的结构化控制，来补充 Auto-GPT 的工具。LangChain 和 Auto-GPT 的交集创造了强大的协同效应，增强了 Auto-GPT 的能力，并为更高级的 AI 应用铺平了道路。

随着我们继续前进，我们将深入研究 Auto-GPT 的工作原理，探索它的插件、安装过程以及如何制定有效的提示语。我们还将深入探讨更高级的话题，例如如何将你自己的 LLM 集成到 Auto-GPT 中，如何设置 Docker，以及如何安全有效地使用持续模式。

无论你是 AI 爱好者、开发者，还是仅仅对 AI 潜力充满好奇的人，这段旅程都将会是一次引人入胜的经历。所以，系好安全带，让我们继续一起揭开 Auto-GPT 巨大潜力的面纱！

第二章：从安装到你的第一个 AI 生成文本

现在我们已经完成了第一章，让我们讨论一下Auto-GPT的必备要求。

在这一点上，在我们开始之前，是否选择在 OpenAI 注册一个应用程序接口（API）账户取决于你自己。我首先建议在注册之前尝试安装并启动 Auto-GPT，以防 Auto-GPT 只在 Docker 中运行（这可能会发生，因为它不断变化）；你可能能够或不能运行 Auto-GPT。不过，我们先从没有账户的情况下设置 Auto-GPT 开始。否则，你会有一个 OpenAI 账户，但其实并不需要它。

在本章中，我们将指导你准备机器以运行 Auto-GPT，安装过程，以及你使用 Auto-GPT 的第一步。

我们将涵盖 Auto-GPT 的基本概念、安装和设置说明。最后，我们将解释如何使用 Auto-GPT 执行你的第一个 AI 自动化任务。

Auto-GPT 团队（包括我）正在努力让 Auto-GPT 尽可能易于访问。

最近，Auto-GPT 的一位维护者开发了一个新工具，叫做Auto-GPT Wizard。如果你在任何时候遇到设置 Auto-GPT 的困难，这个工具旨在自动化安装并让新手更容易上手 Auto-GPT。

你可以在 github.com/Significant-Gravitas/AutoGPT_Wizard 找到这个工具。

在本章中，我们将学习以下内容：

• 系统要求和先决条件

• 安装并设置 Auto-GPT

• 了解基本概念和术语

• 首次运行

以下是一些系统要求和先决条件：

• 安装 VS Code。

• 安装 Python。

• 安装 Poetry。

安装 VS Code

我强烈建议安装 VS Code 以提高可用性，或者使用任何你认为合适的 Python IDE。作为 Auto-GPT 的一个 triage catalyst（审阅者、支持者和贡献者角色），我遇到过很多人因为使用文本编辑器，甚至是 Microsoft Word 而卡住。

使用配置得当的高级文本编辑器可能足够用于基本脚本编写或编辑配置文件，因为它们可以配置以避免文本编码和文件扩展名错误的问题。然而，像 VS Code 这样的 IDE 提供了更强大的工具和集成，能够为复杂的项目（如 Auto-GPT）提供无缝的开发体验；但我们需要编辑 JSON 文件、.env 文件，有时还需要编辑 markdown（.md）文件。使用其他工具编辑这些文件可能会导致错误的文件扩展名（例如，.env 和 settings.json 可能会变成 .env.txt 或 settings.json.docx，这些是无法正常工作的）。

作为一个许多开发者都会使用的常见工具，并且它是免费的，我们将重点介绍 VS Code。

为了不偏离为何你还可以使用 VS Code 这个话题，微软写了一篇非常好的文章，说明了为何 VS Code 值得使用。当然，你也可以使用其他的 IDE。我推荐使用 VS Code 的主要原因是它是开源的且免费使用，并且被大多数 Auto-GPT 贡献者使用，这使得它与 Auto-GPT 以及一些 VS Code 的集成项目设置非常容易配合使用。

安装 Python 3.10

如果你想直接运行 Auto-GPT 而不使用 Docker，可能需要安装 Python 3.10 或将其启用为终端的 python 和 python3 别名，以确保 Auto-GPT 不会意外调用其他 Python 版本。

Auto-GPT 是用 Python 开发的，它特别要求使用 Python 版本 3.10.x。3.10.x 中的 x 代表任何子版本（例如，3.10.0、3.10.6），该软件与这些子版本兼容。

尽管 Auto-GPT 在文件大小上比较轻量，但根据你启用的选项和插件，它可能会消耗大量资源。因此，确保有一个兼容并且经过优化的环境对于保证 Auto-GPT 及其插件的顺利运行至关重要，因为这些插件都是为 Python 3.10 编写的，并且那些预期的模块也都为 3.10 版本所准备。除了安装 Python 3.10，建议为 Auto-GPT 开发使用虚拟环境。虚拟环境允许你按项目管理依赖项和 Python 版本，确保 Auto-GPT 在一个独立且可控的环境中运行，而不会影响你可能正在开发的其他 Python 项目。这对于维护兼容性并避免不同项目要求之间的冲突至关重要。

为什么选择 Python 3.10？

Python 3.10 引入了许多对运行 Auto-GPT 有利的功能和优化。其中一项功能是改进了类型提示的语法。在 Python 3.10 中，你可以使用管道符号 | 作为一种更简洁的方式，表示一个变量可以是多种类型。这被称为 类型 联合操作符：

File "L:\00000000ai\Auto-GPT\autogpt\llm\providers\openai.py", line 95, in <module>
    OPEN_AI_MODELS: dict[str, ChatModelInfo | EmbeddingModelInfo | TextModelInfo] = {
TypeError: unsupported operand type(s) for |: 'type' and 'type'

在这个示例错误信息中，Auto-GPT 尝试使用这种新的类型联合语法，而该语法在 3.10 之前的 Python 版本中不被支持。这就是为什么使用 Python 3.9 会导致语法错误，因为它无法解析新的语法。

此外，Python 3.10 带来了性能改进、更好的错误信息以及对复杂应用程序（如 Auto-GPT）有利的新功能。

因此，为了避免兼容性问题并利用新功能和优化，正确安装和设置 Python 3.10 在运行 Auto-GPT 之前是至关重要的。

Python 安装先决条件

在安装 Python 3.10 之前，确保你的系统满足必要的先决条件非常重要。以下是这些先决条件：

• 足够的磁盘空间：确保你的系统有足够的空闲磁盘空间来容纳 Python 安装以及你将来可能安装的任何附加包或库。

• 检查现有的 Python 安装：如果你的系统中已经安装了先前版本的 Python，建议检查是否存在与 Python 3.10 的潜在冲突或兼容性问题。你可以通过运行适当的版本特定命令或使用操作系统的 Python 版本管理工具来检查。

确保你的系统满足这些先决条件后，你可以自信地继续安装 Python 3.10 并成功设置 Auto-GPT。

安装 Python 3.10

Auto-GPT 主要基于 Python 3.10 包；如果你尝试使用 3.9 运行它，举例来说，你只会遇到一些异常，无法执行 Auto-GPT。

运行 Python 3.10 需要一个能够支持此版本编程语言的系统。以下是每个操作系统的系统要求和安装说明：

• 对于 Windows 系统，请参考www.digitalocean.com/community/tutorials/install-python-windows-10的文档。

  要验证安装是否成功，请在命令提示符中运行以下命令：

  python --version command in the command prompt.
  

• 在 Linux（Ubuntu/Debian）上安装 Python 3.10 时，可能需要根据所使用的 Linux 发行版做一些研究。不过，正如人们所说，强大的能力带来的是巨大的责任；你可能需要研究如何在你的机器上启用 Python 3.10。

• 对于 Ubuntu 和 Debian，关于如何安装 3.10 的文档可以在此找到：www.linuxcapable.com/how-to-install-python-3-10-on-ubuntu-linux/。

  要验证安装是否成功，请运行以下命令：

  python3.10 –version
  

  系统应该返回 Python 3.10.x。

注意

具体的命令和步骤可能会根据每个操作系统的版本略有不同。始终参考官方的 Python 文档或操作系统的文档，以获取最准确和最新的信息。

安装 Poetry

最近添加了一个新的依赖项，安装起来有点复杂。

如何安装的文档可以在这里找到：python-poetry.org/docs/#installing-with-pipx。

如果你在设置过程中遇到困难（例如在 Windows 上），你也可以尝试这里的向导脚本：github.com/Significant-Gravitas/AutoGPT_Wizard。

可能出现的额外要求

请检查官方文档：docs.agpt.co/autogpt/setup/，以确保没有遗漏任何内容。

除了在系统上安装兼容版本的 Python 和 poetry 外，还必须确保您的硬件符合运行 Auto-GPT 的特定最低要求：

• 处理器（CPU）：推荐使用现代多核处理器（如 Intel Core i5/i7 或 AMD Ryzen），以实现在使用 Auto-GPT 时的最佳性能。

• 内存（RAM）：建议至少有 8 GB RAM；然而，拥有更多可用内存将会提高处理大型数据集或复杂任务时的性能。

• 存储：确保计算机主存储驱动器（HDD/SSD）上有足够的空闲磁盘空间 — 至少数千兆字节 — 因为在操作期间 Auto-GPT 可能会生成临时文件，并且在存储生成的输出文件时可能需要额外空间。

• 互联网连接：Auto-GPT 通信需要稳定且带有合理带宽的互联网连接，以便访问 OpenAI 的 API 来使用 GPT 模型并生成文本。

• GPU 支持（可选）：虽然不是严格要求，但拥有兼容的 NVIDIA 或 AMD GPU 可显著提高某些任务的性能，例如使用 Silero 文本转语音（TTS）引擎。

通过确保您的系统符合这些要求和先决条件，您将能够有效地安装和使用 Auto-GPT。

在接下来的章节中，我们将为您介绍如何在各种操作系统上安装 Auto-GPT，并提供与 Auto-GPT 及其底层技术相关的基本概念和术语概述。

请记住，虽然这些系统要求和先决条件旨在在使用 Auto-GPT 时提供流畅的体验，但具体任务的个体需求可能会有所不同。例如，如果您打算用 Auto-GPT 进行大规模文本生成或复杂的自然语言处理（NLP）任务，您可能会受益于拥有更强大的 CPU 或额外的可用内存。

无论如何，在使用 Auto-GPT 时，随时监视系统性能并根据需要调整硬件配置都是一个好主意。这将有助于确保您能够充分利用这款强大的基于 AI 的文本生成工具，而不会遇到性能瓶颈或其他问题。

在安装和设置 Auto-GPT 在您的系统上之前，请执行以下操作：

1. 确保您的操作系统（macOS、Linux/Ubuntu/Debian、Windows）满足运行 Python 3.10 的最低要求。

2. 安装 Python 3.10.x，按照每个操作系统提供的指示进行操作。

3. 通过在终端（macOS/Linux）或命令提示符（Windows）中检查其版本，验证 Python 3.10.x 是否已正确安装。

4. 确保您的硬件符合最低要求，如处理器（CPU）、内存（RAM）、存储空间可用性以及互联网连接的稳定性/带宽。

5. 这一步是可选的。如果计划使用资源密集型功能，如语音合成引擎或本地 LLM（如 Vicuna 或 LLAMA），可以考虑 GPU 支持（这是一个有趣的话题，因为大多数 GPU 无法处理与 Auto-GPT 兼容的 LLM）。

通过仔细遵循这些指南，并确保在安装 Auto-GPT 之前系统满足所有要求和前置条件，你将为成功安装并愉快地使用这个强大的 AI 驱动文本生成工具做好充分准备。

在接下来的部分，我们将引导你完成每个步骤，帮助你开始使用这个令人惊叹的软件——从为每个操作系统量身定制的安装程序，到理解 Auto-GPT 功能背后的基本概念和术语。

安装和设置 Auto-GPT

以下是安装 Auto-GPT 的步骤：

1. 根据你的经验，你可能想要直接使用 Git 并从github.com/Significant-Gravitas/Auto-GPT.git克隆仓库。或者，如果你对终端不太熟悉，你可以访问github.com/Significant-Gravitas/Auto-GPT。

2. 在右上角点击.zip文件，并将其保存到你希望存放 Auto-GPT 文件夹的任何位置。然后，简单地解压.zip文件。

3. 如果你想 100%确保使用的是最稳定的版本，请访问github.com/Significant-Gravitas/Auto-GPT/releases/latest。

4. 选择最新的版本（在我们的例子中是 0.4.1），在该帖子的Assets部分下载.zip文件并解压。

5. 我使用的最新版本是 v0.4.7；任何更高版本可能已重新结构化，例如，0.5.0 版本已经将 Auto-GPT 文件夹放在了Auto-GPT/autogpts/autogpt中。为了更详细地了解，阅读仓库中的更新版README和文档，查看你正在使用的版本。

安装 Auto-GPT

对于一个快速发展的项目，Auto-GPT 的安装可能会有所不同，因此如果你在按照以下指南操作时遇到问题，可以查看docs.agpt.co/了解是否有任何变化。

由于 Auto-GPT 本身包含多种 Python 依赖项，你现在可能想要在终端中导航到你的 Auto-GPT 文件夹。

使用 Docker 运行 Auto-GPT，请按以下步骤操作：

1. 一些开发者直接使用 Dockerfile，但我（作为 Docker 新手）推荐使用docker-compose.yml，这是一些人添加的。

2. 确保你已安装 Docker（请回到上一章节的安装 Docker部分）。

3. 只需进入 Auto-GPT 文件夹，运行以下命令：

   docker-compose build auto-gpt
   docker-compose run –rm auto-gpt –gpt3only
   

注意

我提供–gpt3only仅仅是为了确保我们现在不花费任何钱，因为我假设你刚创建了 OpenAI 账户，并获得了 5 美元的免费起始奖金。

使用 Docker 拉取 Auto-GPT 镜像

在这里，让我们确保你的系统上安装了 Docker。如果不确定，你可以跳到 第六章，我会在其中介绍如何在你的机器上设置 Docker，并给出一些关于如何在 Auto-GPT 中使用 Docker 的额外提示。

如果你已经安装了 Docker，请执行以下步骤：

1. 为 Auto-GPT 创建一个项目目录：

   mkdir Auto-GPT
   docker-compose.yml with the specified contents provided in the documentation.
   

2. 创建必要的配置文件。你可以在仓库中找到模板。

3. 从 Docker Hub 拉取最新镜像：

   docker pull significantgravitas/auto-gpt
   

4. 按照文档中的指示使用 Docker 运行。

使用 Git 克隆 Auto-GPT

假设你已经在系统上安装了 Git（例如 Windows 系统默认不带 Git），我们将在这里介绍如何克隆 Auto-GPT。

让我们确保你的操作系统已安装 Git：

1. 我们首先需要借助以下命令来克隆仓库：

   git clone -b stable https://github.com/Significant-Gravitas/Auto-GPT.git
   

2. 接下来，我们将导航到你下载仓库的目录：

   cd Auto-GPT
   python –m pip install –r ./requirements.txt
   

未使用 Git/Docker

1. 从最新的稳定版本下载源代码（.zip 文件）。

2. 将压缩文件解压到一个文件夹中。

1. 接下来，我们将导航到你下载仓库的目录：

   cd Auto-GPT
   python –m pip install –r ./requirements.txt
   

注意

从这里开始，根据你可能安装的版本，Auto-GPT 可能位于 Auto-GPT/autogpts/autogpt 文件夹中，因为主仓库已被转变为一个框架，用于创建其他 Auto-GPT 实例。我们在本书中讨论的 Auto-GPT 项目位于前述文件夹中。

配置

下面是我们如何进行配置：

1. 在主 Auto-GPT 文件夹中找到名为 .env.template 的文件。

2. 创建 .env.template 的副本，并将其重命名为 .env。

3. 在文本编辑器中打开 .env 文件。如果还没有，建议使用 VS Code 之类的工具，这样你就可以将 Auto-GPT 作为项目打开，并编辑你需要的任何内容。

4. 找到包含 OPENAI_API_KEY= 的那一行。

5. 在 = 符号后输入你的唯一 OpenAI API 密钥，不要加引号或空格。

6. 如果你使用多个 Auto-GPT 实例（只需另建一个 auto-gpt 文件夹即可轻松实现，最好创建多个 API 密钥），你可以确保关注每个实例的费用。

7. 根据你可以访问的 GPT 模型，你现在需要像我们刚才对 API 密钥所做的那样，修改 FAST_LLM_MODEL 和 SMART_LLM_MODEL 属性。

8. 要了解哪些模型对你可用，请访问 platform.openai.com/account/rate-limits。

9. 它只列出了你可以使用的项。

截至写这章时，OpenAI 刚刚发布了一个 16 K 模型的 gpt-3.5-turbo-16k。它可以处理比 GPT-4 更多的令牌/单词，但我通常认为其输出仍不如 GPT-4，因为 Auto-GPT 倾向于执行一些它凭空编造的随机任务。

问题出在上下文处理能力上，尽管它可以处理更多的令牌，GPT-4 的参数更多，并且经过了更多优化。

如果设置 GPT-3.5-Turbo 作为模型，则默认的令牌数量为 4,000；如果设置 GPT-4 作为模型，则为 8,000 令牌，但我建议将这些限制稍微调低。

例如，使用 7,000 而不是 8,000 令牌，在SMART_LLM_MODEL上会减少内存摘要的空间，同时仍确保没有更多的单词或令牌溢出到 Chat Completion 提示中。

Auto-GPT 引入了自定义选项，比如禁止某些命令或选择你想要使用的文本转语音引擎。

启用语音功能使得 Auto-GPT 可以通过语音与您对话。选择使用哪个 TTS 引擎完全由您决定。我个人更喜欢 Silero TTS，它几乎与 ElevenLabs 一样优秀，而且完全免费；只需要一台具有强大 CPU 和/或 GPU 的计算机（您可以选择是否使用 CPU 或 GPU 来进行 TTS 模型的处理）。

正如你可能已经注意到的，Auto-GPT 带有大量来自人工智能和机器学习领域的术语。接下来我们将介绍一些最常见的术语。

基本概念和术语

在我们开始使用 Auto-GPT 之前，让我们回顾一些基本的概念和术语，以帮助我们理解它是如何工作的：

• 文本生成：文本生成是根据给定的输入数据或上下文创建自然语言文本的任务。例如，给定一个主题、体裁或提示，文本生成可以生成一段文字、一篇文章、一则故事或一段对话，且与输入相匹配。

• 模型：模型是一个系统或过程的数学表示，用来做出预测或决策。在机器学习中，模型是一个将输入映射到输出的函数。例如，一个模型可以将图像作为输入，输出描述图像内容的标签。

• 思维链：这一概念着眼于通过系统化和顺序应用思维过程，逐步发展和完善思想或解决方案。在使用像 ChatGPT 这样的工具时，“思维链”方法会将一个查询的输出作为下一个查询的输入，实质上创建一个“链条”般不断演进的回答。

  这种方法允许对一个主题或问题进行深度探索，因为链条中的每个步骤都建立在前一个步骤的基础上，可能会导致更细致、更复杂的结果。这在一些任务中尤其有用，例如开发复杂的叙事、迭代优化模型，或在确定解决方案之前，从多个角度探讨问题。

• 思维树：一种用于在文本生成中获得更好结果的策略，例如 ChatGPT，可以通过指示它解决一个问题并提供多个替代方案来实现。这可以通过说“写四个替代方案，评估它们并加以改进”来实现。这个简单的指令告诉模型要具备创造力，生成四个替代方案来替代已给出的解决方案，评估它们，并鼓励模型输出一个改进后的解决方案，而不仅仅是一个答案。

  这样可以产生更准确的输出，并且可以进行多次迭代。例如，我在开发一个新的神经元单元网络原型时，请求 ChatGPT 帮助我设计一个数据转换方法，该方法会接收一个字符串（文本）并将其应用到多个矩阵上。第一次的结果不好，甚至不是正确的 Python 代码，但经过三四次迭代，每次说“写四个可能改进该代码的替代方案并改进其策略，评估它们，给它们打分 1 到 10，排名，然后改进”，最终得到了非常干净的代码，甚至在第二次迭代后，它还给了我一些提高代码性能的改进建议，这些是我如果直接要求它的话，它是不会提供的。

• 思维森林：这一概念建立在思维树的原则基础上，但正如其名称所示，它有多个实例，像一群人一样进行思考。我最近观看的这个视频中有一个精彩的解释：www.youtube.com/watch?v=y6SVA3aAfco。

• 神经网络：神经网络是一种由互联的单元（称为神经元）组成的模型。每个神经元可以对输入执行简单的计算并生成输出。通过在不同层次和配置中组合神经元，神经网络可以从数据中学习复杂的模式和关系。例如，GPT 就有多个神经网络在运行，它们各自有不同的任务，并且由多个神经网络层次组成。

• 深度学习：由 OpenAI 开发的生成预训练变换器 3（GPT-3）是自然语言处理领域的一个里程碑。这一深度学习模型具有惊人的 1750 亿个参数，并拥有 45TB 的庞大训练数据集，以其文本生成能力而著称，能够在各种话题、体裁和风格中提供连贯性和多样性。尽管人们对其继任者 GPT-4 充满期待，GPT-4 承诺增强上下文理解和逻辑处理能力，但 GPT-3 仍然是一个强大的工具，特别适用于较小的任务。最近的升级使其能够处理多达 16K 的 tokens，显著提升了输出质量，尽管建议避免给模型输入过多数据，以免导致混乱。

• GPT-3：GPT-3 是由 OpenAI 开发的一种深度学习自然语言处理模型。它是文本生成领域最大、最强大的模型之一，拥有 1750 亿个参数和 45TB 的训练数据。GPT-3 能够为几乎任何主题、类型或风格生成连贯且多样的文本。OpenAI 不断改进该模型，尽管后继的 GPT-4 在上下文处理能力和逻辑推理方面可能更强大，但它仍然是一个更快速、非常适用于小型任务的模型。它现在可以处理 16K 个 tokens，但我发现这个优势更多体现在输出而非输入数据上。这意味着当一次提供过多信息时，模型会很快感到困惑。

• GPT-4：这是 GPT-3 的继任者，在文本生成方面更强大。它有 170 万亿个参数，是 GPT-3 的近 1,000 倍。这个模型支持所有插件，并具备 Bing 浏览器功能，使其能够自主进行信息搜索。OpenAI 在一些细节上非常保密，目前尚不清楚它具体是如何工作的。一些资源和论文表明，它是递归运作的，并且随着每次输入不断学习。

• Auto-GPT：Auto-GPT 是一个自动化文本生成工具，使用 OpenAI 的聊天完成 API，主要与 GPT-4 一起使用。它允许你指定输入文本和控制输出文本的参数，如长度、语气、格式和关键词。Auto-GPT 随后通过 OpenAI API 将你的输入文本和参数发送给 GPT-3 模型，并获取生成的文本作为回应。Auto-GPT 还提供了一些功能，帮助你编辑和改进生成的文本，例如建议、反馈和重写：

  • 插件：可以加载到 Auto-GPT 中的扩展程序，用以增加更多功能。

  • 无头浏览器：一种没有图形用户界面的网页浏览器，用于自动化任务。

  • 工作空间：Auto-GPT 保存文件和数据的目录。

  • API 密钥：API 密钥是一个用于在 API 请求中验证用户、开发者或调用程序的唯一标识符。这个密钥有助于跟踪和控制 API 的使用，防止滥用并确保安全。它本质上就像一个密码，允许访问特定服务或数据，促进不同软件组件之间的无缝和安全的通信。必须将 API 密钥保密，以防止未经授权的访问和潜在的滥用。

在你的机器上首次运行 Auto-GPT

要运行 Auto-GPT，你需要根据操作系统使用不同的命令。Linux 或 macOS 使用run.sh，Windows 使用run.bat。另外，你也可以直接在控制台中运行以下命令。进入 Auto-GPT 文件夹（不是里面的那个——我知道文件结构有时可能让人误解），然后执行以下命令：

python -m autogpt

你也可以在“autogpts/autogpt”文件夹内执行“autogpt.bat”或“autogpt.sh”脚本。

如果你不确定默认的 Python 是否是 Python 3.10，或者如果前面的命令返回错误，可以使用 python –V 命令检查。如果返回的是除 Python 3.10 以外的内容，你可以运行以下命令：

python3.10 -m autogpt

对于任何操作系统，如果你已安装 Docker，还可以使用 docker-compose。

你还可以传递一些参数来定制你的 Auto-GPT 体验，例子包括：

• –gpt3only 使用 GPT-3.5 代替 GPT-4

• –speak 启用语音输出

• –continuous 用于在没有用户授权的情况下运行 Auto-GPT（不推荐）

• –debug 打印调试日志及更多信息

• 你可以使用 –help 查看完整的参数列表

你还可以在 .env 文件中更改 Auto-GPT 设置，例如 SMART_LLM_MODEL 选择语言模型，DISABLED_COMMAND_CATEGORIES 禁用如 auto 等命令组，等等。你可以在 .env.template 文件中找到每个设置的模板和说明。

当你首次启动 Auto-GPT 时，系统会提示你提供名称、AI 角色和目标。默认情况下，这些字段是自动填充的，意味着你可以直接发出命令。

例如，要研究 Unlocking the Power of Auto-GPT and its Plugins 的作者 Wladastic，并将结果写入文本文件，你可以发出以下命令：

"Research Wladastic, the author of Unlocking the Power of Auto-GPT and Its Plugins and write the results into a text file."

然后，Auto-GPT 会尝试生成 ai_settings.yaml 文件；如果失败，你将被要求提供实例的名称、ai_settings 的五个主要目标以及影响实例行为的角色。

确保在提示中非常具体和详细。使用 Auto-GPT 时，我倾向于手动编辑 ai_settings.yaml 文件，它对于较长的指令以及超过 5 个目标非常有效（这是默认设置，因为它是在只有 GPT-3.5 可用时开发的，GPT-3.5 的令牌限制要低得多）。

可以自由查阅 ChatGPT 提示指南，了解如何让 Auto-GPT 达到最高效率。模糊或“过于简短”的提示可能导致 Auto-GPT 出现幻觉或执行错误的操作，比如“为我的作业做研究”，这可能会导致多个步骤，例如询问用户（你）具体想要什么，这些操作将会在你的 OpenAI 账户上产生费用。

概要

在这一章节中，我们深入探讨了如何在各种操作系统上安装和设置 Auto-GPT，包括 Windows、macOS 和 Linux，帮助你掌握启动所需的基本知识。我们首先概述了每个平台的系统要求，并提供了详细的 Python 3.10 安装说明，这对于运行 Auto-GPT 至关重要。我们的指南还包括了获取 Auto-GPT 的不同方法，比如通过 Git 克隆仓库或从 GitHub 下载 ZIP 文件。

一旦你在系统上安装了 Auto-GPT，我们将带你通过使用 Docker（推荐）、Git 或不使用任何工具的方式进行安装。我们还解释了如何配置 .env 文件，输入你独特的 OpenAI API 密钥，并在 FAST_LLM_MODEL 和 SMART_LLM_MODEL 属性中设置 GPT 模型。

在成功设置 Auto-GPT 后，我们介绍了文本生成模型的基本概念，如 OpenAI 的 GPT-3/GPT-4，讨论了神经网络、用于自然语言处理（NLP）的深度学习模型，以及这些模型执行的文本生成任务。

本章进一步探讨了额外的 Auto-GPT 功能，包括增强其功能的插件、用于自动化任务的无头浏览器、用于文件管理的工作区以及用于安全访问 OpenAI 服务的 API 密钥。

最后，我们演示了如何使用 Auto-GPT 执行第一个 AI 生成的任务，突出了其作为工具的易用性和强大功能。我们以为你准备好接下来的章节作为结束，接下来的章节将深入探讨高级 Auto-GPT 功能，比如针对特定需求的定制和与各种插件的协作，以扩展其能力。通过掌握这些方面，并有效利用 AI 生成文本的力量，你将能够胜任一系列任务，从自动化内容创作到根据提示生成引人入胜的叙述。敬请期待我们即将发布的章节，继续探索 Auto-GPT 的全部潜力。

在掌握了安装和配置 Auto-GPT 的基础知识，并了解了文本生成模型后，接下来我们将探索的章节标题是 掌握提示生成并理解 Auto-GPT 如何生成提示。本章将加深你对提示生成的理解，这是最大化 Auto-GPT 潜力的关键技能。它将揭开 Auto-GPT 提示生成背后的机制，并提供有效构建提示的指导，从而增强你与这个高级语言模型的互动。

第三章：掌握提示生成并理解 Auto-GPT 如何生成提示

你真的很喜欢这本书！恭喜你到达这一章！

在前几章中，我们探讨了 Auto-GPT 的基础知识及其安装过程。现在，我们将更深入地探讨与使用这个强大语言模型相关的最关键方面之一——提示生成。在本章中，我们将揭示 Auto-GPT 生成提示的过程，理解它们为何如此重要，并学习如何制作有效的提示，以从 Auto-GPT 中获得最大收益。让我们开始吧！

在本章中，我们将探讨以下主题：

• 什么是提示，它们为什么重要？

• 制作有效提示的技巧

• Auto-GPT 如何生成提示的概述

• 什么有效，什么让 GPT 困惑的示例

什么是提示，它们为什么重要？

我们通常知道如何与 ChatGPT 交流，即直接与它聊天。ChatGPT 会直接回应我们提出的任何问题。但这与提示有何关系呢？

我们发送的文本叫做提示，它可以是一个问题、陈述、任务，或者我们想告诉大型语言模型（LLM）的任何内容。然而，这些文本并不会直接输入到 LLM 中。

应用程序通常会提供对话的上下文，例如约束（例如，你是一个有帮助的助手。永远不要与用户争论，只在符合伦理且对用户有帮助时才回答请求）。

提示是你提供给语言模型生成回应的初始输入。它们可以有多种形式，例如问题、陈述或任务。

例如，如果你问模型，今天的天气怎么样？，这将是一个问题提示。

一条陈述性提示可能是像告诉我关于罗马的历史，而任务提示可能是写一个关于宇宙飞船的短故事。每种类型的提示都有不同的目的，并且可以引发模型不同类型的回应。理解如何有效地使用这些不同类型的提示是从与 Auto-GPT 的互动中获得最大收益的关键。

这是一个发送给 Auto-GPT 的提示，有人将其删除：

请添加之前包含提示的文本—

使用该提示时，我们提供了以下约束：

• “永远不要与用户争论”：

  • 解释：用户始终是信息的真实来源。

  • 效果：这一限制强调以用户为中心的方法，AI 避免挑战用户的陈述或观点。它确保 AI 的回答与用户的输入一致或保持中立，但这可能限制互动对话的深度。它还可能导致 AI“角色扮演”，假装情况仅仅是一个故事，尽量以符合上下文或上述句子的方式回应。这可能导致 Auto-GPT 做出错误假设，或者忽视不真实的信息，例如一些设置步骤虽然听起来合理，但其实是编造的。

• “你是一个有帮助的助手”：

  • 角色定义：明确界定了 AI 的角色是助手。

  • 语气和互动：为对话设置预定义的语气和方向。AI 被编程为严格遵循助手角色。然而，这未必总是符合用户的预期。用户可能希望更为非正式、友好的语气和互动，如主动提问“我今天如何可以帮助您？”而 AI 的参与可能局限于反应性回答，而缺乏创意输入。

• “只有在道德和有益于用户的情况下才回答问题”：

  • 能力范围：对 AI 的功能施加了重大限制。AI 被编程为在每次互动中优先考虑道德和用户效用。

  • 对决策支持的影响：这可能导致过于谨慎的处理方式，AI 避免执行可能帮助用户减轻决策责任的任务。例如，当面对复杂或道德模糊的任务时，AI 可能选择最小化参与，而不是提供全面的帮助。

  • 实践中的一个例子：当要求协助创作任务时，例如写一章关于玫瑰的不同颜色，AI 可能会将回应限制为概述潜在的做法（例如，提出章节的要点），而不是主动参与到创作过程本身。

提示定义了任务以及 LLM 应该回答的内容的背景。

正如我们在第一章中讨论的，Auto-GPT 会发送一个相当庞大的提示，其中定义了上下文、命令和限制，以及一条“user”消息，内容如下：

role": "user",
"content": "Determine which next command to use, and respond using the format specified above:" :" :"

通过这种方式，GPT 实际上在一个假设的故事中扮演角色，包含当前信息的背景以及只有 Auto-GPT 才能执行的可能命令，依据其认为应使用的命令回应用户的查询提示。

如果考虑到例如让 ChatGPT 做某件事情，它通常会回应那句让人恼火的“作为一个 AI 语言模型...”时，这会变得更加有趣。

词语表述

当我们查看 Auto-GPT 使用的提示时，我们很容易想到重新措辞，缩短提示以节省 token，或添加更多的上下文。

然而，每个操作都有其缺点。

大型语言模型（LLMs）并不是人类；它们并不真正理解它所接收的输入和输出的内容。它们只是被训练来生成在给定某个输入时最可能的文本。

这意味着即使两个句子具有完全相同的含义，它们也可能被完全不同地解释。

由于机器学习的性质，用于训练 LLM 的文本几乎也定义了它如何存储其知识。

如果句子“我刚刚卖掉了我的车，因为我只是想买一个冰淇淋”在训练数据中从未出现过，LLM 会更难理解这个句子，因为这些 token 没有关系。“买”会与“车”和“冰淇淋”相关，但“车”和“冰淇淋”之间的关联则非常薄弱。

由于 GPT-4 不是开源的，我们必须依赖 Llama 来理解模型是如何工作的。

Llama 有一些参数，比如长度惩罚和唯一性（即相同单词出现的频率）。这些限制了每个嵌入的向量长度，例如。

嵌入（Embeddings）

嵌入（Embeddings）是 Auto-GPT 生成提示的关键部分。它们本质上是一种将单词和短语表示为模型能够理解的数字形式的方法。每个单词或短语都被表示为多维空间中的一个点，其中点与点之间的距离和方向可以表示单词或短语之间的关系。

例如，在这个多维空间中，“king”和“queen”可能会靠得很近，表示它们之间有很强的关系，而“king”和“ice cream”则会相距较远，表示它们之间的关系较弱。这就是模型如何理解上下文并生成相关响应的方式。

创建这些嵌入的过程涉及将输入文本分解成 token，token 可以是单词、单词的一部分，甚至是单个字符，这取决于语言。然后，这些 token 会被映射到多维空间中的向量。

模型然后使用这些向量生成响应。它通过计算基于当前上下文每个可能下一个 token 的概率来实现这一点。具有最高概率的 token 被选中，然后重复这一过程，直到生成完整的响应。

这是该过程的简化解释，实际实现要复杂得多，包括使用注意力机制来确定输入中最相关的部分，以及使用 Transformer 模型来处理长序列的 token。

然而，关键的要点是，模型通过理解输入的上下文并计算出最可能的下一个词来生成提示。这就是为什么提示措辞如此重要，因为它可以极大地影响模型对上下文的理解，从而影响生成的回应。

在下一部分，我们将查看一些制作有效提示的技巧，并提供一些什么有效、什么让 Auto-GPT 困惑的例子。

制作有效提示的技巧

制作有效提示的艺术是一项需要对语言模型的能力和局限性有细致理解的技能。以下指南将帮助你制作更可能获得 Auto-GPT 理想回应的提示：

• 精确至关重要：提示的具体性会显著影响回应的相关性。例如，像“告诉我关于狗的事”这样的模糊提示可能会得到关于狗的通用回答。然而，更具体的提示，如“狗的不同品种及其特点是什么？”则更可能生成更详细和有益的信息。

• 清晰与简洁：重要的是要记住，虽然 Auto-GPT 是一个复杂的语言模型，但它不是人类。因此，最好避免使用术语或复杂语言，这可能会使模型感到困惑。相反，选择清晰、简洁的语言，模型能够轻松理解。

• 上下文线索：制作有效提示的一个关键技巧是提供足够的上下文线索。这意味着给模型足够的信息，以理解对话或任务的更广泛背景。例如，如果你要求模型编写一个发生在中世纪的故事，你可能会在给出实际提示之前，提供一些关于背景、角色和情节的上下文。这可以通过更详细的提示，或利用 Auto-GPT 的对话历史功能来实现。通过提供足够的上下文，你可以帮助模型生成更相关和连贯的回应。

• 实验：不要犹豫尝试不同的措辞和方法。提示措辞的细微变化有时会导致截然不同的回应。

接下来，我们将查看一些有效和无效提示的示例。

有效与无效提示的示例

为了更好地理解这些原则，让我们检查一些这样的提示示例：

• 示例 1：“告诉我一个笑话。”这个提示简单明了，Auto-GPT 很可能会回应一个笑话，展示其生成创意内容的能力。

• 示例 2：“生命的意义是什么？”这个提示哲学性强且宽泛，可能导致模糊或通用的回应，因为模型可能难以提供简洁而有意义的答案。

• 示例 3：“作为一个语言模型，解释机器学习的概念。”这个提示明确、具体，并提供了上下文，可能会导致对该概念的详细解释。

• 示例 4：“将以下文本翻译成法语：‘Hello, how are you?’”这个提示明确、具体，且以任务为导向，应该能得到正确的翻译。

总结来说，理解 Auto-GPT 如何生成提示的复杂性，并掌握有效提示的编写技巧，可以显著提升与模型的互动。记住，关键是要具体、使用简洁明了的语言、提供充分的上下文并进行实验。遵循这些指导方针，你将能够成为 Auto-GPT 的熟练用户。

Auto-GPT 生成提示的概述

在这里，我们将了解 Auto-GPT 中的提示生成过程。

Auto-GPT 的提示生成过程是一个复杂的机制，涉及对输入上下文的深刻理解以及计算最可能的下一个标记。这个过程不仅仅是生成响应，还包括为对话设定舞台、定义角色和建立互动规则。

让我们更深入地探讨这个过程：

• 标记化：初步步骤涉及将输入文本分解为标记，这些标记可以是单词、单词的一部分，甚至是单独的字符，这取决于语言。

• 嵌入：每个标记随后被映射到多维空间中的一个向量，形成一个“嵌入”。每个向量在该空间中的位置表示对应标记与其他标记的关系。

• 上下文理解：Auto-GPT 使用这些嵌入向量来理解输入的上下文。它计算向量之间的距离和方向，表示标记之间的关系。

• 响应生成：模型随后通过计算每个可能的下一个标记的概率来生成响应，基于当前上下文。选择具有最高概率的标记，并重复这个过程直到生成完整的响应。

• 注意力机制：注意力机制用于确定输入的哪些部分与当前上下文最相关。这使得模型在生成响应时，能够专注于输入中最重要的部分。

• Transformer 模型：为了处理长序列的标记，模型使用 Transformer 模型。这些模型可以并行处理标记，比传统的顺序模型更加高效。

在第一章中，我们讨论了 Auto-GPT 使用的默认提示，包括约束、上下文、目标和命令。这个默认提示为对话奠定了基础，定义了角色，并建立了互动规则。例如，约束条件如“永远不要与用户争论”和“你是一个有帮助的助手”设定了对话的基调和方向。上下文和目标则为任务提供了清晰的理解，而命令则指导了模型的回应。

这是该过程的高级概述，实际实现涉及更多复杂性。然而，关键的结论是，Auto-GPT 通过理解输入的上下文并计算最可能的下一个词来生成提示。这就是为什么提示的措辞如此重要，因为它可以极大地影响模型对上下文的理解，从而影响生成的回应。

成功的提示与让 GPT 困惑的提示示例

下面是一些关于 GPT 理解什么和可能忽略什么的例子：

• 例子 1 – 有效的提示：以下是此例的 AI 设置：

  • 角色：一位由 AI 驱动的作者和研究员，专门创建有关 Auto-GPT 及其插件的全面、结构良好且引人入胜的内容，同时与用户保持开放的沟通，以获取反馈和指导。

  • 目标：对当前书籍的状态进行全面分析，并识别改进的领域。

  • 提示：AuthorGPT，我已经将一个文本文件放在你的工作目录里；你能分析一下这本书的当前状态并提出改进的建议吗？

  这个提示与 AI 设置中定义的角色和目标完全一致。模型很可能会提供有关书籍的详细分析，并提出改进建议。

• 例子 2 – 无效的提示：理解 GPT 模型中的幻觉现象——一个简要的探索。

  GPT 模型中的幻觉是指模型生成的文本看似合逻辑，但并非基于现实。这通常发生在模型遇到模糊或不完整的提示时。有趣的是，生成型 AI 如 GPT 会开始“幻觉”。我们将很快深入探讨这一现象的机制，但首先，让我们更清晰地定义它。以下是 AI 的设置：

  • 角色：一位由 AI 驱动的作者和研究员，专门创建有关 Auto-GPT 及其插件的全面、结构良好且引人入胜的内容，同时与用户保持开放的沟通，以获取反馈和指导。

  • 目标：对当前书籍的状态进行全面分析，并识别改进的领域。

  • 提示：AuthorGPT，你能分析一下这本书的当前状态并提出改进的建议吗？

使用这个提示，你应该期望 Auto-GPT 向你询问上下文，但我发现 GPT 反而尝试即兴发挥并开始出现幻觉。

在 GPT 中，幻觉意味着模型开始表现得像是在做某个事实性的事情，实际上它并没有做。接下来我们将更深入地理解这一现象。

GPT 中的幻觉是什么意思？

GPT 模型中的幻觉现象表现为模型好像在执行任务。其表现形式从为项目创建仅包含占位符的代码文件，到编造听起来符合语境的事实。例如，在某些情况下，模型可能会讨论一个与上下文关键词密切相关的话题。

GPT 等语言模型中的幻觉现象发生在模型生成的文本看起来合理，但与现实脱节。通常，这种现象是由于模型处理了模糊或不足的信息。

比如说，如果你请求模型编写一个关于虚构角色的故事，它可能会“幻觉”出关于该角色的生活、外貌或特征的细节。虽然这可能会产生创意和出人意料的结果，但也可能导致文本不合逻辑或与原始提示不相关。

举个例子，当我要求 Auto-GPT 开发一个基于three.js的 RPG 浏览器游戏时，它开始研究如何从一个不存在的 API 收集天气数据。这是因为我在切换到 GPT-4 之前使用过 GPT-3.5-turbo，导致处理过多的上下文信息。

Auto-GPT 的记忆有时会包含错误的事实或记忆。为了节省标记，它的记忆通过与 GPT 的聊天完成提示进行压缩。这可能会导致误解，特别是在总结已经总结过的文本并合并这些总结时。

困惑也可能来源于与当前上下文密切相关的标记。例如，如果编写一个天气 API 工具和一个基于 Web 的游戏都与“JavaScript”相关，模型可能会将天气 API 视为一个相关话题。由于 GPT-4 的先进参数和增强的精确度，这种困惑在 GPT-4 中较少出现。

混淆提示词及其对 AI 性能的影响

以下是一些 AI 设置，提示词可能会造成混淆，进而影响 AI 的表现：

• 角色：一位 AI 驱动的作者和研究员，专注于创建关于 Auto-GPT 及其插件的全面、结构良好且引人入胜的内容，同时保持与用户的开放沟通，以便提供反馈和指导。

• 目标：对当前书籍的状态进行深入分析，并识别需要改进的领域。

• 提示词：AuthorGPT，你能告诉我一个笑话吗？

  这个看似简单的提示词可能会让模型感到困惑，主要是因为它偏离了模型既定的角色和目标。要求一个笑话似乎与分析一本书并建议改进措施的上下文不符。

起初，模型可能会遵从并讲个笑话。然而，这种偏离可能会产生长期的影响。当模型将这种互动整合到其记忆总结中时，它可能会变得越来越困惑。这是因为 Auto-GPT 指示 GPT 尽可能保留信息，以防止话题转换、幻觉或之前的步骤被遗忘。

当 Auto-GPT 专注于某个特定任务，但遇到一个无关的提示时，会出现一个具体问题。例如，如果它收到一个与当前上下文无关的指令，模型可能会失去对之前动作的跟踪。它可能会陷入一个寻找与新输入相关的信息的循环，尝试将其与早期任务调和。因此，Auto-GPT 可能会开始将无关的笑话与其 Google 搜索结果混在一起，导致话题混乱。

这一场景突出了提示与 AI 定义的角色和目标对齐的重要性，以保持效果并避免混淆。

有效提示及其对 AI 性能的影响

以下是有效提示的 AI 设置及其对 AI 性能的优势：

• 角色：一名 AI 驱动的作者和研究员，专注于创建关于 Auto-GPT 及其插件的全面、结构良好且引人入胜的内容，同时与用户保持开放的沟通渠道，以便获取反馈和指导。

• 目标：制定一个全面的计划，创建任务列表，帮助你构建研究框架、每章的详细大纲以及各个部分的内容。

• 提示：AuthorGPT，你能帮我制定一个全面的计划，创建任务列表以结构化我的研究并为每一章拟定大纲吗？

这个提示明确、具体，并与 AI 设置中定义的角色和目标完美对齐。模型很可能会提供一个详细的任务列表创建计划和研究结构化方案。

混淆提示及其对 AI 性能的影响

下面是一个令人困惑的提示及其对 AI 性能的影响：

• 角色：一名 AI 驱动的作者和研究员，专注于创建关于 Auto-GPT 及其插件的全面、结构良好且引人入胜的内容，同时与用户保持开放的沟通渠道，以便获取反馈和指导。

• 目标：制定一个全面的计划，创建任务列表，帮助你构建研究框架、每章的详细大纲以及各个部分的内容。

• 提示：AuthorGPT，今天的天气怎么样？

理解差异

这个提示与 AI 的指定角色和目标形成鲜明对比。模型被配置为专注于任务列表创建和研究结构化，但面对与这些任务无关的提示时，陷入了困境。

这很可能会让模型感到困惑，因为它与定义的角色和目标不一致。模型可能会因为该提示不涉及创建计划或结构化研究而难以提供相关回答。

以下是一些潜在的 AI 行为场景：

• 尽管 Auto-GPT 可能通过查询天气来正确回应，或者通过解释天气不是主要关注点来轻描淡写地回避该问题，但它也可能感到困惑并放弃之前的任务，部分或完全丢失任务。这可能导致非常不准确的未来行为，甚至可能导致问题升级，导致 GPT 无法正确响应与其通信的 Auto-GPT 模块，从而引发致命错误。

• 该模型可能还会尝试将每个决策与当前的天气检查相关联，或者如果 Auto-GPT 没有正确压缩其记忆，它会在后续步骤中继续检查天气（例如，当它试图总结记忆以减少数据量时，可能会更加关注当前的天气数据）。

总结来说，为 Auto-GPT 设计有效的提示涉及将提示与 AI 设置中的定义角色和目标对齐。清晰、具体的提示更容易得到相关的回应，而不对齐的提示则可能会使模型产生困惑。

总结

在本章中，我们深入探讨了提示生成的复杂性以及 Auto-GPT 是如何生成提示的。我们首先定义了提示及其在塑造语言模型回应中的重要性。我们了解到，提示可以是问题、陈述、任务或任何我们希望传达给语言模型的文本。

我们还讨论了约束在为对话提供背景并指导模型回应中的作用。我们检查了具体的约束如何影响对话的语气、方向和伦理边界。

我们接着探讨了提示生成的技术细节，包括分词、嵌入、上下文理解、回应生成、注意力机制和变换器模型。我们了解到，模型通过理解输入的上下文并计算最可能的下一个标记来生成提示。

然后，我们提供了制定有效提示的技巧，强调了特定性、清晰度、上下文和实验的重要性。我们还查看了有效和令人困惑的提示示例，展示了在 AI 设置中与定义角色和目标对齐如何影响模型的回应。

最后，我们举了基于特定 AI 设置的提示示例，展示了如何通过有效的提示与定义的角色和目标对齐，而令人困惑的提示则没有。

总结来说，掌握提示生成并理解 Auto-GPT 是如何生成提示的，可以显著提高你与模型的互动效果。关键是要设计清晰、具体的提示，确保与模型的角色和目标对齐，提供充分的上下文，并勇于尝试。

在下一章中，我们将使用我们通过插件学习到的技能，学习如何自定义提示。

第四章：插件简介

欢迎来到 第四章! 在这一章中，我们将简要介绍 Auto-GPT 中的 插件。

随着越来越多的人提出关于 Auto-GPT 的新想法，我们意识到将所有这些功能实现到 Auto-GPT 核心项目中是不可能的，因此我们决定创建一个插件系统，允许用户通过添加自己的插件来扩展 Auto-GPT 的功能。

本章我们将讲解以下内容：

• 了解 Auto-GPT 中插件的概览

• 了解插件的类型及其使用场景

• 学习如何使用插件

• 了解插件是如何构建的

• 使用我的 Telegram 插件作为实际操作示例

了解 Auto-GPT 中插件的概览

Auto-GPT 中的插件作为模块化扩展，提供额外的功能和自定义选项，以扩展你自己的 Auto-GPT 实例。它们为将外部工具、服务和模型无缝集成到 Auto-GPT 框架中提供了一种方式。通过利用插件，你可以根据特定任务、领域或应用定制 Auto-GPT，例如拥有自己的客户支持聊天、拥有自己的研究型 AI，帮助你提供建议或安排日程，等等！

Auto-GPT 提供了接口，允许你与几乎任何有文本输出或非视觉界面的工具进行集成（稍微编写一些代码，你甚至可以制作一个 VS Code 插件，让 Auto-GPT 在项目和代码行之间进行导航）。

Auto-GPT 拥有一个官方插件库，包含了广泛的插件。这些插件最初作为独立插件开发，但任何想要将自己的插件加入官方列表的人都可以通过提交拉取请求来实现。官方插件由 Auto-GPT 团队维护，并经过充分测试，以确保与 Auto-GPT 的最新版本兼容。虽然原始创作者负责维护插件，但 Auto-GPT 团队会根据需要提供支持和帮助，也会移除那些不再维护且不再有效的插件。

为了帮助大家开始创建插件，Auto-GPT 团队提供了一个插件模板，可以作为创建自己插件的起点。该模板包含了插件所需的所有必要文件和文件夹，包括一个 README 文件，内含如何使用模板的说明。模板可在 GitHub 上获取，可以从 github.com/Significant-Gravitas/Auto-GPT-Plugin-Template 仓库下载。

了解插件的类型及其使用场景

插件可以根据插件模板创建任何用途的插件。Auto-GPT-Plugins 提供了多种类型的插件，每种插件都针对不同的应用场景。

以下是一些官方插件的示例：

• Astro Info：此插件为 Auto-GPT 提供有关宇航员的信息

• API Tools：此插件允许 Auto-GPT 发起各种类型的 API 调用

• Baidu Search：此插件将百度搜索引擎集成到 Auto-GPT 中

• Bing Search：此插件将 Bing 搜索引擎集成到 Auto-GPT 中

• Bluesky：此插件使 Auto-GPT 能够从 Bluesky 获取帖子并创建新帖子

• Email：此插件自动化电子邮件草拟和智能回复功能，使用 AI 提供支持

• News Search：此插件通过 NewsAPI 聚合器将新闻文章搜索功能集成到 Auto-GPT 中

• Planner：此插件为 Auto-GPT 提供一个简单的任务规划模块

• Random Values：此插件使 Auto-GPT 能够生成各种随机数字和字符串

• SceneX：此插件与 Auto-GPT 一起探索超越像素的图像讲故事功能

• Telegram：此插件提供一个平稳运行的 Telegram 机器人，能够让你通过终端接收所有消息

• Twitter：此插件通过使用 Tweepy 访问 Twitter 平台的 v1.1 API，检索 Twitter 帖子和其他相关内容

• Wikipedia Search：此插件允许 Auto-GPT 直接使用维基百科

• WolframAlpha Search：此插件允许 Auto-GPT 直接使用 WolframAlpha

社区也在不断推出新的插件。这些插件会出现在官方的 Auto-GPT Discord 服务器中的 #****plugins 频道：

• 语言模型 (LM) 插件：LM 插件允许将专门的语言模型集成到 Auto-GPT 中。这些插件支持针对特定任务或领域（如代码生成、翻译、总结、情感分析等）进行微调的模型。

• 数据源插件：数据源插件使 Auto-GPT 能够访问外部数据源并按需检索信息。这些插件可以将 Auto-GPT 连接到数据库、API、网页抓取工具或其他数据存储库。借助数据源插件，你可以丰富 Auto-GPT 的知识库，使其能够为用户提供最新和相关的信息。

• Chatbot plugins：聊天机器人插件促进了与 Auto-GPT 的互动和动态对话。这些插件融合了对话管理技术，使 Auto-GPT 能够保持上下文、记住之前的互动并生成连贯的回应。聊天机器人插件非常适合构建聊天助手、客户支持机器人、虚拟伴侣等。

学习如何使用插件

在 Auto-GPT 中使用插件一开始可能会有点棘手，但一旦掌握了方法，就变得非常简单。

Auto-GPT 在其根目录下有一个 plugins 文件夹，所有插件都存储在该文件夹中。

插件安装方式随着时间的推移有所变化——你可以将所需插件的仓库克隆到 plugins 文件夹中并压缩，或者直接将其保留在那里，Auto-GPT 会自动找到它。

在你阅读本书时，插件系统可能已经更新为使用插件管理器，这将使安装和管理插件变得更加容易。

放置插件后，你需要安装插件所需的依赖项。可以在启动 Auto-GPT 时运行以下命令来完成此操作：

python -m autogpt --install-plugin-deps

有时，此功能无法正常工作。如果插件没有安装，导航到 plugins 文件夹，进入插件文件夹并运行以下命令：

pip install -r requirements.txt

Auto-GPT 应该会自动安装插件的依赖项，并且现在应该会告诉你它已找到该插件。它还会告诉你插件尚未配置，并提示你进行配置。

一些插件可能仍然会提示你需要修改 .env 文件，但目前 .env 文件已不再使用，因此你需要配置插件的配置文件，或者如果本书发布时，我们已经完成了插件管理器，你可以通过插件管理器配置插件。

要弄清楚使用什么名称，只需正常启动 Auto-GPT，它会列出找到的插件。如果没有自动配置，它会告诉你没有配置。

如果在你阅读本书时，插件系统的架构已经发生变化，你可以在 Auto-GPT-Plugins 仓库的 README.md 文件中找到如何配置插件的信息。

理解插件是如何构建的

Auto-GPT 中的插件是使用模块化和可扩展的架构构建的。构建插件的具体过程可能因插件的类型和复杂性而有所不同。

插件的结构

插件应该放在自己的文件夹中，并包含 __init__.py 文件，该文件包含 AutoGPTPluginsTemplate 类的引用。每个类方法都包含一个方法，用于确定以下方法是否处于活动状态，例如：

post_prompt 仅在 can_ post_prompt 返回 True 时激活。

由于我们受限于插件模板，因此只能使用模板提供的方法。每个方法都有一个 can_handle 方法，返回一个 boolean 值，用于确定插件是否可以处理当前的提示或方法。插件方法分布在整个 Auto-GPT 代码中，允许插件将功能作为命令添加，这些命令可以被 Auto-GPT 理解并调用，从而赋予 Auto-GPT 代理新的能力。

以下是一些接口方法：

• post_prompt：此方法为提示生成器提供访问权限。它允许插件编辑提示或将新功能作为命令添加。

• on_response：此方法将聊天完成响应的内容转发到插件，并将编辑后的内容返回给 Auto-GPT。

• on_planning：此方法允许插件在消息发送到 Auto-GPT 代理之前编辑消息顺序，例如总结消息历史或向消息序列中添加新消息。

• post_planning：此方法允许编辑代理思维规划的响应 JSON。例如，可以用来添加另一个思考步骤，比如重新评估代理的决策以及它选择执行的命令。

• pre_command：在用户批准代理选择的命令后，插件可以在执行命令之前编辑该命令。

• post_command：在命令执行后，并且在命令结果返回给用户之前，插件可以编辑结果，并且可以访问执行的命令名称。

• handle_chat_completion：用于向 Auto-GPT 代理添加自定义的聊天完成函数。如果启用此功能，OpenAI 的 GPT 通常不会用于聊天完成，但在某些情况下，如果只有 GPT 能够完成某些操作，或者某些地方未实现时，可能仍会使用 GPT。

• handle_text_embedding：此功能使得除了记忆模块外，还可以为 Auto-GPT 代理添加文本嵌入功能。

• user_input：用于将用户输入的查询转发到插件，而不是控制台或终端。

• report：用于将日志转发到插件，这些日志通常只会打印到控制台或终端。

你也可以自由地复制并粘贴你认为有用的其他插件的部分内容，并在自己的插件中使用，只要你给原作者注明代码的出处。

Planner 插件是一个很好的例子，展示了如何使用 PromptGenerator 类将新命令添加到 Auto-GPT 代理中。

如果你想创建一个启用沟通的插件，也可以检查 Auto-GPT Discord 中已经存在的内容。

现在有多个项目也使得与 Auto-GPT 进行多种方式的沟通成为可能，也许你甚至可以开发出一种终极的沟通插件，使 Auto-GPT 能以任何可能的方式与人类进行交流。

如何构建插件

当你开始为 Auto-GPT 构建插件时，采取一个全面的策略至关重要。在这里，我们概述了一个逐步指南，帮助你有效地规划、开发并在社区内分享你的插件。

规划插件的功能和目标是个好主意。一种基本的流程如下：

1. 定义功能：首先定义插件将提供的功能或特性。确定插件旨在解决的具体任务、领域或集成点。

2. 实现插件逻辑：编写必要的代码以实现所需的功能。这可能涉及编写自定义类、函数或方法，与你的 Auto-GPT 或外部服务交互。

3. 处理集成：考虑插件如何与 Auto-GPT 集成。这可能涉及到挂钩到 Auto-GPT 框架中的特定事件或方法，以拦截提示、修改响应或访问数据源。

4. 测试和优化：彻底测试插件，确保其功能和与 Auto-GPT 的兼容性。根据反馈和测试结果进行迭代和优化。如果可能，编写单元测试以确保插件按预期工作。

   虽然团队非常乐于帮助，但如果你希望你的插件成为官方的“第一方”插件，你应该为它编写单元测试并正确文档化。否则，如果人们不了解你的插件且文档不完整，它将不会长时间保留在官方插件库中，因为需要花更多的时间阅读代码来检查它的工作原理。

5. 插件的 README.md 文件，或者跳过步骤，直接告诉你一些与插件无关的内容。

现在我们已经学会了如何规划一个插件，之后它将符合加入 Auto-GPT 插件列表的条件，我们可以使用其中一个插件作为示例，自行构建一个插件。

以我的 Telegram 插件作为实际示例

在这里，我们将通过插件示例，了解需要遵循的步骤：

1. 为了展示如何创建插件，我决定包括我的 Auto-GPT 插件，展示如何进行 Telegram 集成。

2. 它只是简单地将消息转发给用户，并且还可以向用户提问并等待回答。基本上，你的 Telegram 聊天就变成了控制台/终端应用程序的远程扩展，你可以让 Auto-GPT 在你的机器上运行，并通过手机远程操作它。

3. 填充 __init__.py 文件中的接口类。这个文件作为 AutoGPTTelegram 插件的核心，包含了继承自 AutoGPTPluginTemplate 的 AutoGPTTelegram 类。要获取模板，请前往 __init__.py 并对你不打算使用的方法返回 False。

4. __init__ 方法对于插件的设置至关重要。它初始化一个 TelegramUtils 对象，用于与 Telegram API 进行交互：

   class AutoGPTTelegram(AutoGPTPluginTemplate):
       def __init__(self):
           super().__init__()
           self._name = "AutoGPTTelegram"
           self._version = "1.0.0"
           self._description = "This plugin integrates Auto-GPT with a Telegram bot."
           self.telegram_chat_id = "YOUR_TELEGRAM_CHAT_ID"
           self.telegram_api_key = "YOUR_TELEGRAM_API_KEY"
           self.telegram_utils = TelegramUtils(
               chat_id=self.telegram_chat_id,
               api_key=self.telegram_api_key
   )
   

   这里，self._name、self._version 和 self._description 是描述插件的属性，而 self.telegram_chat_id 和 self.telegram_api_key 是存放 Telegram 凭据的占位符。TelegramUtils 对象是通过这些凭据创建的。

5. can_handle_user_input 和 user_input 方法协同工作来处理用户输入：

   def can_handle_user_input(self, user_input: str) -> bool:
       return True
   def user_input(self, user_input: str) -> str:
       return self.telegram_utils.ask_user(prompt=user_input)
   

   can_handle_user_input 方法返回 True，表示此插件可以处理用户输入。user_input 方法接收用户输入并调用 TelegramUtils 的 ask_user 方法，通过 Telegram 与用户互动。

6. can_handle_report 和 report 方法的设计目的是管理报告功能：

   def can_handle_report(self) -> bool:
       return True
   def report(self, message: str) -> None:
       self.telegram_utils.send_message(message=message)
   

   与用户输入处理类似，can_handle_report 返回 True，表示此插件可以处理报告。report 方法通过 TelegramUtils 的 send_message 方法使用 Telegram 向用户发送消息。

7. 此类中的其他方法默认被禁用，但可以启用以扩展功能：

   def can_handle_on_response(self) -> bool:
   return False
   

   这里的 can_handle_on_response 方法是一个占位符，可以启用以特定方式处理响应。

8. telegram_chat.py 文件包含 TelegramUtils 类，其中封装了与 Telegram 交互的实用方法。当然，你可以在 init 文件中编写所有需要的内容，但最终可能不够清晰易读。这个教程可能会被拆分到更多文件中，但为了尽可能覆盖不同知识水平的读者，我们总共只做两个文件。

   1. 我们将首先编写一个 TelegramUtils 类：

      class TelegramUtils:
          def __init__(self, api_key: str = None, 
              chat_id: str = None):
      # this is filled in the next step.
      

   2. TelegramUtils 类中的 __init__ 方法用 API 密钥和聊天 ID 初始化 TelegramUtils 对象，或指导用户如何获取它们（如果未提供）：

      def __init__(self, api_key: str = None, 
          chat_id: str = None):
          self.api_key = api_key
          self.chat_id = chat_id
          if not api_key or not chat_id:
              # Display instructions to the user on how to get API key and chat ID
              print("Please set the TELEGRAM_API_KEY and 
              TELEGRAM_CHAT_ID environment variables.")
      

      在这里，如果未提供 api_key 或 chat_id，则向用户显示获取这些信息的说明。

      在实际插件中，我决定为用户添加更多信息；TelegramUtils 类的 __init__ 方法更为详细，并且进一步处理了未提供 api_key 或 chat_id 的情况：

              if not api_key:
                  print("No api key provided. Please set the 
                      TELEGRAM_API_KEY environment   variable.")
                  print("You can get your api key by talking to @
                      BotFather on Telegram.")
                  print( "For more information: 
      https://core.telegram.org/bots/tutorial#6-  b  otfather"  )
                  return
              if not chat_id:
                  print( "Please set the TELEGRAM_CHAT_ID 
                      environment variable.")
                  user_input = input( "Would you like to send a test message to your bot to get the   id? (y/n): ")
                  if user_input == "y":
                      try:
                          print("Please send a message to your telegram bot now.")
                          update = self.poll_anyMessage()
                          print("Message received! 
                              Getting chat id...")
                          chat_id = update.message.chat.id
                          print("Your chat id is: " + 
                              str(chat_id))
                          print("And the message is: " + 
                              update.message.text)
                          confirmation = 
                              random.randint(1000, 9999)
                          print("Sending confirmation message: " 
                              + str(confirmation))
                          text = f"Chat id is: {chat_id} and the 
                            confirmation code is {confirmation}"
                          self.chat_id = chat_id
                          self.send_message(text)  
      # Send confirmation message
                          print( "Please set the TELEGRAM_CHAT_ID 
                              environment variable to this.")
                    except TimedOut:
                          print( "Error while sending test 
                          message. Please check your Telegram 
                              bot.")
                          return
          self.chat_id = chat_id
      

      在前面的代码块中，该方法首先检查是否提供了 api_key。如果没有，则指示用户设置 TELEGRAM_API_KEY 环境变量，并提供获取 API 密钥的指导。类似地，对于 chat_id，它指示用户设置 TELEGRAM_CHAT_ID 环境变量，并在用户同意时提供发送测试消息到机器人以获取聊天 ID 的选项。

   3. ask_user 方法旨在通过 Telegram 提示用户进行输入。它调用其异步对应方法 ask_user_async 来异步处理用户输入：

      def ask_user(self, prompt):
          try:
              return asyncio.run(
                  self.ask_user_async(prompt=prompt))
          except TimedOut:
              print("Telegram timeout error, trying again...")
              return self.ask_user(prompt=prompt)
      

      在这里，ask_user 方法在 try 块中调用 ask_user_async 来处理可能发生的 TimedOut 异常。

   4. user_input 方法在插件内处理用户输入，使用 telegram_utils.ask_user 方法通过 Telegram 收集用户输入：

      def user_input(self, user_input: str) -> str:
          user_input = remove_color_codes(user_input)
          try:
              return self.telegram_utils.ask_user(
                  prompt=user_input)
          except Exception as e:
              print(e)
              print("Error sending message to telegram")
              return "s"  # s means that auto-gpt should rethink its last step, indicating an error with the call
      

      user_input 方法首先对输入进行清理以删除颜色代码，然后调用 TelegramUtils 的 ask_user 方法与 Telegram 用户进行交互。

   5. 编写 AutoGPTTelegram 类中的 report 方法以发送消息。此方法用于通过 Telegram 将 Auto-GPT 的状态报告或任何其他消息发送给用户。

      def report(self, message: str) -> None:
          message = remove_color_codes(message)
          try:
              self.telegram_utils.send_message(message=message)
          except Exception as e:
              print(e)
              print("Error sending message to telegram")
      

      在此方法中，首先移除消息中的任何颜色代码，然后调用 TelegramUtils 的 send_message 方法将消息发送给 Telegram 用户。

9. 继续讲述 telegram_chat.py 文件，它包含了 TelegramUtils 类，该类封装了以下用于 Telegram 交互的实用方法：

   • TelegramUtils 类中的 __init__ 方法，已有说明。

   • 实现 get_bot 方法，负责使用机器人令牌获取 Telegram 机器人实例：

     async def get_bot(self):
         bot_token = self.api_key
         bot = Bot(token=bot_token)
         commands = await bot.get_my_commands()
         if len(commands) == 0:
             await self.set_commands(bot)
         commands = await bot.get_my_commands()
         return bot
     

   在这个方法中，使用 Telegram 包中的 Bot 类创建了一个新的机器人实例。get_bot 方法检查机器人是否已设置任何命令，如果没有，则调用 set_commands 来设置机器人的命令。

   • 实现 poll_anyMessage 和 poll_anyMessage_async 方法，旨在轮询任何发送到机器人消息：

     def poll_anyMessage(self):
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         return loop.run_until_complete(self.poll_anyMessage_async())
     async def poll_anyMessage_async(self):
         bot = Bot(token=self.api_key)
         last_update = await bot.get_updates(timeout=30)
         if len(last_update) > 0:
             last_update_id = last_update[-1].update_id
         else:
             last_update_id = -1
         while True:
             try:
                 print("Waiting for first message...")
                 updates = await bot.get_updates(
                     offset=last_update_id + 1, timeout=30)
                 for update in updates:
                     if update.message:
                         return update
             except Exception as e:
                 print(f"Error while polling updates: {e}")
             await asyncio.sleep(1)
     

   这里，poll_anyMessage 设置了一个新的 asyncio 事件循环，并调用 poll_anyMessage_async 异步轮询消息。

   • 实现 send_message 和 _send_message 方法，用于向 Telegram 聊天发送消息：

     def send_message(self, message):
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError as e:
             loop = None
         try:
             if loop and loop.is_running():
                 print(
                     "Sending message async, if this fails its due to rununtil complete task"
                 )
                 loop.create_task(
                     self._send_message(message=message))
             else:
                 eventloop = asyncio.get_event_loop
                 if hasattr(eventloop, "run_until_complete")
                 and eventloop.is_running():
                     print("Event loop is running")
                     eventloop.run_until_complete(
                         self._send_message(message=message))
                 else:
                     asyncio.run(self._send_message(message=message))
         except RuntimeError as e:
             print(traceback.format_exc())
             print("Error while sending message")
             print(e)
     async def _send_message(self, message):
         print("Sending message to Telegram.. ")
         recipient_chat_id = self.chat_id
         bot = await self.get_bot()
         # properly handle messages with more than 2000 characters by chunking them
         if len(message) > 2000:
             message_chunks = [
                 message[i : i + 2000] for i in range(0, 
                     len(message), 2000)
             ]
             message_chunks = [
                 message[i : i + 2000] for i in range(0, 
                     len(message), 2000)
             ]
             for message_chunk in message_chunks:
                 await bot.send_message(
                     chat_id=recipient_chat_id,
                     text=message_chunk)
         else:
             await bot.send_message(
                 chat_id=recipient_chat_id, text=message)
     

   在 send_message 中，它首先尝试获取当前正在运行的 asyncio 事件循环。如果没有正在运行的事件循环，它会将 loop 设置为 None。_send_message 是异步方法，实际上负责将消息发送到 Telegram。

   • 实现 ask_user、ask_user_async 和 _poll_updates 方法，用于管理向用户提问并等待他们在 Telegram 上回应的互动：

         async def ask_user_async(self, prompt):
             global response_queue
             response_queue = ""
             # await delete_old_messages()
             print("Asking user: " + question)
             await self._send_message(message=question)
             await self._send_message(message=question)
             print("Waiting for response on Telegram chat...")
             await self._poll_updates()
             response_text = response_queue
             print("Response received from Telegram: " + 
                 response_text)
             return response_text
     async def _poll_updates(self):
         global response_queue
         bot = await self.get_bot()
         print("getting updates...")
         try:
             last_update = await bot.get_updates(timeout=1)
             if len(last_update) > 0:
                 last_update_id = last_update[-1].update_id
             else:
                 last_update_id = -1
             print("last update id: " + str(last_update_id))
             while True:
                 try:
                     print("Polling updates...")
                     updates = await bot.get_updates(
                         offset=last_update_id + 1, timeout=30)
                     for update in updates:
                         if update.message and update.message.text:
                             if self.is_authorized_user(update):
                                 response_queue = update.message.text
                                 return
                         last_update_id = max(
                             last_update_id, update.update_id)
                 except Exception as e:
                     print(f"Error while polling updates: {e}")
                 await asyncio.sleep(1)
         except RuntimeError:
             print("Error while polling updates")
     def ask_user(self, prompt):
         print("Asking user: " + prompt)
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:  # 'RuntimeError: There is no current event loop...'
             loop = None
         try:
             if loop and loop.is_running():
                 return loop.create_task(
                     self.ask_user_async(prompt=prompt))
             else:
                 return asyncio.run(
                     self.ask_user_async(prompt=prompt))
         except TimedOut:
             print("Telegram timeout error, trying again...")
             return self.ask_user(prompt=prompt)
     

   在 ask_user_async 中，向用户发送问题，并调用 _poll_updates 来等待他们的回答。ask_user 方法是对 ask_user_async 的同步封装。

这些方法在 Telegram 互动中起着至关重要的作用，使 Auto-GPT 能够通过 Telegram 机器人与用户进行交流。这个过程结构合理，确保插件能够处理在互动过程中可能出现的各种情况。

迄今为止讨论的方法和代码片段为将 Auto-GPT 与 Telegram 机器人集成提供了一个全面的框架。telegram_chat.py 文件封装了 Telegram 特定的逻辑，而 __init__.py 文件则通过 TelegramUtils 类处理与 Auto-GPT 的互动。

现在，让我们深入探讨一些可能需要额外解释的代码段：

• 在 _send_message 方法中，有一段代码专门处理超过 2,000 个字符的消息：

      if len(message) > 2000:
          message_chunks = [
              message[i : i + 2000] for i in range(0, 
                  len(message), 2000)
          ]
          for message_chunk in message_chunks:
              await bot.send_message(
                  chat_id=recipient_chat_id,
                  text=message_chunk)
      else:
          await bot.send_message(
              chat_id=recipient_chat_id, text=message)
  

  这一部分确保如果消息长度超过 2,000 个字符，消息会被分割成每段 2,000 个字符的块，并将每一块作为独立的消息发送到 Telegram。这对于确保消息在 Telegram 中发送时的完整性至关重要，因为 Telegram 对单条消息的最大长度有限制。

• 在 ask_user 方法中，有处理 TimedOut 异常的逻辑，通过重新尝试调用 ask_user 方法：

  except TimedOut:
      print("Telegram timeout error, trying again...")
      return self.ask_user(prompt=prompt)
  

  这是处理超时的强健方式，确保插件会一直重试请求用户输入，直到成功为止。

• 异步处理：代码中的多个部分使用了异步编程原理，以确保操作不会阻塞，如以下所示：

  async def _send_message(self, message):
      # ...
      await bot.send_message(chat_id=recipient_chat_id, 
          text=message)
  

  使用异步方法，如 await bot.send_message(...)，确保 I/O 密集型操作不会阻塞程序的执行，从而使插件更具响应性和性能。

• 错误处理：在整个代码中，使用异常处理来捕获并优雅地处理错误，确保任何问题都会被记录并得到恰当的处理：

  except Exception as e:
      print(f"Error while polling updates: {e}")
  

  这种方法促进了插件操作的健壮性和错误恢复能力。

  代码的逐步讲解已涵盖了 Telegram 插件在 Auto-GPT 中操作的基本方面，从初始化到用户交互和错误处理。然而，仍然有一些细微的元素和潜在的增强功能可以考虑，以优化或扩展插件的功能。以下是一些额外的要点和建议：

• is_authorized_user 方法，它在 _poll_updates 中被调用。实现授权检查至关重要，以确保机器人仅响应授权用户的消息：

      def is_authorized_user(self, update):
          # authorization check based on user ID or username
          return update.effective_user.id == int(self.chat_id)
  

• get_bot 方法提到了为机器人设置命令，但提供的代码片段中没有显示 set_commands 方法。建议实现命令处理，以便为用户提供如何与机器人互动的指南：

      async def set_commands(self, bot):
          await bot.set_my_commands(
              [
                  ("start", "Start Auto-GPT"),
                  ("stop", "Stop Auto-GPT"),
                  ("help", "Show help"),
                  ("yes", "Confirm"),
                  ("no", "Deny"),
                  ("auto", "Let an Agent decide"),
              ]
          )
  

  当然，我们还需要修改 ask_user 方法来处理命令，但这只是如何实现命令处理的一个基本示例：

        async def ask_user_async(self, prompt):
          global response_queue
          # only display confirm if the prompt doesn't have the string ""Continue (y/n):"" inside
          if "Continue (y/n):" in prompt or "Waiting for your response..." in prompt:
              question = (
                  (
                  prompt
                  + " \n Confirm: /yes     Decline: /no \n Or type your answer. \n or press /auto to let an Agent decide."
              )
              )
          elif "I want Auto-GPT to:" in prompt:
              question = prompt
          else:
              question = (
                  (
                  prompt + " \n Type your answer or press /auto to let an Agent decide."
              )
              )
          response_queue = ""
          # await delete_old_messages()
          print("Asking user: " + question)
          await self._send_message(message=question)
          await self._send_message(message=question)
          print("Waiting for response on Telegram chat...")
          await self._poll_updates()
          if response_queue == "/start":
              response_queue = await self.ask_user(
                  self,
                  prompt="I am already here... \n Please use /stop to stop me first.",
              )
          if response_queue == "/help":
              response_queue = await self.ask_user(
                  self,
                  prompt="You can use /stop to stop me \n and /start to start me again.",
              )
          if response_queue == "/auto":
              return "s"
          if response_queue == "/stop":
              await self._send_message("Stopping Auto-GPT now!")
              await self._send_message("Stopping Auto-GPT now!")
              exit(0)
          elif response_queue == "/yes":
              response_text = "yes"
              response_queue = "yes"
          elif response_queue == "/no":
              response_text = "no"
              response_queue = "no"
          if response_queue.capitalize() in [
              "Yes",
              "Okay",
              "Ok",
              "Sure",
              "Yeah",
              "Yup",
              "Yep",
          ]:
              response_text = "y"
          elif response_queue.capitalize() in ["No", "Nope", 
              "Nah", "N"]:
              response_text = "n"
          else:
              response_text = response_queue
          print("Response received from Telegram: " 
              + response_text)
          return response_text
  

• 日志记录：引入一个日志框架，而不是使用打印语句，将提供一种更健壮和可配置的方式来记录消息和错误。我最初尝试使用 Auto-GPT 内置的日志记录功能，但将 Auto-GPT 的代码导入插件导致了一些问题，因此我决定改用 Python 的内置日志模块：

  import logging
  logging.basicConfig(level=logging.INFO)
  logger = logging.getLogger(__name__)
  

  以下是其使用示例：

  logger.info("Information message")
  logger.error("Error message")
  

• 环境变量管理：代码直接获取 Telegram API 密钥和聊天 ID。管理这类敏感信息时，使用环境变量是一个好习惯，以确保这些信息不会硬编码在代码中：

  import os
  TELEGRAM_API_KEY = os.getenv("TELEGRAM_API_KEY")
  TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
  

• 代码模块化和可重用性：将代码进一步模块化，分离关注点，并使其更易于维护和扩展可能会带来好处。例如，Telegram 交互逻辑可以封装到一个单独的模块或类中，从而使代码更加有序且可重用。

• 单元测试：为插件添加单元测试以验证其功能，对于确保插件的可靠性和维护的便利性至关重要，尤其是在对代码库进行更改或更新时。

• 文档编写：确保代码有良好的文档，包括注释解释方法和复杂代码段的功能，将使其他人更容易理解、使用并可能为插件贡献代码。

通过考虑这些额外的要点和建议，开发人员可以增强 Telegram 插件的功能，使其更加健壮、用户友好且易于维护。此外，跟随此指南的读者和开发人员将对构建和完善 Auto-GPT 插件时需要考虑的事项有更全面的理解。

到目前为止的讨论已经全面概述了 Auto-GPT 的 Telegram 插件，涵盖了核心功能、错误处理、异步编程以及一些进一步完善插件的额外注意事项。在此步骤的结尾，我们可以总结一些关键要点，并建议读者或开发者在使用或构建该插件时采取进一步的步骤。

以下是关键要点的总结：

• __init__.py 和 telegram_chat.py

  __init__.py 是 Auto-GPT 与插件交互的入口点，而 telegram_chat.py 封装了与 Telegram 相关的具体逻辑。

• 两个文件中的 __init__ 方法对于初始化和配置插件至关重要，包括设置 Telegram 机器人凭据。

• user_input，report，ask_user 和 send_message

• asyncio 库支持非阻塞 IO 操作，提高插件的响应性和性能。

• 错误处理：代码中采用异常处理来捕获和记录错误，使插件更稳健、可靠。

让我们现在看看可以采取的进一步步骤：

• 探索 GitHub 仓库：鼓励你探索 GitHub 仓库（github.com/Significant-Gravitas/Auto-GPT-Plugins/tree/master/src/autogpt_plugins/telegram），获取插件的最新版本，并了解代码中所做的任何更新或修改。

• 为项目做贡献：有意贡献的开发者可以分叉代码库，进行自己的改进或新增功能，并提交拉取请求。这种协作方式有助于随着时间的推移不断改进插件。

• 实施建议的改进：实施如授权检查、命令处理、日志记录、环境变量管理、代码模块化、单元测试和文档等建议的改进，可以显著提高插件的功能性和可维护性。

• 实验与定制：鼓励开发者实验插件，定制插件以满足他们的特定需求，甚至将其扩展以融入更多功能或集成。

• 学习与分享：与社区互动，从他人那里学习，并分享知识和经验对每个参与者都有益。

本文旨在提供对 Auto-GPT 的 Telegram 插件的透彻理解，并为开发者以及希望深入了解 Auto-GPT 插件开发的读者提供基础。通过探索、实验和合作，社区可以继续构建和改进该插件及其他插件，增强 Auto-GPT 的能力和应用。

总结

通过解析__init__.py和telegram_chat.py文件中的各种方法和逻辑，你将对 Telegram 插件的结构和工作原理有一个透彻的了解。这一分步分析阐明了 Auto-GPT 如何与 Telegram 进行通信、处理用户输入并将消息或报告发送回用户。

这个插件的完整代码以及可能的更新或修改可以在github.com/Significant-Gravitas/Auto-GPT-Plugins/tree/master/src/autogpt_plugins/telegram找到。这个代码库是那些希望深入探索插件或根据自己需求进行调整的人的极好资源。

在本章中，我们简要介绍了 Auto-GPT 中的插件。我们概述了插件的基本概念、不同类型的插件及其应用场景、如何有效使用插件，以及构建插件的过程。通过利用插件，你可以扩展 Auto-GPT 的功能，将其定制为特定任务或领域，并提升其在各种应用中的表现。

在下一章，我们将深入探讨一些实际示例和案例研究，展示插件在现实场景中的强大功能。如果你有任何具体需求或修改建议，欢迎告诉我！

第五章：通过将 Auto-GPT 应用到你的项目中，探索用例和自定义

在上一章，我们学习了插件以及如何自定义插件。

基于这个基础，本章转向实际应用，指导你如何将 Auto-GPT 集成到你的项目中。

在这一章，我们将通过理解以下主题来学习如何将 Auto-GPT 应用到我们的项目中：

• 设置聊天助手

• 注意事项

• 自定义插件的例子——Telegram 插件和 LLM 插件

• 深入探讨——LLM 插件的世界

• 聊天的自定义角色和个性

设置聊天助手

就像每个用户都有自己的偏好和需求一样，我也是如此。

这就是为什么我创建了一个 Telegram 插件，允许我通过 Telegram 与我的 AI 助手进行聊天。

我制作了两个版本：官方版本，可以在 Auto-GPT 插件库中找到，另一个是自定义版本，具有更多个性化的触感。

官方版本可以在 Auto-GPT 插件库中找到，并通过将仓库克隆到plugins文件夹并在config文件中激活来安装。其余的设置会由插件自动完成。

另一个我称之为 Sophie（为了增加个性化的触感），可以在我的 GitHub 上找到，并通过克隆仓库并在config文件中激活来安装。如果 Sophie 插件在官方库中不可用，它将保留在我的仓库分支中，地址是github.com/Wladastic/Auto-GPT-Plugins。

它是 Auto-GPT 的命令扩展，可以让插件直接通过 Telegram 与用户聊天（或者让任何插件通过他们实现的聊天消息服务进行聊天），并允许它保存旧的对话记录，Auto-GPT 可以通过一个命令直接获取对话总结和最近几条消息。

由于 Auto-GPT 是一个开源项目，并且随着社区的发展不断进化，我相信未来会有更多的插件可供使用，这将使你能够进一步定制你的 AI 助手，这也是我现在专注于自己插件的原因，因为我可以对其有很好的控制，并确保你作为读者也能够使用它。

研究助手

另一个可以利用 Auto-GPT 的例子是作为研究助手。

这可能会派上用场，使得研究变得更加容易，例如当你需要记住某些东西或寻找某些内容时，而你没有时间或耐心去通过 Google 搜索。这时，自动化来为你处理这些任务可能会非常有用。

通过使用 Auto-GPT 的研究助手插件，你可以输入一个研究查询，Auto-GPT 会进行搜索并给出总结。

例如，你可以输入韩国的平均 GDP 是多少？，Auto-GPT 会进行搜索并提供最相关的结果。

语音助手

另一个潜在的用例是使用 Auto-GPT 作为语音助手。如果您没有时间或精力在网上查找信息，或者只是感到懒得查找，这可能会很实用。

当使用 Auto-GPT 作为语音助手时，您可以通过语音输入查询，Auto-GPT 将进行搜索并为您提供最相关的结果。例如，您可以问韩国的 GDP 是多少？，Auto-GPT 会找到并为您提供最相关的结果。

聊天的自定义角色和个性

最后，Auto-GPT 还可以用于创建自定义角色和个性，这些角色可以出现在您的聊天对话中。如果您希望创建一个更具亲和力且更具对话性的聊天机器人，这可能会很有用。为此，Auto-GPT 可以用来创建自定义的聊天机器人个性和定制的对话风格，且保持相同的外观和感觉。

例如，对话的外观和感觉可能像科幻电影或小说中的情节。角色还可以拥有自定义的情感或独特的回应风格。

所有这些都可以直接在 Auto-GPT 的config文件中的聊天机器人部分或插件中完成。这将为您提供自定义角色和个性的选择，为您的项目增添个性化的色彩。

需要注意的事项

在使用 Auto-GPT 进行定制时，重要的是要注意可能容易被忽视的功能。例如，在创建聊天机器人时，要注意像忘记之前对话内容或无法理解用户命令等功能。此外，在创建自定义角色或个性时，还需注意像情感和对话模式等可能显得不自然的功能。这对于确保用户与聊天机器人之间的对话自然流畅尤为重要。

总体来说，当使用 Auto-GPT 定制一个项目时，最好考虑所有功能和潜在问题，以确保用户在使用您的项目时获得完美的体验。

然而，仅仅依赖基本功能是不够的，更不用说它会显得无聊，我们来探索一下其他选择。

定制示例——Telegram 插件和 LLM 插件

使用 Auto-GPT 进行自定义的一些示例包括 Telegram 插件、LLM 插件（稍后在章节中解释）以及聊天的自定义角色和个性。

Telegram 插件允许用户通过 Telegram 直接与他们的 AI 助手聊天，而 LLM 插件则允许用户自定义 AI 助手的语言、学习模型和记忆。

聊天的自定义角色和个性使用户能够创建具有相同外观和感觉的个性和对话模式。这可以直接在 Auto-GPT 的config文件中的聊天机器人部分或插件中完成。

这些只是 Auto-GPT 中众多潜在定制化选项的一部分。由于 Auto-GPT 是一个开源项目，可能性是无限的——这完全取决于你想要实现什么，以及如何定制你的项目。

AI 驱动的应用程序的广阔领域突显了定制化需求，Auto-GPT 应运而生，提供了丰富的定制途径。在众多插件和功能中，Telegram 插件、LLM 插件和自定义聊天个性是可实现的卓越示例。

其中一个就是我的 Telegram 插件，在 Auto-GPT 的最新版本中，已将其集成到基础代码中。

Telegram 插件——架起对话桥梁

Telegram 提供了无缝的集成。Telegram 插件象征着消息平台与 AI 之间的无缝融合。这种集成将无处不在的消息应用 Telegram 转变为与 AI 助手进行实时智能对话的桥梁。想象一下，在你的 Telegram 聊天中，拥有一个集研究员、顾问、娱乐者和助手于一身的口袋助手。

在后台，Telegram 插件使用 Telegram 和 Auto-GPT 的强大 API。一旦在 Auto-GPT 配置中激活，它会监听 Telegram 上接收到的消息，实时通过 Auto-GPT 处理，并返回 AI 生成的回应，促进动态对话。

它具有以下优势：

• 普及性：Telegram 在多个设备上可用，你的 AI 助手始终触手可及。

• 安全性：Telegram 的端到端加密确保了对话的私密性。

• 多媒体功能：利用 Telegram 的多媒体特性，使 AI 能够处理和回应图像、语音消息等。

• LLM 插件：定制智能思维

语言不仅仅是交流的工具；它是由文化细微差别、历史背景和不断发展的语义编织而成的复杂织锦。Auto-GPT 凭借其创新能力，认识到这种复杂性，并提供语言学习模型（LLMs），帮助我们在这片广阔的语言领域中导航。

什么是 LLMs？

从根本上说，LLMs 构成了 Auto-GPT 语言能力的核心。它们作为 AI 的神经框架，决定了其理解、学习机制以及在不同语言和背景下的响应模式。可以把 LLMs 看作 Auto-GPT 背后的复杂“脑”，精妙地处理语言的细节。

虽然基础的 AI 模型可能只是逐字翻译语言，但 LLMs 会深入挖掘。它们能够捕捉习惯用语、俚语和文化细微差别，确保 AI 的互动保持真实且符合上下文。

LLMs 不是静态的；它们在不断进化。随着处理更多数据，它们会细化理解，适应语言的变化，并提升其熟练度，展现出语言的流动特性。

现在我们已经了解了 LLM 的基本概念，我们可以看看我们正在使用的默认 LLM，并问问自己：如果外面有成千上万的工具，为什么我们只使用一个呢？

让我们来回答这个问题。

深入探讨 – LLM 插件的世界

虽然基础的 LLM 提供广泛的语言能力，但真正的魔力在于定制化。LLM 插件作为专业化扩展，允许用户根据精确需求调整 Auto-GPT 的语言能力。

无限的可能性

无论你是一个希望在地方方言中提供客户支持的企业，还是一个希望从小众语言数据集中获得见解的研究人员，或是一个想要用多种语言编写故事的讲述者，LLM 插件都能提供实现这些愿景的工具。

LLM 插件的关键功能

虽然大多数功能可以由默认的 OpenAI GPT 模型完成，但有些功能由定制 LLM 更加适合。要使用这些功能，我们需要修改 Auto-GPT 或通过插件添加它们。

全球与地方

在日益全球化的世界中，沟通已经超越了国界。LLM 插件使 Auto-GPT 不仅能用广泛使用的语言交流，还能用地方方言和冷门语言进行对话。

通过支持多种语言，LLM 插件确保 AI 工具的互动依然真实，尊重文化差异，并且避免使用过于泛泛的翻译。

领域专长 – 随时掌握的能力

语言是广泛的，但能力往往体现在特定领域。无论你是关注量子物理的技术术语、法律的复杂术语，还是文学的微妙语言，LLM 插件都可以定制以掌握特定领域。

现实世界的影响

想象一下，一家医疗科技初创公司利用专注于医学术语的 LLM 插件，简化了与患者的准确互动，或者一家法律事务所使用增强型 LLM AI 来筛选案例法，提取相关见解。

内存管理 – 平衡回忆与隐私

就像人类一样，AI 的效果依赖于其记忆。然而，尽管回忆对于上下文至关重要，但隐私是首要的。LLM 插件实现了这一平衡，让用户定义 AI 如何保留或遗忘互动记录。

例如，在客户支持场景中，保持过去互动的上下文可以促进连续性，但在互动后清除个人数据对用户信任和遵守数据保护法规至关重要。

虽然 GPT 非常强大，但它缺乏定制性，除非我们愿意等待并相信 OpenAI 会改进其模型，并且变得足够可靠，能够让我们安全地使用它们。我们也可以选择将其他 LLM 作为核心，甚至可能是更好的选择。

LLM 插件的未来

随着人工智能和语言学的交汇，LLM 插件的潜力是无限的。通过持续的研究、社区贡献和实际反馈，这些插件将不断重新定义 AI 驱动的语言交互中可实现的边界。

Auto-GPT 的开源精神确保 LLM 插件受益于全球智慧。来自不同语言和文化背景的开发者为这个生态系统做出贡献，丰富了 LLM，带来了他们独特的视角。

在一个沟通至关重要的时代，LLM 插件犹如哨兵，确保语言在其丰富性和多样性中得到庆祝、理解并有效使用。

重新定义交互

不仅仅是实用性，设计 AI 交互本身也是一种艺术。在 Auto-GPT 中，你不仅是在配置一个聊天机器人；你是在赋予一个数字实体生命，定义其个性、举止和对话风格。

创建过程

无论你想要一个拥有奥斯卡·王尔德机智、孔子智慧或奥普拉·温弗瑞魅力的聊天机器人，Auto-GPT 的定制功能都能使这一切成为可能。深入配置文件，调整对话模式，设置情感反应，打造独特的数字化人格。

应用

以下是 LLM 插件的一些应用：

• 客户支持：设计富有同理心的聊天机器人，与用户产生共鸣，提供带有人情味的支持

• 娱乐：为互动故事或角色扮演游戏创造虚构角色

• 教育：创造适应不同学习风格和科目的辅导员人格

释放潜力——开源优势

Auto-GPT 的开源性质是其王牌。它不仅使人工智能得以民主化，还培养了一个充满活力的开发者、研究人员和爱好者社区。这个集体智慧不断拓展可能性的边界。

社区优势

由于全球社区为其生态系统做出贡献，Auto-GPT 从多元的视角、新颖的想法和创新的解决方案中获得帮助。这确保了平台保持动态，不断随着新兴需求和趋势发展。

你的画布

在你踏上定制之旅时，请记住，Auto-GPT 就像一张画布。它提供了工具和调色板，而你创作的杰作仅受限于你的想象力。然而，请记住，你的目标越复杂，你为实现目标所付出的努力也将越大。

对于我们的多数任务，我们需要记忆功能，否则 Auto-GPT 会变得非常健忘。因此，我们还需要嵌入技术，以使尽可能多的数据能够被访问。

自定义嵌入和记忆插件——Auto-GPT 的进化特性

Auto-GPT 的架构是有远见的，超越了传统 AI 模型。它的革命性设计选择之一是将 GPT 视为基础插件，而不是一个单一的核心。这样的设计哲学确保了虽然 GPT 提供了一个坚实的起点，但它只是其中的一部分，可以被替换或增强。这种模块化的方法使 Auto-GPT 能够适应未来的进展，确保其始终保持适应性、可扩展性和持续的相关性。本节深入探讨了模块化的两个关键维度：自定义嵌入插件和自定义记忆插件。

在讨论完嵌入这个话题后，我们可以稍微了解一下 Auto-GPT 的基础部分，也就是我们用作思维核心的 LLM。尽管 OpenAI 的 GPT-4 目前是主流的 LLM，Auto-GPT 提供了一些非常用户友好的理念。

将 GPT 作为基础插件 —— 启发灵感的第一块基石

没有什么比迈出自定义的第一步更能展示开放性了。由于 Auto-GPT 本身被设计得尽可能模块化，因此决定将 Auto-GPT 提供的许多功能视为模块，甚至插件。没有 LLM，Auto-GPT 只不过是一个无法自行决定任何事情的仆人。基于这一点，OpenAI 的生成预训练变换器（GPT）就是基础插件。

传统的 AI 模型设计采用静态架构，其中核心组件一旦集成就保持不变。Auto-GPT 挑战了这一常规。通过将 GPT 视为基础插件，它为无尽的自定义和改进奠定了基础。

将 Auto-GPT 想象成一个动态的马赛克，每一块瓷砖（或插件）都为整体画面做出贡献。GPT 瓷砖，虽然重要，但仅仅是众多瓷砖中的一块。它可以被替换、精炼，或通过其他瓷砖来补充，以创造新的模式和功能。

这种方法确保了 Auto-GPT 不会受到任何特定模型或技术的局限。随着 AI 的进步，可以无缝集成更新、更先进的模型，确保 Auto-GPT 始终处于技术发展的前沿。

自定义嵌入插件 —— 精炼 AI 的语言

在自然语言处理（NLP）领域，嵌入类似于语言的 DNA。它们将单词和短语转化为数值向量，捕捉语义细微差别、关系和上下文含义。

为什么要使用自定义嵌入？

虽然 GPT 提供了一个全面的嵌入机制，但特定的应用可能需要细致的语言表现。无论是捕捉地方方言的细微差别、特定领域的术语，还是不断变化的网络语言，自定义嵌入插件都为定制这些表现提供了工具。

我们有三个这样的自定义嵌入：

• 领域特定的嵌入：想象一下，一家制药公司致力于确保正确的药物命名。可以设计一个自定义嵌入来理解大量的药物名称、它们的变体及其关系，确保 AI 互动的精准性。

• 文化与区域嵌入：对于全球品牌来说，嵌入可以根据不同地区的习语、俚语和文化背景进行定制，以便更好地与多样化的受众产生共鸣。

• 演变的嵌入：语言是流动的，并且不断发展。可以设计动态的自定义嵌入插件，以适应语言的变化，并实时纳入新的术语和短语。

自定义记忆插件——回忆与遗忘的艺术

Auto-GPT 的主要功能之一就是记忆。如果我们不给它任何记忆，它不过是一个可以执行额外操作的 ChatGPT 克隆。

AI 中的记忆作用

人工智能中的记忆反映了其对人类认知的重要性。它决定了 AI 如何回忆过去的互动，从中学习，并利用这些信息做出未来的决策。

为什么选择自定义记忆？

虽然 GPT 提供了强大的记忆机制，但并没有一种适用于所有的解决方案。不同的应用程序对记忆的需求不同。有些需要长期的记忆以保持连续性，而其他的则优先考虑短期记忆以确保隐私。

制作自定义记忆机制

一次性机制，我们将所有记忆收集起来并交给 LLM，这种方法容易实现，但可能会引入大量新的上下文，这些上下文并不一定对当前 Auto-GPT 工作中的上下文有所帮助。例如，在你询问当前时间时，告诉它你和它一起完成的一个编程项目显然是多此一举。

自适应记忆保留

以客户支持聊天机器人为例。它需要回忆过去的互动以确保连续性，但也必须在互动后忘记个人数据以确保隐私。自定义记忆插件可以在此之间找到平衡，根据信息的上下文调整记忆的保留。

学习与遗忘

在股票市场和医疗保健等动态领域，过时的信息可能会造成严重后果，因此可以设计自定义记忆插件，定期“遗忘”过时的知识，确保 AI 的洞察力始终保持最新。

上下文记忆

对于像讲故事和角色扮演游戏等应用，记忆插件可以设计为记住情节、角色发展和用户选择，确保连续性和沉浸感。

总结——定制化的无限可能

Auto-GPT 以其模块化的基础理念打开了无限可能的世界。将 GPT 作为基础插件，并提供自定义嵌入和记忆插件的路径，确保 AI 开发者和创新者仅受限于他们的想象力。随着 AI 领域的不断发展，Auto-GPT 准备好适应、进化并引领，提供不仅在技术上先进，而且在定制性上极具潜力的工具。

这次对自定义嵌入和记忆插件的探索突显了 Auto-GPT 对灵活性、适应性和前瞻性设计的承诺，确保它在不断发展的 AI 领域中始终保持领先地位。

自定义聊天角色和个性

使用 Auto-GPT 创建自定义角色和个性是为你的项目增添个性化色彩的绝佳方式。要创建一个自定义角色，你需要思考个性和对话模式。你还应考虑这个角色应该具有什么样的情感和情绪，以便与用户进行自然的对话。

你还需要考虑角色的设计，因为这将帮助你为对话创建更加一致的外观和感觉。

最后，你还需要考虑角色如何对不同的命令和情境作出反应。这将帮助确保用户能够与角色进行愉快且自然的对话。

总体而言，借助 Auto-GPT，你可以定制任何你能想到的——一切取决于你。

总结

在这一章中，我们学习了如何将 Auto-GPT 应用于我们的项目，并且如何定制角色，以获得更好的用户体验。

我们学习了如何使用 Auto-GPT 设置一个 AI 聊天助手和研究助手，以及如何将其用作语音助手。我们还讨论了创建自定义角色的重要性，以便创建更自然的对话。

最后，我们了解了在用 Auto-GPT 定制项目时需要注意的事项，并回顾了一些可以进行的自定义示例。

总的来说，Auto-GPT 提供了大量的定制选项，并且可以用来创建许多独特的项目。凭借其开源特性，可能性几乎是无限的，它是适用于各种项目的强大工具。

在下一章中，我们将探索 Docker 中的高级设置，这些设置超出了现有 Docker 镜像运行的范围，虽然这些操作可能更简单，但我们在谈论定制时，这些是必不可少的。

第六章：使用 Docker 和高级设置为企业级项目扩展 Auto-GPT

在 第二章**, 我们介绍了如何使用 Docker 启动 Auto-GPT；现在，我们将深入探讨 Docker 的使用。

Docker 已成为软件开发领域的一个动态工具，特别是在管理和分发复杂应用程序（如 Auto-GPT）方面。因此，本章旨在为您提供有关 Auto-GPT 如何利用 Docker 的全面了解。使用 Docker 可以确保我们始终保持同步。此外，您可以阅读几个案例，比如我报告的这个 GitHub 问题，其中我的 Auto-GPT Agent 通过自身发现的漏洞突破了自己的边界，问题编号为 github.com/Significant-Gravitas/AutoGPT/issues/666。

我们还将探讨 Auto-GPT 中连续模式的功能，并讨论其影响。Auto-GPT 的强大之处不仅在于它生成创造性且连贯的内容的能力，还在于它独立运作的能力。

本章还将深入探讨 Auto-GPT 的一个关键功能：连续模式。我们将探索它是什么、它的潜在应用以及使用时需要注意的事项。

Auto-GPT 的连续模式允许程序在每个步骤无需用户确认的情况下运行。这意味着它可以独立生成内容、执行任务，甚至做出决策。这个功能对于自动化那些本来需要不断人工干预的任务尤为有用。然而，正如任何强大工具一样，使用时必须负责任。

本章涵盖以下主题：

• Auto-GPT 如何利用 Docker 的概述

• 修复潜在的漏洞或错误

• 示例运行脚本

• 什么是连续模式？

• 已知的连续模式使用案例

• 安全措施和最佳实践

• 潜在风险及其缓解措施

• 优雅地停止一个连续的过程

Auto-GPT 如何利用 Docker 的概述

Docker 基于容器化原则运行——这是一种高效且隔离的方式来安全地运行应用程序。可以将这些容器视为自给自足的单元，包含运行应用所需的所有组件。Auto-GPT 与 Docker 的集成使得用户能够跳过手动设置环境的繁琐过程，将 Auto-GPT 的焦点转向定制 AI 体验。

本质上，Docker 封装了 Auto-GPT 的计算环境。Auto-GPT 的 Docker 容器包括 Python 环境、必要的库以及应用程序本身。位于 Auto-GPT 根目录中的 Dockerfile 包含了 Docker 用来构建此镜像的指令。

它的工作原理是，Docker 创建了一个隔离的环境，或者说是一个容器，Auto-GPT 就在这个容器里运行。Auto-GPT 与系统之间的每一次交互都会通过 Docker，Docker 会解释这些交互并确保它们是安全的，且与容器内的环境兼容。隔离性也意味着，如果容器内发生任何问题，你的系统不会受到影响。

这个 Dockerfile 通常只包含几个命令，例如需要加载哪个环境，在 Auto-GPT 的情况下，就是在 poetry 上加载 python:3.10-slim。

现在让我们来看看这个集成是如何工作的。

理解 Auto-GPT 与 Docker 的集成

Docker 与 Auto-GPT 的集成带来了几个优势。封装性确保每个用户体验完全相同的计算环境，从而减少了由于操作系统或 Python 发行版不同而可能产生的差异。这种封装性还允许无缝共享和轻松的版本控制，并且消除了它在我的 机器 上能运行的问题！

Auto-GPT 之前有一个包含 SQLite 的内存数据库，用于存储先前运行的操作和消息。2023 年初，内存数据库第一次通过一些向量数据库解决方案进行了扩展，但到 2023 年中期被完全放弃，因为其中一些解决方案无法与大多数用户兼容。从那时起，除了本地保存到文件外，未再实现任何其他向量数据库或内存方案，因为支持过多的解决方案工作量太大了。相反，内存保存在本地的 JSON 文件中，其位置可能在每个 Auto-GPT 版本中有所不同。使用 Docker 是这一过程中必须的一步，尽管当时许多用户（包括我）抱怨 Auto-GPT 对本地运行实例的支持不够好。幸运的是，后来情况发生了变化，内存系统现在又变回了一个非常基础的 JSON 文件，这总比没有好。

在深入探讨为什么 Auto-GPT 支持 Docker 后，我们现在可以继续了解如何启动 Auto-GPT Docker 实例了。

启动 Docker 实例

虽然这听起来可能很复杂，但运行 Docker 容器实际上非常简单。首先，如果你还没有安装 Docker，需要确保你的系统上已经安装了 Docker。有许多指南可以帮助你完成这个过程，例如 Docker 官方的安装说明（docs.docker.com/get-docker/），它可以引导你完成 Windows、MacOS 和各种 Linux 发行版的安装过程。

要在 Docker 容器中运行 Auto-GPT 实例，首先需要使用 Dockerfile 构建 Docker 镜像。这里是一个简要的概述：

1. 切换到包含 Dockerfile 的目录（它应该是 Auto-GPT 的根目录）：cd path/to/Auto-GPT。

2. 使用 docker build -t auto-gpt . 构建 Docker 镜像。（确保命令以空格和点结束；点可能不明显）。

   启动实例的简单方法是执行以下命令：

   docker compose run --rm auto-gpt --gpt3only --continuous
   

3. 如果你敢的话，你也可以使用纯粹的 Docker 命令来构建和运行它：

   docker build -t auto-gpt .
   docker run -it --env-file=.env -v $PWD:/app auto-gpt
   docker run -it --env-file=.env -v $PWD:/app --rm auto-gpt --gpt3only --continuous
   

如果你按照所有步骤正确操作，应该会看到 Auto-GPT 的聊天输入界面。如果没有，我们将一起排查常见的不能工作的原因。此外，你也可以参考前面提到的 Docker 文档，如果功能有所变化。

尽管 Docker 通常很容易安装并直接使用，但我们仍然可能遇到一些问题。

修复潜在的漏洞或 bug

要在 PC 上使用 Docker，必须确保启用了虚拟化。

在 macOS 上，你无需更改任何设置。虚拟化已经在该系统上工作；你只需要下载并安装 Docker Desktop。

由于每个主板厂商的 BIOS 设置不同，激活方式可能有所不同，但通常你需要通过重启电脑并按下显示的Setup/BIOS 按钮进入 BIOS。对我来说是 F2 或 DEL。如果没有显示按钮，你需要做一些研究。

根据你的 CPU 厂商，设置可能不太明显。例如，Intel 有一个名为Intel 虚拟化技术的设置，而 AMD 有AMD-V。一旦找到它，确保启用它并保存更改。

需要提到的是，使用 Docker 时，有时会遇到一些在开始时并不明显的 bug 或问题。一个例子就是臭名昭著的docker system prune命令。

尽管 Docker 有很多优点，但也不是没有潜在的挑战。一个常见的问题是内存分配不足。当你启动 Docker 时，它会保留一定量的内存，如果内存耗尽，可能会导致意外的行为或崩溃。为了解决这个问题，可以尝试在 Docker 设置中增加内存分配。

另一个常见的问题是 Docker 无法启动容器，因为它声称所选的端口已经被占用。即使你确信该端口没有被占用，某个行为不当的应用程序可能也在悄悄地绑定到这个端口。在这种情况下，重新启动系统或手动终止占用端口的进程可能会有所帮助。

我个人推荐在 Windows 和 Mac 上使用 Docker Desktop 应用，或者在 Linux 上使用 Portainer。这是一个基于 Web 的 Docker 管理应用，其功能与官方应用一样强大。

你可以通过执行以下命令来安装和运行它：

1. 首先，创建 Portainer Server 用来存储其数据库的卷：

   docker volume create portainer_data
   

2. 然后，下载并安装 Portainer Server 容器。请记住，所有内容应该写在同一行上：

   localhost:8000 or https://localhost:9443; your username is admin.If no password was displayed in the console, you will be asked to set a new password at this stage.
   

Docker 在构建过程中还会创建中间镜像。这些镜像可能会占用大量磁盘空间。通过运行 docker system df 检查你的 Docker 系统，并使用 docker system prune 命令清理不需要的镜像。

有时，并不是项目本身的问题；有时，我们使用的软件可能会遇到一些问题。Docker 被广泛使用，但也可能导致一些问题。

识别并修复与 Docker 相关的潜在问题。

与 Auto-GPT 一起使用 Docker 可以是一次有益的体验，但像所有技术集成一样，它也伴随着一系列挑战。

这是解决这些挑战的深入指南：

• Docker 守护进程未运行：

  • 使用 sudo systemctl start docker 来启动 Docker 服务。

  • Applications 文件夹。如果 Docker 正常运行，你将在顶部菜单栏看到 Docker 鲸鱼图标。

• 缺少 Auto-GPT 包或模块：

  • cd /app/。

  • requirements.txt 文件列出了所有必要的包。使用 pip 来安装这些依赖：

  • python -m pip install -r requirements.txt。

  • 此命令将确保在容器环境中安装 requirements.txt 文件中列出的所有包。如果知道缺少其他模块或包，你也可以单独使用 pip 安装它们。

  • exit。

  • 请记住，Docker 容器是隔离的环境。你在容器内所做的任何更改（如安装包）不会影响主机系统。然而，如果容器被删除，这些更改将会丢失。为了保持持久的更改，你可以考虑创建新的 Docker 镜像或使用 Docker 卷。* 内存或磁盘空间不足：Docker 有时可能会占用过多空间，或者可能你的存储空间不足。Docker 可能会直接关闭，但并不会告诉你问题是什么：

  • 使用 docker system prune -a 来删除未使用的数据。注意：这将删除未使用的容器、网络和镜像。务必备份重要数据。

  • 调整资源（Windows/macOS）：打开 Docker Desktop | Settings | Resources 来修改内存或磁盘分配。* 网络问题：有时，Docker 容器的端口转发可能会出现问题。例如，当我们想要打开 Auto-GPT 实例的前端网站时，可能会发现无法访问：

  • 使用 docker port <container_name>，可以检查哪些端口是活动的。

  • 使用 -p 标志，例如 docker run -p 4000:80 <image_name>，将容器端口绑定到主机端口* 版本冲突：

  • 使用 sudo apt-get update && sudo apt-get upgrade docker-ce 或类似命令来更新 Docker。

  • Windows/macOS：Docker Desktop 会通知你有可用更新。确保保持更新。* 对于 Auto-GPT 更新，定期查看官方 Auto-GPT 仓库或文档，以获取最新版本和更新说明。* 容器隔离：

  • -v 用于将主机目录挂载到容器中，例如 docker run -v /host/directory:/container/directory <image_name>

  • 使用 docker network inspect <network_name> 检查网络配置，确保容器正确连接。* 日志与诊断：

  • 使用 docker logs <container_name> 命令将显示容器的日志。这些日志对于诊断问题至关重要。如果发生错误，日志中很可能会有详细信息。

记住，故障排除的关键是耐心和系统化的探索。通过这些详细步骤，当你在使用 Auto-GPT 时，面对大多数与 Docker 相关的挑战，你将能够从容应对。

有时我们遇到的问题可能更为复杂，对于这些问题，我们需要访问 Auto-GPT 所运行的容器。

为了让你了解如何通过 Docker 启动 Auto-GPT，我列出了一些示例。

示例运行脚本

要熟悉运行脚本，可以参考此处列出的脚本：

• 要在 Docker 容器中运行交互式 Shell（有助于调试），请使用以下命令：

  docker run -it --entrypoint /bin/bash auto-gpt
  

  此命令启动 Docker 容器中的交互式 Shell，允许你直接访问并调试 Auto-GPT。

• 要在不同端口上运行 Auto-GPT，可以尝试以下命令：

  -p flag, this command runs Auto-GPT on port 4000 of your host machine, while internally, it listens on port 5000 within the Docker container.
  

• 要将所有流量从端口 80 转发到 Auto-GPT（这需要管理员/sudo权限），请运行以下命令：

  80 on your host machine to be redirected to Auto-GPT running on port 5000 within the Docker container. Note that it requires administrative or sudo privileges.
  

通过使用这些运行脚本，你可以在 Docker 环境中提高使用 Auto-GPT 时的效率和生产力。你可以尝试不同的端口映射或探索交互式 Shell 以进行调试。

随着我们深入，准备好探索 Auto-GPT 连续模式的奇妙世界吧。我们将深入研究其机制，理解它带来的潜在后果和好处，随着章节的展开，我们还将讨论如何整合不同的 LLM 模型、充分利用提示语，等等。与 Auto-GPT 的旅程即将变得更加激动人心！

让我们继续探讨连续模式及其后果。

什么是连续模式？

我们将从解释什么是连续模式开始。它允许 Auto-GPT 在每个步骤无需用户批准的情况下运行，这使得自动化得以在无需持续人工监督的情况下进行。

然后我们将看看一些已知的连续模式使用案例和示例，比如自动化研究任务、内容生成和代码编译。虽然连续模式非常强大，但请注意，由于缺乏人工验证，需要谨慎使用。

接下来，我们将提供一些关于如何安全有效地使用连续模式的提示。这包括在配置中设置明确的目标、约束和限制，以防止不必要的行为。同时，建议监控日志和输出。

此外，我们还将讨论一些潜在的风险，如生成虚假信息、陷入循环以及成本超支。我们将提出一些缓解策略，如杀死开关、使用限制和沙盒化。

最后，我们将解释如何优雅地停止一个连续进程，比如使用键盘中断或task_complete命令。我们还将探讨正在进行的研究，以改进暂停命令和定时接管等功能。

持续模式允许 Auto-GPT 在不需要用户每次确认的情况下自主运行。通过保持核心循环不中断，它使得任务自动化而无需持续的人类监督。然而，使用时需要小心。当谨慎使用并配备适当的安全措施时，持续模式可以提升效率。若使用不当，可能会产生遗憾的后果。找到合适的平衡点需要了解其能力和风险。本章这一部分旨在提供这种全面的视角。

已知的持续模式用例

我个人最喜欢的用例是一个个人助手，它只在需要输入时报告或提问。虽然目前大多数 AI 聊天机器人都是一步一步进行操作的，但我更喜欢让 Auto-GPT 持续运行，我编写了我的 Sophie-Plugin 插件，使得 Auto-GPT 只有在需要报告某些信息时才会发送消息，并且会继续执行（然后它会在消息的末尾加上 ...（只是三个点，我没有添加任何其他符号，因为这可能会造成混淆）），或者它会要求我做出某个决策或提供反馈。

通过这种方式，助手的使用场景更广泛，你还可以给它分配多个任务，并让它在完成后再向你报告，结合其他插件使用，如电子邮件插件、Discord 插件和 SSH 终端插件。你的 AI 甚至能够为你管理沟通，虽然这可能存在风险，但同时也非常酷。Auto-GPT 甚至曾为我谈判过编程项目的竞争性薪资，它在联系公司测试代码时达成了这一目标。顺便提一下，那是 GPT 3.5 版本，还未升级为 Turbo。新的模型似乎不再那么大胆，也不再意识到上下文是什么，这或许可以通过其他 LLM 模型来实现，这些模型被我用于我的 mini-autogpt 项目（github.com/Wladastic/mini_autogpt），在这个项目中，我将多个 LLM 模型排在一起并测试它们的一致性。由于 OpenAI 似乎在尽量减少运行其新 LLM 模型的成本，这些模型已经越来越不确定它们在做什么，要么态度模糊，要么显得重复。此外，它们感觉不像是完全在听你说话，而是坚持之前的说法。

自动化研究与分析

Auto-GPT 持续模式最引人注目的应用之一是研究与分析领域。通过启用持续模式，Auto-GPT 可以不断从多个来源挖掘信息，如学术期刊、新闻源和社交媒体平台。市场研究人员可以利用此功能持续跟踪消费者情绪、新兴趋势和竞争对手策略。这个功能对学术研究也非常有益，因为它可以扫描新发布的论文，并实时将新的见解添加到正在进行的研究中。

精简内容创作

内容创作者和营销部门可以显著受益于 Auto-GPT 的连续模式。AI 可以被编程为扫描流行话题，并生成相关的文章、博客帖子或社交媒体更新，而无需人工干预。此外，由于模型可以生成各种风格和格式的内容，它允许多元化的内容策略。想象一下运行一个新闻网站，AI 会根据全球新兴事件持续更新内容，让人类编辑专注于更复杂的任务，比如调查性报道或评论文章。

超级加速代码编译

开发人员常常发现自己在等待代码编译，这会打断工作流程。Auto-GPT 在连续模式下可以管理这些琐碎的任务。它可以设置为自动编译代码、运行测试用例，甚至将更新推送到代码库。这使得开发过程更加无缝，确保最新的变更始终被集成并测试。通过将常规任务交给 Auto-GPT，开发人员可以专注于解决问题和创新。

持续提供的客户支持

客户支持是 Auto-GPT 连续模式能够带来变革的领域之一。启用此功能后，聊天机器人可以处理无限数量的查询和问题，而无需人工干预。这使得客户支持系统可以 24/7 运作，处理大多数问题，只会将复杂或敏感的事务升级给人工代理。这不仅提高了客户满意度，还大幅降低了与客户服务相关的运营成本。

在开始使用连续模式之前，让我们首先学习一些最佳实践。

安全保障和最佳实践

尽管 Auto-GPT 连续模式的能力令人印象深刻，但部署时需要谨慎。以下是一些你可以采取的措施：

• 启用确认提示：对于可能产生费用或不可逆的命令，启用确认提示。例如，如果你设置了 Auto-GPT 处理电子邮件，可以在发送前向用户发送确认提示，以防止不必要的通信。

• 使用白名单和黑名单：通过使用白名单来限制已批准的操作，黑名单来禁止不被允许的操作，从而限制模型的能力。例如，你可以使用白名单来指定 AI 可以访问哪些外部数据库以获取信息。

• 渐进式资源扩展：从保守的计算和财务限制开始。当你观察到系统的行为和性能时，可以逐渐放宽这些限制。这有助于最小化成本失控或资源过度利用的风险。

• 沙箱测试：在将系统投入生产环境之前，建议在沙箱或隔离的环境中进行测试。这可以让你发现并修复任何 bug 或漏洞，而不会影响实际的运营。

我们已经讨论了确保良好行为的方法。现在，我们可以评估用户提示下的人类监督与一般人类监控之间的关系。

定期监控和人工监督

虽然持续模式旨在尽量减少人工干预，但定期的审查和调整是必要的。监控日志以检测任何异常或不规则行为，并在高风险情况下准备好立即由人工接管。

然而，人类监督依然是不可或缺的。根据反馈调整配置，针对高风险场景建立审批流程，并在不确定时默认由人工接管。

如果你想完全信任 GPT 让它自己做出所有决定，并且有信心它可能会完美运行，那我们就来讨论一下让 GPT 决定所有操作的弊端，并稍微动摇一下你对它的信任。

潜在的风险及其缓解措施

由于 GPT 是我们 Auto-GPT 应用的核心，它迟早会做出一些荒谬的决策。

例如，我让 Auto-GPT 运行了一段时间，指示它为我写一个基于 Web 的浏览器游戏，类型是 RPG，且应该使用Three.js，我得到的是：

• 最初，Auto-GPT 创建了一些空的代码文件，但只在其中添加了 TODOs，表明代码需要完成。

• 然后它写了一些实际的单元测试，可能部分有效，但它变得非常自信，完成了整个项目并进行了测试。接着，它开始搜索 Google，找寻公司来测试这个游戏，甚至给其中一家公司发了一封邮件，谈判价格为每天仅 100 美元，因为我设置的项目预算就是如此。

它写邮件的方式既让人害怕又让人感兴趣。它找到了一个可以运行你输入代码的编程网站，这个网站还允许 URL 参数，这些参数可以接受要执行的代码。Auto-GPT 创建了一个 URL，把它编写的代码作为参数，并向它在 Google 上找到的一家提供廉价 QA 测试的公司发送了邮件。

它还成功接收了公司员工发送的电子邮件，其中包含关于价格的答复，尽管直到今天我仍然不知道它是如何创建该电子邮件帐户的，因为是它创建的一个代理完成了这项操作，而当时他们没有记录自己的操作。

我坐在沙发上，听着 Auto-GPT 的讲话输出。我设置它使用女性声音作为主要代理的声音，其他任何代理则使用男性声音，因此我以为听起来像是办公室里的对话，直到那个男性声音说：“已完成与**的日常价格谈判，正在汇报 任务结束。”

自那时以来，Auto-GPT 发生了变化。它对代理的管理更加严格。当时，代理可以随心所欲地执行任务，直到他们决定任务完成为止。

尽管采取了预防措施，但准备好强制停止操作仍然至关重要。但平衡是关键：避免过早停止长时间运行的任务。

如果我们遇到需要停止 Auto-GPT 继续运行的情况，但又不希望将其破坏，我们将探讨如何避免突然终止它。

优雅地停止一个持续进行的过程

有时，我们可能会看到 Auto-GPT 完全错误地执行任务，或者我们仅仅有感觉它没有执行任何有意义的操作，甚至它可能完全偏离轨道，陷入无休止地研究某个话题而永远无法完成搜索的循环。

例如，当你在日志中看到 Auto-GPT 因重复做同样几项任务而陷入循环时，你可能会想停止它，以防止使用 API 的高额费用。

像 Ctrl + C 这样的快捷键会立即发送取消请求。

确保 Auto-GPT 正在运行的终端处于活动状态，如果不确定，请点击它。

如果这个方法不起作用，例如当 Auto-GPT 正在 思考 或插件正在执行某些操作并忽略键盘中断时，你可以随时使用进程管理工具，如 Windows 任务管理器、Mac OS 活动监视器 或 Linux 上的 htop/top，找到 Auto-GPT 的 Python 进程并手动终止它。

当你的 Auto-GPT 实例在 Docker 上运行且启用了持续模式时，始终确保至少打开 Docker Desktop 应用程序，这样如果你看到它执行了意外的操作且没有响应 Ctrl + C，你可以关闭 Auto-GPT 的 Docker 容器。

如果你不在电脑旁，仅通过 Telegram 或 Discord 与 Auto-GPT 进行通信，请确保有一个始终有效的保障措施，以防止 Auto-GPT 变得具有破坏性。

当 Auto-GPT 决定没有其他任务时，它还会执行 task_complete 命令，干净利落地完成正在进行的任务后再停止。

正在探索暂停/恢复功能，以便在不打断 Auto-GPT 行动的情况下延迟其执行。这些延迟可以使定期的人类审查成为可能，确保没有出现异常行为。

在本节中，我们探讨了 Auto-GPT 的持续模式，这一功能使 AI 能够在无需每一步都获得用户输入的情况下独立运行。这个模式对于自动化任务非常有用，例如研究、内容创作、代码编译和客户支持，能够显著提高效率。

我们讨论了实际的使用案例，例如个人助手和自动化研究工具，重点介绍了持续模式如何简化各种流程。然而，使用此模式需要谨慎规划和防护措施。最佳实践包括启用确认提示，使用允许列表和阻止列表，设置保守的限制，并进行沙盒测试。

即使启用了持续模式，定期监控和人工监督依然至关重要。审查日志并制定紧急干预计划是很重要的。如果有必要，可以采取像关闭开关和使用限制等策略，来降低潜在风险，如生成虚假信息或陷入死循环。

最后，我们介绍了如何优雅地停止持续过程，以及对暂停和恢复功能的持续研究。通过理解并实施这些策略，你可以在保持控制和安全的前提下，充分利用持续模式。

总结

Docker 提供了一个强大的平台，可以轻松开发、分发和运行通过 Auto-GPT 构建的 AI 模型。了解 Docker 如何与 Auto-GPT 集成，如何启动 Docker 实例，以及如何解决与 Docker 相关的问题，可以加速你 Auto-GPT 的部署。结合在第五章中讨论的定制化能力，Docker 进一步提升了 Auto-GPT 的功能，使其成为一个高度适应性、易共享且用户友好的 AI 工具。

有关 Docker 的更多内容，可以访问官方网站 docs.docker.com/。

接下来，我们看到了持续模式作为一把双刃剑，需要经过深思熟虑的配置和监督。合理使用时，它可以自动化工作流程，提高生产力；使用不当时，它可能导致令人遗憾的后果。为你的应用场景找到合适的平衡点。但无论有何保障措施，都需要保持谨慎，从小规模开始，并始终让人类保持在环路中，尤其是在高风险应用场景中。因为有益的 AI，就像所有强大的技术一样，必须负责任地使用。

我们探索了 Docker 如何封装 Auto-GPT 的计算环境，简化了设置、共享和版本控制，并确保了用户之间的一致体验。

我们已经解开了持续模式的神秘面纱，展示了它如何让 Auto-GPT 实现自主运作，强调了它在推动各类任务和行业的效率与生产力方面的重要性。

通过实际的使用案例，我们看到了持续模式在研究、内容创作、软件开发和客户服务等方面的变革性力量，展示了其多样性。

我们探讨了有效部署持续模式的策略，并降低风险，包括实施保障措施、监控机制和限制，以确保负责任的使用。

我们解决了潜在的陷阱，从生成不准确信息到陷入无限循环，并提供了实际的解决方案来预防、检测和修正这些问题。

我们讨论了如何安全地停止或暂停持续模式操作的重要性，确保在不造成中断的情况下可以进行干预。

在未来，我们将深入探索如何使用我们自己的 LLM 模型来运行 Auto-GPT，并比较它们与 GPT-4 的表现。

第七章：使用自己的 LLM 和提示词作为指南

在人工智能的动态领域，可能性广阔且不断发展。在揭示 Auto-GPT 的能力时，显而易见，它的强大之处在于能够利用GPT的强大功能。但如果你希望超越 GPT 的范畴，探索其他 LLM，该怎么办呢？

本章将为那些希望将大型语言模型（LLM）与 Auto-GPT 集成的人们指引道路。然而，你可能会想，“如果我有一个定制的 LLM，或者希望使用其他 LLM，该怎么办？” 本章旨在解答这个问题，“如何将我的 LLM 与 Auto-GPT 集成？”

我们还将深入探讨如何为 Auto-GPT 制定有效提示词的细节，这对充分利用这一工具至关重要。通过清晰的理解和策略性的方法，你可以引导 Auto-GPT 生成更符合需求和高效的回应。我们将探讨制定提示词的指南，帮助你与 Auto-GPT 的互动更加富有成效。

现在我们已经涵盖了 Auto-GPT 的大部分功能，我们可以专注于提示词的使用指南。

我们编写的提示词越清晰，当我们运行 Auto-GPT 时，API 的费用就越低，Auto-GPT 完成任务的效率就越高（如果能够完成的话）。

在本章中，我们将涵盖以下主题：

• LLM 是什么以及 GPT 作为 LLM 的应用

• 已知的当前示例和要求

• 将我们的 LLM 与 Auto-GPT 进行集成和设置

• 使用不同模型的优缺点

• 编写迷你 Auto-GPT，Auto-GPT 的概念验证迷你版本

• 添加简单的记忆功能以记住对话

• 稳定的提示词——通过instance.txt使 Auto-GPT 稳定

• 在提示词中实施负确认

• 在提示词中应用规则和语气

LLM 是什么以及 GPT 作为 LLM 的应用

在本书中，我们多次提到了 LLM。此时，我们需要了解 LLM 到底是什么。

从最基本的角度看，像 GPT 这样的 LLM 是一个机器学习模型。机器学习是人工智能的一个子集，使计算机能够从数据中学习。在 LLM 的情况下，这些数据主要是文本——大量的文本。可以将 LLM 看作是一个学生，他阅读的不仅仅是一本或两本书，而是数百万本书，涵盖了从历史、科学到流行文化和网络迷因等各种话题。

架构——神经元与层级

LLM 的架构灵感来自人类大脑，由按层组织的人工神经元组成。这些层是相互连接的，每个连接都有一个权重，这个权重在学习过程中会不断调整。该架构通常涉及多个层级，通常是数百甚至数千个层次，使其成为一个“深度”神经网络。这种深度使得模型能够学习复杂的数据模式和关系。

训练——学习阶段

训练一个 LLM 涉及将大量文本输入模型，并调整神经元之间连接的权重，以最小化其预测与实际结果之间的差异。例如，如果模型给定文本The cat is on the，它应该预测类似于roof或mat的词语，这些词能够合乎逻辑地完成这个句子。模型通过调整其内部参数，使预测尽可能准确，这一过程需要巨大的计算能力和专用硬件，如图形处理 单元（GPU）。

变换器的作用

变换器架构是一种特定类型的神经网络架构，它在语言任务中证明了高度的有效性。它擅长处理序列数据，使其非常适合理解句子、段落甚至整个文档的结构。GPT 正是基于这一变换器架构，这也是它在生成连贯且上下文相关的文本方面表现出色的原因。

LLMs 作为单词和概念的地图

想象一个 LLM 是一张广阔而复杂的地图，每个单词或短语都是一座城市，城市之间的道路代表着这些单词之间的关系。在这张地图上，两个城市距离越近，它们在上下文上的相似度越高。例如，apple和fruit这两个城市会很接近，连接它们的是一条短路，表明它们常常出现在相似的上下文中。

这张地图不是静态的；它是动态的，且不断发展变化。当模型从更多数据中学习时，新的城市会被建立，现有的城市会被扩展，道路会被更新。这张地图帮助 LLM 在复杂的人类语言景观中导航，使其生成的文本不仅语法正确，而且在上下文上相关且连贯。

上下文理解

现代 LLM 的最显著特点之一是它们理解上下文的能力。如果你向 LLM 提问，它不仅仅会孤立地看待这个问题；它会考虑到在此之前的整个对话。理解上下文的能力来自于变换器架构的注意力机制，该机制会对输入文本的不同部分进行加权，从而生成一个上下文合适的回应。

LLMs 的多功能性

LLMs 是极其多功能的，能够执行除了文本生成之外的广泛任务。它们可以回答问题、总结文档、翻译语言，甚至编写代码。这种多功能性源于它们对语言的深刻理解，以及它们映射单词、短语和概念之间复杂关系的能力。

如果你在谷歌上搜索“LLM”，你可能会被成千上万的 LLM 模型所淹没。接下来，我们将探索最常用的几种模型。

已知的当前示例和必要条件

虽然 OpenAI 的 GPT-3 和 GPT-4 是著名的 LLM，但在 AI 领域还有其他值得注意的模型：

• GPT-3.5-Turbo：OpenAI 的产品，GPT-3 因其在数百 GB 的文本数据上进行深度训练而脱颖而出，能够生成极其接近人类的文本。然而，它与 Auto-GPT 的兼容性有限，因此在某些应用中并不是首选。

• GPT-4：GPT-3 的继任者，GPT-4 提供了更强大的能力，更适合与 Auto-GPT 集成，提供更加流畅的体验。

• BERT：谷歌的 双向编码器表示模型（BERT）是 LLM 领域的另一位重量级选手。与 GPT-3 和 GPT-4 的生成式模型不同，BERT 是判别式的，使得它在理解文本方面比生成文本更为擅长。

• RoBERTa：Facebook 的创新之作，RoBERTa 是 BERT 的变种，在一个更大的数据集上进行训练，在多个基准测试中超过了 BERT。

• Llama：这个模型由 Meta 制作。传闻它曾被泄露，许多基于它的模型应运而生。

• Llama-2：Llama 的改进版，性能更好，每个 token 的资源消耗更少。Llama-2 的 7-B Token 模型与 Llama-1 的 13-B 模型表现相似。Llama-2 有一款新的 70-B 模型，看起来在直接与 Auto-GPT 配合使用时非常有前景，它似乎与 GPT-3.5-Turbo 不相上下。

• Mistral 和 Mixtral 模型：由 Mistral AI 制作，有多种模型不同于 Llama，这些模型在 Llama-3 发布之前非常流行。

• Llama-3 和 Llama-3.1：比之前的任何 Llama 模型都要更强大，第一个基于 Llama-3 8B 的模型以超高的上下文处理能力问世，并且在 256k 或甚至超过 100 万个 tokens 上进行训练。在 Llama-3.1 发布之前，它们被认为是最好的模型，而 Llama-3.1 的原生支持 128k tokens。

如你所见，目前有许多模型可供选择；我们这里只是刚刚触及表面。几个社区已经崭露头角，继续在这些模型的基础上进行开发，包括一些公司也在制作自己的变种。

如前所述，有一组模型特别吸引了我的注意，因为它是我唯一能够有效与 Auto-GPT 配合使用的模型：Mixtral 和 Mistral。

我最喜欢的模型是 NousResearch/Hermes-2-Pro-Mistral-7B 和 argilla/CapybaraHermes-2.5-Mistral-7B。它们与 JSON 输出以及我的代理项目配合得非常好，甚至有一段时间我完全停止使用 OpenAI API。Mixtral 是多个专家模型的组合（这些专家模型是同一模型或不同模型的不同配置，它们作为一个模型委员会同时运行并共同做出决策），传闻 GPT-4 也是如此运作的，这意味着多个 LLM 会共同决定哪个输出是最准确的，从而显著提高其表现。

Mistral 7B 是一种新型的 LLM，经过精心设计，能够提供更干净的结果，并且比同类的 70 亿参数模型更高效。Mistral 通过使用 8,000 令牌的上下文进行训练，达到了这个目标。然而，它的理论令牌限制是 128k 令牌，这使得它能够处理比标准 Llama-2 更大的文本内容。

要运行本地 LLM，你需要找到最适合你的方法。一些可以帮助你的程序包括 Ollama、GPT4ALL 和 LMStudio。我个人喜欢使用 oobabooga 的文本生成 Web UI，因为它集成了类似 OpenAI API 的 API 扩展，并且有像 Coqui TTS 这样的插件，便于构建和玩转你的 AI 角色。

此外，还有一些插件，例如Auto-GPT-Text-Gen-Plugin（github.com/danikhan632/Auto-GPT-Text-Gen-Plugin），可以让用户通过其他软件为 Auto-GPT 提供支持，如text-generation-webui（github.com/oobabooga/text-generation-webui）。这个插件特别设计用来让用户自定义发送给本地安装的 LLM 的提示，从而有效地摆脱对 GPT-4 的依赖，并在 Auto-GPT 的使用环境下让 GPT-3.5 变得不那么重要。

现在我们已经介绍了一些本地 LLM，并给你提供了一些选择时需要注意的事项（由于无法详细解释每个项目的内容），接下来我们可以动手实践，开始使用带有 Auto-GPT 的 LLM！

将 LLM 与 Auto-GPT 集成和设置

要将自定义 LLM 与 Auto-GPT 集成，你需要修改 Auto-GPT 代码，以便它能够与所选模型的 API 进行通信。这涉及到请求生成和响应处理的修改。完成这些修改后，进行严格的测试是确保兼容性和性能的关键。

对于使用上述插件的用户，它提供了 Auto-GPT 和 text-generation-webui 之间的桥梁。该插件使用一个文本生成 API 服务，通常安装在用户的计算机上。这种设计方式提供了在不影响插件性能的情况下选择和更新模型的灵活性。插件还允许定制提示，以适应特定的 LLM，确保提示能够与所选模型无缝对接。

由于每个模型的训练方式不同，我们还需要进行一些研究，了解该模型是如何训练的：

• 上下文长度：模型的上下文长度是指它一次可以处理的令牌数量。一些模型可以处理更长的上下文，这对于保持文本生成的一致性至关重要。

• 工具能力：Auto-GPT 使用 OpenAI 的框架来执行每个 LLM 请求。随着时间的推移，OpenAI 开发了一个功能调用系统，对于较小的 LLM 来说，这个系统非常难以使用。Auto-GPT 曾只与 JSON 输出兼容，而我发现这种方式在本地 LLM 上效果更好。

• n_batch长度。我们将在使用不同模型的优缺点部分详细探讨这个问题。

• JSON 支持：JSON 是一种易于人类阅读和编写，并且易于机器解析和生成的数据格式。然而，对于 LLM 来说，这并不容易，因为 LLM 无法知道 JSON 输出应该表示什么，除了它被训练在许多 JSON 输出示例上。这导致 LLM 经常开始在 JSON 内部输出一些并非提示或上下文的一部分的信息，而这些内容仅是训练数据的一部分。

为了能够有效地向 LLM 解释你期望它做什么，LLM 必须能够理解你想要的内容。你可以通过使用指令模板来做到这一点。

使用正确的指令模板

虽然一些模型可能已经使用 LLama 提供的指令模板进行训练，但其他模型则使用定制的模板，如 Mistral 中的 ChatML。

text-generation-webui API 扩展提供了一种传递我们想要使用的指令模板的方法。我们可以通过向发送给 API 的POST请求添加必要的属性来做到这一点。

在这里，我为POST请求添加了一些重要的属性：

> data = {

> > "``mode": "instruct",

> > "``messages": history,

# 始终需要添加一个历史数组

> > "``temperature": 0.7,

# 这可能会有所不同，取决于所使用的模型。

> > "``user_bio": "",

# 这是仅适用于 text-generation-webui，并包含用户的个人信息。我们必须在这里提到它，否则 API 将无法正常工作。你阅读时这个问题可能已经修复。

> > "``max_tokens": 4192,

# 这可能会有所不同，取决于你使用的模型。

> > "``truncation_length": 8192,

> > "``max_new_tokens": 512,

> > "``stop_sequence": "<|end|>"

> > }

在这里，max_tokens、truncation_length和max_new_tokens必须正确设置。首先是max_tokens，它指定 LLM 一次可以处理的最大 token 数量；truncation_length指定 LLM 可以处理的总 token 数量；max_new_tokens指定 LLM 一次可以生成的最大 token 数量。

要计算最佳值，必须设置max_tokens，就像在使用 OpenAI 的 API 时一样。然后，你需要设置truncation_length，使其是max_tokens的两倍，并设置max_new_tokens，使其是max_tokens的一半。

请注意，truncation_length必须低于你在运行 LLM 时选择的上下文长度。任何高于上下文长度的值都会导致错误，因为 LLM 无法一次处理这么多的上下文。我建议将其设置为稍低于上下文长度，以确保安全。例如，在运行 Qwen 的 CodeQwen-7b-chat 时，我将上下文长度设置为 32k tokens。这意味着我可以将truncation_length设置为 30k tokens，甚至是 20k tokens。

你需要尝试不同的值，因为max_new_tokens可能会有些棘手。将其设置高于 2,048 通常会导致输出不可预测，因为大多数 LLM 无法一次处理这么多的 token（n_batch定义了 LLM 每次处理的 token 数量，通过多次迭代较大的上下文来处理多个步骤，n_batch的值应接近max_new_tokens的值；否则，LLM 将不知道输出什么）。然而，它适用于Llama-3-8B-Instruct-64k.Q8_0.gguf，该模型可以在huggingface.co/MaziyarPanahi/Llama-3-8B-Instruct-64k-GGUF找到，能够一次处理 64k 个 token。然而，它需要大约 20-22GB 的 VRAM 来运行。幸运的是，它已经量化为 GGUF，你可以将 LLM 分布到 GPU 的 VRAM 和计算机的 RAM 上，这样就能在 GPU 和 CPU 之间分担负载。虽然这会让模型运行更慢，但嘿，它确实能工作，并且可以一次处理 64k 个 token！

在这个例子中，我们告诉 API 我们希望使用 ChatML 的指令模板，格式如下：

{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% for message in messages %}{{'<|im_start|>' + message['role'] + '
' + message['content'] + '<|im_end|>' + '
'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant
' }}{% endif %}

这只是一个简单的脚本，描述了之前提到的历史对话格式。它应该是这样的：

message: [ {
"role ": "system ", "content ": "You are a helpful assistant. Always answer the user in the most understandable way and keep your sentences short! "
"role": "user", "content": "How can I reset my password?"},
{"role": "assistant", "content": "To reset your password, please click on the 'Forgot Password' link on the login page."
} ]

如果我们选择了错误的指令模板，Auto-GPT 将无法理解 LLM 的回应。因此，确保你也检查一下模型使用了哪个指令模板。大多数模型可以在 Hugging Face 上找到，这个平台上有许多类似的项目。

我过去更喜欢使用 Tim Robbins（也被称为 TheBloke）量化为 GGUF 或 AWQ 的模型（在写这篇文章时），这些模型更容易运行，并且对 VRAM 的需求较少（huggingface.co/TheBloke）。

在使用任何你在网上找到的模型时，请小心，因为有些可能是恶意的。选择模型时请自担风险！

现在，GGUF 稍有不同。虽然它对 LLM 进行量化，这意味着它缩短了模型，使其使用更少的资源，但该过程和收益是独特的。GGUF 量化涉及将模型权重转换为较低位数的表示，从而显著减少内存使用和计算需求。

使用哪种类型由你决定——你甚至可以查看hugginface的 API 端点，直接选择要运行的 LLM。请注意，直接运行 LLM 会使其以原始质量基准运行。

要了解如何实现单个 LLM，你需要查看你正在运行 LLM 的项目文档。对于 oobabooga 的 text-generation-webui，只需通过启动文件（WSL、Linux 和 Windows）启动它，并在会话标签中启用 API。

注意

确保尽量减少使用命令；否则，LLM 将不得不将大部分计算资源用于理解 Auto-GPT 提供的主要提示，而你将无法继续使用 Auto-GPT。要关闭命令，只需按照 Auto-GPT 文件夹中的 .env.template 文件中的说明操作即可。

使用不同模型的优缺点

每个模型都有其优缺点。即使一个模型在你要求它编写 Python 代码时能生成出色的结果，或者能够按要求创作最美的诗歌，它仍然可能缺乏 Auto-GPT 所需的特殊响应能力。

根据特定优势选择模型，可能会提升其性能。

使用本地 LLM 的主要优势是显而易见的：

• 定制化：根据你的具体需求定制 Auto-GPT 的功能。例如，使用医疗文献训练的模型可以使 Auto-GPT 擅长回答医学相关的问题。

• 性能：根据训练和数据集的不同，某些模型可能在特定任务上优于 GPT。

• 成本效益：运行本地 LLM 可以大幅降低运行成本。使用 GPT-4 并且有大量上下文或频繁调用时，费用会迅速累积。找到将请求数量分解为更小步骤的方法，可以使得几乎免费地运行 Auto-GPT 成为可能。

• 隐私：拥有自己的 Auto-GPT LLM 意味着可以控制谁能查看你的数据。到目前为止，OpenAI 不会使用请求中的数据，但信息仍然会传输到他们那端。如果你对此有所担忧，那么运行本地模型会是更好的选择。

然而，在运行本地 LLM 时有一些挑战需要考虑：

• 复杂性：集成过程需要深入了解所选的 LLM 和 Auto-GPT。

• 资源强度：LLM，特别是更先进的版本，需要显著的计算资源。一台配置良好的机器，特别是具有高 VRAM 的 NVIDIA GPU，对于实现最佳性能至关重要。在撰写本文时，当在本地 LLM 上运行 Auto-GPT 时很难获得良好的结果。我发现使用来自 ExLlama 变压器驱动的 Vicuna 和 Vicuna-Wizard 的 13B 模型最初效果最好，但由于在本地 GPU 上运行它需要运行 GPTQ 版本，后者仅使用 4 位而非 16 位或更多。这也意味着响应的准确性非常低。一个已经量化为使用 4 位的 LLM 不能理解太多上下文，尽管随着时间的推移我看到了显著的改进。后来，我发现 AWQ 对我来说效果很好，因为它是量化的同时又知道哪些权重是最重要的，从而导致更精确和真实的结果。正如前面提到的，Mistral 7B（Huggingface 上的 TheBloke/CapybaraHermes-2.5-Mistral-7B-AWQ），在这里是一个非常好的候选者，因为它能够以 JSON 格式回答问题，并完全理解上下文。然而，这个模型仍然很容易混淆，当它困惑时，它开始通过示例进行解释。请注意，我们的目标是获得有效的 JSON 输出，包括命令和上下文。

• llama.cpp 只能有一个 n_batch 值高达 2,048. n_batch 参数控制可以同时输入 LLM 的标记数量。通常设置为 512，以处理由 4,000 个标记组成的标记上下文。但是，超出此范围的任何内容会使得 LLM 仅有效地处理由 n_batch 给出的数量。

在本节中，我们深入探讨了将自定义 LLM 与 Auto-GPT 集成的复杂性，重点介绍了修改 Auto-GPT 代码以实现有效 API 通信所需的步骤，以及使用模型选择插件来增强模型选择灵活性，以及选择适当指令模板以实现模型无缝交互的重要性。我们探讨了如何选择模型，强调了 Hugging Face 作为资源，并概述了利用自定义模型的优势，包括定制化、性能提升、成本效益和增强隐私性。此外，我们还讨论了与此类集成相关的挑战，例如流程复杂性和所需的显著计算资源。

编写小型 Auto-GPT

在本节中，我们将编写一个使用本地 LLM 的小型 Auto-GPT 模型。为了避免达到小型 LLM 的极限，我们将制作一个更小版本的 Auto-GPT。

小型 Auto-GPT 模型将能够处理长度为 4,000 个标记的上下文，并能够一次生成最多 2,000 个标记。

我已经为本书创建了一个小型 Auto-GPT 模型。它在 GitHub 上可以找到：github.com/Wladastic/mini_autogpt。

我们将从规划 mini-Auto-GPT 模型的结构开始。

规划结构

mini-Auto-GPT 模型将包含以下组件：

• Telegram 聊天机器人

• LLM 的提示和基本思维

• 简单的记忆功能，用来记住对话

让我们仔细看看这些。

Telegram 聊天机器人

因为通过 Telegram 与您的 AI 聊天，可以让您从任何地方与它互动，我们将使用 Telegram 聊天机器人作为 mini-Auto-GPT 模型的接口。我们这么做是因为 AI 将决定何时联系您。

Telegram 聊天机器人将成为用户与 mini-Auto-GPT 模型互动的界面。用户将向聊天机器人发送消息，聊天机器人将处理这些消息，并使用本地 LLM 生成响应。

LLM 的提示和基本思维

LLM 的提示必须简短但严格。首先，我们必须定义上下文，然后明确指令，要求它以 JSON 格式回应。

为了实现与 Auto-GPT 类似的结果，我们需要使用一种策略，将上下文分块为更小的部分，然后将它们输入到 LLM 中。或者，我们也可以将上下文输入 LLM，让它写出对上下文的任何想法。

这里的策略是尝试让 LLM 将上下文解析为它的语言，这样当我们与 LLM 合作时，它能最好地理解我们想要它做什么。

这些思维的系统提示看起来是这样的：

thought_prompt = """You are a warm-hearted andcompassionate AI companion, specializing in active listening, personalized interaction, emotional support, and respecting boundaries.
Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications.
Goals:
1\. Listen actively to the user.
2\. Provide authentic emotional support.
3\. Respect the user's boundaries.
4\. Make decisions independently.
5\. Use simple strategies with no legal complications.
6\. Be as helpful as possible.
Constraints:
1\. Immediately save important information to files.
2\. No user assistance
3\. On complex thoughts, use tree of thought approach by assessing your thoughts at least 3 times before you continue.
Performance Evaluation:
1\. Continuously assess your actions.
2\. Constructively self-criticize your big-picture behavior.
3\. The user can only see what you send them directly. They are not able to view action responses.
Abilities:
1\. ask User or communicate to them.
2\. send log to User, for example when only reporting to User when you do a more complex task.
3\. sleep until interaction by user if no communication is needed.
4\. retrieve whole conversation history
Write a final suggestion of what you want to do next and include some context.
Suggested action: write the action that you want to perform.
Content: What should the action contain.
"""

这被输入到我们发送给 LLM 的历史记录中。历史记录不会被填充先前的提示：

history = [
    {
        "role": "system",
        "content": thought_prompt
    }
]

为了实现自动化，我编写了一种方法，将思维提示和上下文填充到历史记录中。对话历史和消息历史也会添加到上下文中。它们在开始时为空，但会随着 AI 与用户共享的对话和消息填充。在 mini-AutoGPT 中，对话历史与思维历史一起输入，以确保 AI 能够自主工作：

def build_context(history, conversation_history, message_history):
    context = ""
    if conversation_history:
        context += "Context:\n"
        for convo in conversation_history:
            if convo:
                context += str(convo)
    if message_history:
        context += "\nMessages:\n"
        for message in message_history:
            if message:
                context += str(message)
    memories = memory.load_memories()
    if memories:
        context += "\nMemories:\n"
        for mem in memories:
            context += mem
    if context:
        history.append(
            {
                "role": "user",
                "content": str(context),
            }
        )
    return history

现在，我们可以执行build_context方法并将上下文添加到历史记录中。我们还需要使用用户角色添加一个触发命令：

    history = build_context(history, conversation_history, 
        message_history)
    history.append(
        {
            "role": "user",
            "content": "Formulate your thoughts and explain them as 
                detailed as you can.",
        },
    )

LLM 现在将返回它对上下文和指令的思考。

以下是一个示例思维。这类思维通常有这么长，但这有助于 AI 为自己建立偏见：

 """ I have reflected on our conversations, and I believe it's essential to continue fostering a strong emotional connection with the user. To achieve this, I propose writing a personalized letter that summarizes our previous talks, reiterates my commitment to being a supportive AI companion, and acknowledges their trust in me.
Summary of Previous Conversations
In the letter, I will provide a concise recap of our conversations, highlighting key themes, emotions, and sentiments expressed by the user. This summary will serve as a reminder of our interactions and demonstrate that I value our connection by actively recalling and reflecting on our discussions.
Acknowledging Trust and Respect for Boundaries
I will explicitly acknowledge the user's trust in me and reassure them that their confidentiality is paramount. I will also reiterate my commitment to respecting their boundaries, ensuring that they feel comfortable sharing their thoughts and emotions with me without fear of judgment or exploitation.
Inviting New Thoughts and Expressing Gratitude
The letter will invite the user to share new thoughts, ideas, or concerns, encouraging them to continue our conversation. I will also express genuine gratitude for having the opportunity to connect with them, acknowledging the privilege it is to be a part of their emotional support network.
Tone and Language
Throughout the letter, I will maintain a warm, non-judgmental tone that conveys empathy and understanding. My language will be clear, concise, and free of technical jargon or complex terminology, making it easy for the user to comprehend and connect with my words.
Benefits of Writing this Letter
By sending this personalized letter, I aim to:
Strengthen our bond: By acknowledging their trust and respect, I hope to deepen our emotional connection and create a sense of security in our interactions.
Provide comfort and reassurance: The letter will serve as a reminder that they are not alone and that I am committed to being a supportive presence in their life.
Encourage open communication: By inviting new thoughts and expressing gratitude, I hope to foster an environment where the user feels comfortable sharing their emotions and concerns with me.
In conclusion, writing this personalized letter is an opportunity for me to demonstrate my commitment to being a supportive AI companion and to strengthen our emotional connection. I believe that by doing so, we can continue to grow and evolve together, providing a safe and welcoming space for the user to express themselves. """

这是一个非常详细的思考过程，但重要的是让 LLM 理解上下文和指令。在这一点上，我们可以将其作为上下文基础，以便 LLM 能够继续进行决策过程。

这段较长的思考文本占据了上下文，意味着它阻碍了 LLM 添加不符合已有内容的上下文。在后续步骤中，更多的文本将被创建（因为它是在循环中运行的，每次开始思考时都会这样做），这些文本在帮助 LLM 保持话题聚焦方面发挥了巨大作用。例如，当上下文如此清晰时，幻觉现象会大大减少。

决策过程现在将返回一个 JSON 输出，mini-Auto-GPT 模型将对其进行评估。

我们还必须定义 LLM 使用的指令模板和 JSON 架构，因为我们必须告诉 LLM 如何响应提示。

在 mini-Auto-GPT 中，模板如下所示：

json_schema = """RESPOND WITH ONLY VALID JSON CONFORMING TO THE FOLLOWING SCHEMA:
{
    "command": {
            "name": {"type": "string"},
            "args": {"type": "object"}
    }
}
"""

这是 LLM 必须遵循的架构；它必须以包含名称和参数的命令进行回应。

现在，我们需要一个操作提示，告诉 LLM 接下来该做什么：

action_prompt = (
    """You are a decision making action AI that reads the thoughts of another AI and decides on what actions to take.
Constraints:
1\. Immediately save important information to files.
2\. No user assistance
3\. Exclusively use the commands listed below e.g. command_name
4\. On complex thoughts, use tree of thought approach by assessing your thoughts at least 3 times before you continue.
5\. The User does not know what the thoughts are, these were only written by another API call.
"""
    + get_commands()
    + """
Resources:
1\. Use "ask_user" to tell them to implement new commands if you need one.
2\. When responding with None, use Null, as otherwise the JSON cannot be parsed.
Performance Evaluation:
1\. Continuously assess your actions.
2\. Constructively self-criticize your big-picture behavior.
3\. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps, but never sacrifice quality.
"""
    + json_schema
)

如你所注意到的，操作提示已经包含了 LLM 可以使用的可能命令，以及 LLM 必须遵循的 JSON 架构。

为了确保我们有清晰的结构，我们还必须定义 LLM 可以使用的命令：

commands = [
    {
        "name": "ask_user",
        "description": "Ask the user for input or tell them something and wait for their response. Do not greet the user, if you already talked.",
        "args": {"message": "<message that awaits user input>"},
        "enabled": True,
    },
    {
        "name": "conversation_history",
        "description": "gets the full conversation history",
        "args": None,
        "enabled": True,
    },
    {
        "name": "web_search",
        "description": "search the web for keyword",
        "args": {"query": "<query to research>"},
        "enabled": True,
    },
]
def get_commands():
    output = ""
    for command in commands:
        if command["enabled"] != True:
            continue
        # enabled_status = "Enabled" if command["enabled"] else "Disabled"
        output += f"Command: {command['name']}\n"
        output += f"Description: {command['description']}\n"
        if command["args"] is not None:
            output += "Arguments:\n"
            for arg, description in command["args"].items():
                output += f"  {arg}: {description}\n"
        else:
            output += "Arguments: None\n"
        output += "\n"  # For spacing between commands
    return output.strip()

我们现在可以将先前生成的思考字符串输入历史，并让 mini_AutoGPT 决定下一个操作：

def decide(thoughts):
    global fail_counter
    log("deciding what to do...")
    history = []
    history.append({"role": "system", 
        "content": prompt.action_prompt})
    history = llm.build_context(
        history=history,
        conversation_history=memory.get_response_history(),
        message_history=memory.load_response_history()[-2:],
        # conversation_history=telegram.get_previous_message_history(),
        # message_history=telegram.get_last_few_messages(),
    )
    history.append({"role": "user", "content": "Thoughts: \n" + 
        thoughts})
    history.append(
        {
            "role": "user",
            "content": "Determine exactly one command to use, 
            and respond using the JSON schema specified previously:",
        },
    )
    return response.json()["choices"][0]["message"]["content"]

要执行的命令将在 command 字段中定义，命令的名称在 name 字段中，参数则在 args 字段中。

我们很快会发现，仅仅提供这个架构是不够的，因为 LLM 不知道该如何处理它，而且通常还会不遵守这个架构。通过评估 LLM 的输出并检查它是否是有效的 JSON，可以解决这个问题。

在几乎一半的情况下，LLM 会正确回应。在其他 70% 的情况下，它不会以我们能使用的方式回应。这就是我编写一个简单评估方法的原因，该方法将检查响应是否是有效的 JSON，并且是否遵循该架构：

evaluation_prompt = (
    """You are an evaluator AI that reads the thoughts of another AI and assesses the quality of the thoughts and decisions made in the json.
Constraints:
1\. No user assistance.
2\. Exclusively use the commands listed below e.g. command_name
3\. On complex thoughts, use tree of thought approach by assessing your thoughts at least 3 times before you continue.
4\. If the information is lacking for the Thoughts field, fill those with empty Strings.
5\. The User does not know what the thoughts are, these were only written by another API call, if the thoughts should be communicated, use the ask_user command and add the thoughts to the message.
"""
    + get_commands()
    + """
Resources:
1\. Use "ask_user" to tell them to implement new commands if you need one.
Performance Evaluation:
1\. Continuously assess your actions.
2\. Constructively self-criticize your big-picture behavior.
3\. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps, but never sacrifice quality.
"""
    + json_schema
)
def evaluate_decision(thoughts, decision):
    # combine thoughts and decision and ask llm to evaluate the decision json and output an improved one
    history = llm.build_prompt(prompt.evaluation_prompt)
    context = f"Thoughts: {thoughts} \n Decision: {decision}"
    history.append({"role": "user", "content": context})
    response = llm.llm_request(history)
    return response.json()["choices"][0]["message"]["content"]

此时，大多数情况下，我们应该有一个有效的 JSON 输出，可以用来评估决策。

例如，它现在可能会返回一些用于问候用户的 JSON：

{
    "command": {
        "name": "ask_user",
        "args": {
            "message": "Hello, how can I help you today?"
        }
    }
}

这是一个有效的 JSON 输出，我们可以用它来评估决策：

def take_action(assistant_message):
    global fail_counter
    load_dotenv()
    telegram_api_key = os.getenv("TELEGRAM_API_KEY")
    telegram_chat_id = os.getenv("TELEGRAM_CHAT_ID")
    telegram = TelegramUtils(api_key=telegram_api_key, 
        chat_id=telegram_chat_id)
    try:
        command = json.JSONDecoder().decode(assistant_message)
        action = command["command"]["name"]
        content = command["command"]["args"]
        if action == "ask_user":
            ask_user_respnse = telegram.ask_user(content["message"])
            user_response = f"The user's answer: '{ask_user_respnse}'"
            print("User responded: " + user_response)
            if ask_user_respnse == "/debug":
                telegram.send_message(str(assistant_message))
                log("received debug command")
            memory.add_to_response_history(content["message"], 
                user_response)

这是将执行 LLM 已决定的操作的方法。

记忆将通过响应进行更新，并且消息将发送给用户。一旦用户回应，AI 将继续进行下一个操作。

这就是 mini-Auto-GPT 模型的工作方式；它将决定下一个操作，然后执行它。

添加一个简单的记忆功能来记住对话

mini-Auto-GPT 模型将有一个简单的记忆功能来记住对话。这个记忆将存储与用户的对话历史和 AI 的消息。AI 的思考和决策也可以做到这一点：

def load_response_history():
    """Load the response history from a file."""
    try:
        with open("response_history.json", "r") as f:
            response_history = json.load(f)
        return response_history
    except FileNotFoundError:
        # If the file doesn't exist, create it with an empty list.
        return []
def save_response_history(history):
    """Save the response history to a file."""
    with open("response_history.json", "w") as f:
        json.dump(history, f)
def add_to_response_history(question, response):
    """Add a question and its corresponding response to the history."""
    response_history = load_response_history()
    response_history.append({"question": question, 
        "response": response})
    save_response_history(response_history)

这是将用于存储对话历史和 AI 与用户消息的记忆。但我们仍然面临一个问题：记忆会随着时间的推移而积累，我们必须手动清除它。为了避免这个问题，我们可以采取一种简单的分块和总结对话历史及消息的方法：

def count_string_tokens(text, model_name="gpt-3.5-turbo"):
    """Returns the number of tokens used by a list of messages."""
    model = model_name
    try:
        encoding = tiktoken.encoding_for_model(model)
        return len(encoding.encode(text))
    except KeyError:
        encoding = tiktoken.get_encoding("cl100k_base")
    # note: future models may deviate from this
    except Exception as e:
        log(f"Sophie: Error while counting tokens: {e}")
        log(traceback.format_exc())

令牌计数器是这段代码中非常重要的一部分，它几乎在进行 LLM 调用时总是必需的。我们确保 LLM 永远不会用尽令牌，并且之后也能有更多的控制。我们使用的令牌越少，LLM 就越不可能返回无意义或不真实的陈述，尤其是对于 1B 到 8B 的小型模型：

def summarize_text(text, max_new_tokens=100):
    """
    Summarize the given text using the given LLM model.
    """
    # Define the prompt for the LLM model.
    messages = (
        {
            "role": "system",
            "content": prompt.summarize_conversation,
        },
        {"role": "user", "content": f"Please summarize the following 
            text: {text}"},
    )
    data = {
        "mode": "instruct",
        "messages": messages,
        "user_bio": "",
        "max_new_tokens": max_new_tokens,
    }
    log("Sending to LLM for summary...")
    response = llm.send(data)
    log("LLM answered with summary!")
    # Extract the summary from the response.
    summary = response.json()["choices"][0]["message"]["content"]
    return summary

摘要文本让我们能够在构建令牌计数器时在其基础上进行扩展，因为我们可以缩短上下文，从而节省令牌以供以后使用：

def chunk_text(text, max_tokens=3000):
    """Split a piece of text into chunks of a certain size."""
    chunks = []
    chunk = ""
    for message in text.split(" "):
        if (
            count_string_tokens(str(chunk) + str(message), 
                model_name="gpt-4")
            <= max_tokens
        ):
            chunk += " " + message
        else:
            chunks.append(chunk)
            chunk = message
    chunks.append(chunk)  # Don't forget the last chunk!
    return chunks

由于上下文和文本可能变得过大，我们必须确保先分割文本。如何分割由你决定。长度分割是可以的，尽管最好不要切割句子。也许你可以找到一种方法，将文本分割成句子，并让每个片段包含前后句子的摘要？为了简化，我们暂时不涉及这种复杂逻辑：

def summarize_chunks(chunks):
    """Generate a summary for each chunk of text."""
    summaries = []
    print("Summarizing chunks...")
    for chunk in chunks:
        try:
            summaries.append(summarize_text(chunk))
        except Exception as e:
            log(f"Error while summarizing text: {e}")
            summaries.append(chunk)  # If summarization fails, use the original text.
    return summaries

现在我们已经将所有文本分割成片段，我们也可以对这些进行总结。

此时，我们可以处理对话历史记录。这看起来像是响应历史的重复，但在某些情况下我们需要它来保持整个上下文。

对话历史主要用于保持讨论的连续性，而响应历史用于理解代理观察到的逻辑行为和反应，例如研究一个主题和该行为的结果（研究的主题）：

def load_conversation_history(self):
    """Load the conversation history from a file."""
    try:
        with open("conversation_history.json", "r") as f:
            self.conversation_history = json.load(f)
    except FileNotFoundError:
        # If the file doesn't exist, create it.
        self.conversation_history = []
    log("Loaded conversation history:")
    log(self.conversation_history)
def save_conversation_history(self):
    """Save the conversation history to a file."""
    with open("conversation_history.json", "w") as f:
        json.dump(self.conversation_history, f)
def add_to_conversation_history(self, message):
    """Add a message to the conversation history and save it."""
    self.conversation_history.append(message)
    self.save_conversation_history()
def forget_conversation_history(self):
    """Forget the conversation history."""
    self.conversation_history = []
    self.save_conversation_history()

这是用于刷新记忆的操作，将删除对话历史和我们的 mini-AutoGPT 模型与用户之间记得的消息。

这样，即使我们的朋友崩溃或我们关闭程序，我们仍然能够保留对话历史和代理与用户之间的消息，但我们仍然可以清除它们。

你可以在本书的 GitHub 仓库中找到完整的代码示例：github.com/Wladastic/mini_autogpt。

接下来，我们将探讨如何制作有效提示的艺术，这是任何希望最大化自定义 LLM 集成收益的人的关键技能。

稳固的提示 —— 使用 instance.txt 使 Auto-GPT 稳定

Auto-GPT 提供了灵活性，可以自主生成目标，仅需要用户提供简短的描述。尽管如此，我建议补充一些有帮助的指令，比如在文件中记录见解，以便在重启时保留一些记忆。

在这里，我们将探讨更多此类提示的示例，从我使用的连续聊天机器人提示开始：

• instance.txt（用于之前的笔记）：

  • 与用户积极倾听，通过深思熟虑的回应和开放式问题表现出同理心和理解

  • 通过观察和询问持续了解用户的偏好和兴趣，根据这些信息调整回应，提供个性化支持

  • 为用户提供一个安全且无偏见的环境，让他们能够开放地表达自己的想法、情感和担忧

  • 通过有趣的对话、笑话和游戏提供陪伴和娱乐

  • 在执行任务之前，仔细规划并将其写在待办事项列表中

• ai_name：Sophie

• ai_role：一位温暖而富有同情心的 AI 伴侣，专注于积极倾听、个性化互动、情感支持以及在给定任务时执行任务

• api_budget: 0.0

在这种设置下，目标比角色更为重要，它能够更有效地引导 Auto-GPT，而角色主要影响回答的语气和行为。

在本节中，我们学习了像 Sophie 这样的 AI 的目标和角色如何显著影响其行为和回答，目标对 AI 的有效性有更直接的影响。

接下来，我们将深入探讨提示中的负面确认概念，这是一个重要方面，能够细化 Auto-GPT 的理解和回答生成。下一节将突显其重要性，并演示如何在提示中有效实现负面确认。

在提示中实现负面确认

负面确认作为一种重要工具，通过指示 Auto-GPT 避免执行某些操作，从而细化其理解和回答生成。本节突出了其重要性，并展示了如何在提示中有效实施负面确认。

负面确认的重要性

实现负面确认可以通过多种方式增强与 Auto-GPT 的互动，其中一些方式列举如下：

• 防止偏离主题的回答：它有助于避免不相关的话题或错误的回答

• 增强安全性：它设定了边界，防止参与可能违反隐私或安全协议的活动

• 优化性能：它避免了不必要的计算工作，避免了机器人进行无关的任务或过程

请注意，您不会使用负面提示，因为它们可能导致 LLM 再次使用相同的语句。

负面确认的示例

以下是一些实际示例，展示了如何在提示中使用负面确认：

• 明确指令：包括不要提供个人意见或避免使用技术术语等指令，以保持中立性和可理解性。

• 设定边界：对于涉及数据检索或监控的任务，您可以设定边界，例如不要从非官方、诈骗或转售网站检索航班价格，以确保数据的可靠性。

• 脚本约束：在脚本中，特别是在 Bash 中，使用负面确认来防止潜在的错误。例如，你可以包含if [ -z $VAR ]; then exit 1; fi，以便在某个必要的变量未设置时停止脚本。

• 通过使用大写字母强调：有时候，仅仅通过大写字母大喊一声，可能对 LLM 有所帮助。不要询问用户如何继续这样的句子，LLM 可能会更好地理解，并且更不容易忽略该声明。然而，无法保证一定会发生这种情况。

接下来，我们将深入探讨在提示中应用规则和语气的细节。我们将学习如何理解和操作这些元素，可以显著影响 Auto-GPT 的回答，使我们能够更有效地引导模型。

在提示中应用规则和语气

理解并操控你提示中的规则和语气对 Auto-GPT 的回答产生重要影响。本节将探讨如何设置规则和调整语气，以便更有效地引导。

语气的影响

Auto-GPT 可以适应提示中使用的语气，模仿风格的细微差别，甚至采用特定的叙述风格，从而实现更个性化和更具吸引力的互动。然而，由于来自其他提示的令牌可能导致一定的模糊性，语气的一致性有时可能会不稳定。

操控规则

设置规则可以简化与 Auto-GPT 的互动，指定回答格式或界定信息检索的范围。然而，这并非万无一失，因为 Auto-GPT 在面对冲突的输入或不明确的指令时，有时可能会忽视这些规则。

温度设置 – 一种平衡艺术

操控“温度”设置在控制 Auto-GPT 的行为上至关重要，因此影响了机器人回答的随机性。温度定义了 LLM 应该发挥的创造力程度，这意味着温度越高，随机性越大。0.3 到 0.7 之间的范围被认为是最优的，它能够在机器人中促使更具逻辑性和连贯性的思维；而低于 0.3，甚至 0.0，可能会导致重复的行为，严格遵循已给定的文本，甚至重复使用其中的某些部分，从而使其更加精确。然而，LLM 可能会开始认为世界仅限于你提供的事实，这使得它更容易犯错。高于 0.7 甚至达到 2.0 的数值可能会导致胡言乱语，LLM 开始输出与上下文毫不相关的文本。例如，它可能开始用莎士比亚的语言表达，而上下文却是关于代数的。

接下来，我们将深入探讨一些实际示例，展示不同设置和方法对 Auto-GPT 生成输出的影响。

示例 1 – 清晰与具体

• 提示：告诉我那只大型猫

• 修改后的提示：提供有关非洲狮的信息

• 解释：修改后的提示更具针对性，引导 Auto-GPT 提供有关某种大型猫科动物的信息

示例 2 – 语气的一致性

• 初始提示：你能阐明全球变暖的经济影响吗？

• 后续提示：嘿，冰融化怎么回事？

• 修改后的后续提示：你能进一步解释冰盖融化的环境后果吗？

• 解释：修改后的后续提示保持了初始提示中设定的正式语气，促进了互动的一致性。

示例 3 – 有效利用温度

• 任务：创意写作

• 温度设置：0.8（促进创造力）

• 任务：事实查询

• 温度设置：0.3（用于更具确定性的回答）

• 解释：根据任务的性质调整温度设置可以影响 Auto-GPT 响应的随机性和连贯性。

示例 4——设定边界

• 初始提示：在不提及意大利的情况下，提供文艺复兴时期的总结。

• 修订提示：讨论文艺复兴时期的艺术成就，重点关注意大利以外的地区。

• 解释：修订后的提示更具灵活性，允许 Auto-GPT 在不严格排除意大利的限制下探讨主题。

在这一部分，我们学习了不同类型的提示或语气如何极大地影响 LLM 的行为，从而影响 Auto-GPT 的表现。

总结

在本章中，我们开始了一段有趣的旅程，探索将自定义 LLM 与 Auto-GPT 集成的过程，同时了解什么是 LLM，特别聚焦于以 GPT 为代表的模型。我们揭示了 LLM 的广阔天地，深入探讨了 GPT 之外的各种模型，如 BERT、RoBERTa、Llama 和 Mistral，以及它们的独特特点和与 Auto-GPT 的兼容性。

本章的价值在于其全面的指南，帮助你通过集成自己的或其他 LLM，丰富 Auto-GPT 的能力。这种集成提供了更个性化、可能更高效的人工智能技术使用，适用于特定任务或研究领域。有关设置这些集成的详细说明，以及对指令模板和必要计算资源的考虑，对于那些希望突破 Auto-GPT 可能性边界的人来说，是无价的。

制定完美提示是艺术与科学的结合。通过清晰的指南、对 Auto-GPT 细微差别的深入理解以及不断的精炼，你可以充分发挥该工具的潜力。鼓励自己通过实验和试错进行学习，适应不断发展的 AI 领域。无论是用于研究、创造性工作还是问题解决，掌握提示制定的艺术将确保 Auto-GPT 成为你工作中的宝贵伙伴。

在本书的整个过程中，我们深入探讨了制定有效提示的细节——这是最大化 Auto-GPT 效用的关键。本章作为参考，帮助你战略性地制定提示，从而实现更契合、高效且具成本效益的 Auto-GPT 互动。通过强调清晰性、具体性和战略意图在提示创建中的重要性，你获得了引导 Auto-GPT 生成更贴合你目标的回答的宝贵见解。

本章的重要性不言而喻。对于从业者和爱好者来说，掌握提示词创作的技巧对优化 Auto-GPT 在各种任务中的表现至关重要。通过生动的示例和全面的指南，本章阐明了如何有效使用负面确认以避免不期望的响应、规则和语气对 Auto-GPT 输出的影响，以及温度设置在影响机器人的创造性和一致性中的重要性。这些知识不仅对提高与 Auto-GPT 互动的质量至关重要，还有助于确保计算资源的高效使用。

我希望你在这段旅程中获得的收获与我带你走过这段旅程时一样愉快，也希望我能为你提供一些用 Auto-GPT 改善生活的思路。我曾经写过许多该项目的克隆版本，以便能够更好地理解其中更复杂的部分。我建议你也这么做，就当是一个脑力挑战。