AutoGPT 指南：在本地创建与部署自主式 AI 代理

AutoGPT 平台是一款允许用户创建、部署并管理持续运行的 AI 代理的平台。它采用低代码界面，帮助用户自动化成千上万种数字流程，代理在后台自主运行。

AutoGPT 平台由两个核心组件构成：AutoGPT Server（主要逻辑与基础设施）与 AutoGPT Frontend（用于构建代理、管理工作流并实现周期性计划的界面）。 

平台预集成了 OpenAI、Anthropic、Groq 和 Llama 等 LLM 提供商，可将数据处理、内容创作，甚至娱乐类活动等各类任务自动化。 

在本教程中，我们将指导技术从业者如何在本地设置 AutoGPT 平台并创建第一个代理。您可以阅读我们关于 理解 AI 代理 的完整指南以进一步了解，并在另一篇文章中探索不同的 AI 代理类型。 

什么是 AutoGPT？

AutoGPT 是一款允许用户创建、部署并管理自主式 AI 代理的 AI 平台/软件。通过安装在用户机器上的低代码界面，这些代理能在最少的人为监督下执行各类任务。 

在撰写本文时，如您想避免本地部署的麻烦，即将上线的 AutoGPT 云版本现已开放候补名单。

AutoGPT 的关键特性与能力包括：

• 低代码工作流：无需深厚编程知识即可创建工作流。
• 自主运行：部署持续运行的代理，并在特定触发条件下启动。
• 智能自动化：将数据处理、内容生成等重复流程自动化。
• 模块化积木系统：使用代表不同动作与集成的模块化块来构建代理。
• 多 LLM 支持：兼容 OpenAI、Anthropic、Groq 和 Llama。
• 应用市场：可获取针对特定场景预配置的代理。

AutoGPT 架构概览

AutoGPT 平台由两个主要组件构成：

1. AutoGPT 服务器：

• 代理与自动化的核心逻辑
• 可靠性能所需的基础设施
• 预构建代理的市场

2. AutoGPT 前端：

• 用于设计与配置代理的构建器
• 工作流管理工具
• 部署控制
• 即用型代理选择
• 监控与分析面板

AutoGPT 的后端使用 Python，Web 框架为 FastAPI，数据存储采用 PostgreSQL 搭配 Prisma ORM。其通过 websockets 实现实时通信，并包含执行、调度与通知等管理器。 

该设计随着平台的增长，提升了可扩展性与可维护性。

前端采用 Next.js 14、TypeScript、Radix 组件与 Tailwind CSS，并使用 xyflow 进行工作流可视化。这带来直观的低代码界面，使用户无需深厚编程知识即可构建 AI 代理。

平台包含以下关键服务：

• 数据库管理器：存储代理配置与执行数据
• 执行管理器：运行工作流并管理代理状态
• 调度器：处理基于时间的自动化与周期性任务
• Websocket 服务器：提供实时更新
• REST API：提供特性编程访问
• 代理协议：标准化与外部服务的通信
• 集成 API：连接第三方服务与 AI 提供商

2025 年的 AutoGPT 与早期版本对比

在 2023 年左右首次发布时，AutoGPT 人气爆棚，被视为 ChatGPT 的开源“杀手”。当然，那只是由社交媒体影响者推动的炒作——毕竟现在已是 2025 年，ChatGPT 依旧存在。但 AutoGPT 确实标志着 AI 社区的关注点转向了 AI 代理。

早期版本的 AutoGPT 承诺可从单一提示即时构建完全自主的代理。它能够将提示拆解为可管理的任务，并组合多种工具、软件与 API 来完成工作，同时拥有由自我反思反馈回路增强的短期与长期记忆。 

然而，在实践过程中，他们必然意识到这种方法在生产场景中受限于 LLM 的固有不可预测性。

如今，AutoGPT 不再是“从提示到代理”的平台，而是更优秀的选择——一种将代理构建方式的控制权交到用户手中的低代码平台。如果您查看 1–2 年前的帖子或观看 YouTube 视频，就能看到从最初版本到 2025 年平台形态的转变。

那些文章展示的安装说明与工作流示例与我接下来要教您的内容截然不同。

话不多说，让我们看看如何在您的机器上设置该平台。

AutoGPT 的安装与配置

在本地设置 AutoGPT 需要正确配置开发环境并了解容器化工具——如需复习，请查看我们的课程 使用 Docker 和 Kubernetes 进行容器化与虚拟化。本节将从先决条件到首次运行平台的完整流程为您逐步讲解。

先决条件与环境准备

在安装 AutoGPT 之前，请确保具备以下先决条件：

1. Node.js 与 NPM

• Mac：
• brew install node
• Linux/WSL2：
• sudo apt update sudo apt install nodejs npm
• 验证安装：
• node -v npm -v

2. Docker 与 Docker Compose

• Mac：下载并安装 Docker Desktop
• Linux（WSL2 自带 Docker 内核，但仍需安装）：
• sudo apt update sudo apt install docker.io docker-compose sudo systemctl enable --now docker
• 验证安装：
• docker -v docker compose -v

3. Git

• Mac：
• brew install git
• Linux/WSL2：
• sudo apt update sudo apt install git

克隆 AutoGPT 仓库：

git clone https://github.com/Significant-Gravitas/AutoGPT.git技术支持

这些先决条件对于高效运行 AutoGPT 至关重要。Node.js 与 NPM 用于前端应用，使您能够通过友好的界面与 AutoGPT 交互。 

Docker 与 Docker Compose 会创建隔离容器，确保在不同系统上获得一致的性能，并简化后端服务的部署。Git 则使您能够克隆仓库并保持与最新改进同步。

完成此步骤后，您的机器上应已有 AutoGPT 目录，其中包含运行应用所需的一切。剩下的就是配置。

使用 Docker 进行本地托管 

Docker 为运行 AutoGPT 提供隔离且一致的环境，确保所有依赖在不同宿主系统上都能正确工作。

1. 设置后端服务

cd AutoGPT/autogpt_platform
cp .env.example .env
docker compose up -d --build技术支持

新的 .env 文件包含了合理默认值的环境变量。您并非必须自行配置该文件，但它的存在是必需的。当前端应用在创建自定义代理时需要提供各类密钥与凭据时，会使用到该文件。

最后的 docker compose 命令在首次运行时可能根据网络速度耗时最长约 15 分钟。它会设置前端将要连接的后端组件。

2. 设置前端应用

cd frontend
cp .env.example .env
npm install
npm run dev技术支持

这些命令会为前端创建环境文件，使用 Node.js 安装依赖，并启动界面。

3. 验证安装

• 通过 http://localhost:3000 访问 AutoGPT 界面
• 后端服务运行在以下端口：
• WebSocket 服务器：8001
• Execution API：8006

访问 3000 端口应显示应用市场（Marketplace）界面，您需在此创建账户并登录。

4. 自定义加密密钥（可选但推荐）

# 使用 Python 生成新密钥
from cryptography.fernet import Fernet
Fernet.generate_key().decode()

# 或使用内置 CLI
poetry run cli gen-encrypt-key技术支持

将 autogpt_platform/backend/.env 中的现有密钥替换为您的新密钥。

Windows 用户注意：在 Windows 上使用 Docker 时，安装过程中请选择 WSL 2 而非 Hyper-V，以避免与 Supabase 的兼容性问题。若已使用 Hyper-V 安装，可在 Docker Desktop 设置中切换为 WSL 2。

AutoGPT 用户界面概览

在创建可用代理之前，先熟悉一下 AutoGPT 的构建器界面。

界面是一个大的空白画布，包含四个主要按钮：

• Blocks（模块）
• 撤销/重做按钮
• 保存

单击“Blocks”将打开菜单，展示 AutoGPT 内置的可复用组件，并按类别分组。

这些模块提供了通用的关键工具，可广泛应用于多种代理场景。 

例如，下面我搜索并添加了两个模块——长文本输入与 AI 文本生成器。这两个组件足以复刻一个基础版的 ChatGPT 界面：

从图中可以看到，每个模块都有不同的可配置部分。输入模块包含模块名称与默认值字段；文本生成器包含提示词、模型与提示变量等字段。 

后者还有一个仅需填写一次的 OpenAI API 密钥输入框，您必须在运行代理之前提供（现在就填写）。API 密钥字段会根据所选模型而变化，AutoGPT 支持多数主流与小众厂商。

您会注意到，这两个模块都有小的边角（参见 3 与 5），可用于连接它们：

在上图中，我为输入模块命名（1）并设置默认值（2），然后将其文本结果（3）连接到文本生成器的提示词字段（4）。该连接创建了一个基础的代理工作流，在保存代理本身之后（步骤 5–8）即可执行。

点击运行后，您会看到输入字段的“运行设置”弹窗：

输入您的提示词并运行，即可获得如下首个输出：

您可能会注意到，模型响应在较大的文本生成模块中不便阅读。这也是 AutoGPT 提供代理输出模块的原因，我在下方将其添加进来：

请注意，我将文本生成器的响应字段连接到了代理输出模块的值。添加输出模块还可启用“Agent Outputs”面板，将来自不同模块的所有代理输出集中展示：

保存代理后，它会被存入您的库中。此外，整个代理随后还能作为一个模块在您创建的其他代理中复用。该模块化方法具有以下优势：

1. 可复用性：可在多个项目中复用复杂功能，而无需重复搭建。
2. 可组合性：可组合不同代理以创建更复杂的工作流。
3. 可维护性：更新原始代理后，所有将其作为模块使用的实例都能获益。
4. 抽象化：将复杂流程封装为单一模块，使主工作流更清晰、更易理解。
5. 协作：可与团队或社区共享专业化代理模块，加速开发。

这种搭积木式的方法使您能够通过层层叠加能力来创建更强大的 AI 系统。

在 AutoGPT 中用 Python 编写自定义模块

语法与通用流程概览

AutoGPT 的强大之处在于其模块化积木系统。尽管平台内置了许多实用模块，您仍可通过用 Python 创建自定义模块来扩展其能力。这样就能集成任何可通过编程方式访问的 API、服务或工具。

创建自定义模块的基本步骤如下：

1. 在 autogpt_platform/backend/backend/blocks 目录中创建新的 Python 文件，命名使用 snake_case
2. 定义继承自 Block 基类
3. 使用 BlockSchema 创建输入与输出模式以定义数据结构
4. 实现带唯一 ID 与测试数据的 __init__ 方法
5. 编写包含模块核心逻辑的 run 方法
6. 妥善处理错误，确保模块能优雅失败
7. 使用平台的测试基础设施 测试您的模块

下面我们逐一拆解各组件：

Block 类结构

每个模块必须继承 Block 基类，并定义其输入/输出模式：

from backend.data.block import Block, BlockSchema, BlockOutput

class MyCustomBlock(Block):
   class Input(BlockSchema):
       # Define input fields with types
       field1: str
       field2: int
      
   class Output(BlockSchema):
       # Define output fields with types
       result: str
       error: str  # Always include an error field
      
   def __init__(self):
       super().__init__(
           id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",  # Generate proper UUID
           input_schema=MyCustomBlock.Input,
           output_schema=MyCustomBlock.Output,
           test_input={"field1": "test", "field2": 42},
           test_output=("result", "expected output"),
           test_mock=None  # Only needed for external API calls
       )
      
   def run(self, input_data: Input, **kwargs) -> BlockOutput:
       try:
           # Your block logic here
           result = f"Processed {input_data.field1} and {input_data.field2}"
           yield "result", result
       except Exception as e:
           raise RuntimeError(f"Error in block: {str(e)}")技术支持

关键组成部分

1. 输入/输出模式：使用类型提示定义数据结构
2. UUID 生成：使用正确的 UUID 生成器（不要自行编造）
3. 测试数据：提供贴近实际的测试输入与期望输出
4. 错误处理：始终在 run 方法中包含恰当的错误处理
5. 结果产出：使用 yield 逐个输出结果

自定义模块示例

让我们创建一个使用 OpenAI API 执行情感分析的自定义模块示例，演示如何集成外部 AI 服务并安全处理 API 密钥。

OpenAI API 密钥设置说明

在使用该模块前，您需要设置 OpenAI API 密钥：

1. 安装所需包：

• pip install openai python-dotenv

2. 在 autogpt_platform/backend/blocks 目录创建 .env 文件，并写入您的 OpenAI API 密钥：

• OPENAI_API_KEY=your_api_key_here

现在，让我们创建该模块：

导入依赖并设置环境

首先处理导入与环境设置：

# autogpt_platform/backend/blocks/sentiment_analyzer.py
from backend.data.block import Block, BlockSchema, BlockOutput
from typing import Dict, Any, List
import os
from dotenv import load_dotenv
from openai import OpenAI
import json

# Load environment variables from .env file
load_dotenv()技术支持

此部分导入必要的库，并从 .env 文件加载环境变量。load_dotenv() 函数确保您可以通过 os.getenv() 访问 API 密钥。

定义模块模式并初始化

接着，我们定义包含输入与输出模式的模块类：

class OpenAISentimentBlock(Block):
   """Block to analyze sentiment of text using OpenAI API"""
  
   class Input(BlockSchema):
       text: str  # Text to analyze
       model: str = "gpt-3.5-turbo"  # OpenAI model to use
       detailed_analysis: bool = False  # Whether to return detailed analysis
      
   class Output(BlockSchema):
       sentiment: str  # Positive, Negative, or Neutral
       confidence: float  # Confidence score of the prediction
       explanation: str  # Brief explanation of the sentiment
       detailed_analysis: Dict[str, Any]  # Optional detailed analysis
       error: str  # Error message if analysis fails技术支持

输入模式定义了三个参数：

• text：待分析的文本（必填）
• model：要使用的 OpenAI 模型（默认为 "gpt-3.5-turbo"）
• detailed_analysis：是否返回更多细节（默认为 False）

输出模式定义了结果结构，包括情感类别、置信度、解释及可选的详细分析。

用测试数据初始化模块

__init__ 方法使用测试数据进行设置，并初始化 OpenAI 客户端：

def __init__(self):
   super().__init__(
       id="8f67d394-9f52-4352-a78b-175d5d1d7182",  # Generated UUID
       input_schema=OpenAISentimentBlock.Input,
       output_schema=OpenAISentimentBlock.Output,
       test_input={
           "text": "I really enjoyed this product, it exceeded my expectations!",
           "detailed_analysis": True
       },
       test_output=[
           ("sentiment", str),
           ("confidence", float),
           ("explanation", str),
           ("detailed_analysis", dict)
       ],
       test_mock={
           "_analyze_sentiment": lambda text, model, detailed: {
               "sentiment": "positive",
               "confidence": 0.92,
               "explanation": "The text expresses clear enjoyment and states that expectations were exceeded.",
               "detailed_analysis": {
                   "emotions": {
                       "joy": "high",
                       "satisfaction": "high",
                       "disappointment": "none"
                   },
                   "key_phrases": ["really enjoyed", "exceeded expectations"],
                   "tone": "enthusiastic"
               }
           }
       }
   )
   # Initialize OpenAI client
   api_key = os.getenv("OPENAI_API_KEY")
   if not api_key:
       raise RuntimeError("OpenAI API key not found. Please set OPENAI_API_KEY in .env file.")
   self.client = OpenAI(api_key=api_key)技术支持

该方法将：

• 设置贴近实际的测试输入与期望输出，用于测试
• 为情感分析函数提供 mock，避免测试时实际调用 API
• 使用环境变量中的 API 密钥初始化 OpenAI 客户端
• 在缺少 API 密钥时抛出错误

实现情感分析方法

核心功能在 _analyze_sentiment 方法中实现：

@staticmethod
def _analyze_sentiment(self, text: str, model: str, detailed: bool) -> Dict[str, Any]:
   """Analyze sentiment using OpenAI API"""
   # Create prompt based on whether detailed analysis is requested
   if detailed:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
       4. A detailed analysis including:
          - Key emotions detected and their intensity
          - Key phrases that influenced your assessment
          - Overall tone of the text
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation",
           "detailed_analysis": {
               "emotions": {"emotion1": "intensity", "emotion2": "intensity"},
               "key_phrases": ["phrase1", "phrase2"],
               "tone": "description of tone"
           }
       }
       """
   else:
       system_prompt = """
       You are a sentiment analysis expert. Analyze the following text and provide:
       1. The overall sentiment (positive, negative, or neutral)
       2. A confidence score from 0.0 to 1.0
       3. A brief explanation of your assessment
      
       Format your response as a JSON object with the following structure:
       {
           "sentiment": "positive|negative|neutral",
           "confidence": 0.0-1.0,
           "explanation": "brief explanation"
       }
       """
  
   try:
       # Make API call using the latest OpenAI API syntax
       response = self.client.chat.completions.create(
           model=model,
           response_format={"type": "json_object"},
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": text}
           ],
           temperature=0.2  # Low temperature for more consistent results
       )
      
       # Extract and parse JSON response
       content = response.choices[0].message.content
       result = json.loads(content)
      
       return result
      
   except Exception as e:
       raise RuntimeError(f"OpenAI API error: {str(e)}")技术支持

该方法将：

• 根据是否请求详细分析创建不同的系统提示词
• 使用 OpenAI API 生成结构化的情感分析结果
• 设置较低温度（0.2），以获得更一致的结果
• 解析 JSON 响应并返回
• 处理 API 调用过程中可能出现的异常

实现 run 方法

最后，由 run 方法将各部分串联起来：

def run(self, input_data: Input, **kwargs) -> BlockOutput:
   try:
       # Validate input
       if not input_data.text or not isinstance(input_data.text, str):
           raise ValueError("Text must be a non-empty string")
      
       # Process through OpenAI
       results = self._analyze_sentiment(
           input_data.text,
           input_data.model,
           input_data.detailed_analysis
       )
      
       # Yield the results
       yield "sentiment", results["sentiment"]
       yield "confidence", results["confidence"]
       yield "explanation", results["explanation"]
      
       # Only return detailed analysis if requested and available
       if input_data.detailed_analysis and "detailed_analysis" in results:
           yield "detailed_analysis", results["detailed_analysis"]
      
   except ValueError as e:
       raise RuntimeError(f"Input validation error: {str(e)}")
   except Exception as e:
       raise RuntimeError(f"Sentiment analysis failed: {str(e)}")技术支持

该方法将：

• 验证输入文本
• 用输入参数调用情感分析方法
• 使用 yield 逐一输出结果
• 仅在请求且可用时返回详细分析
• 以合适的信息处理不同类型的错误

该示例的关键要点

1. OpenAI API 集成：使用带 chat completions 端点的最新 OpenAI API 语法
2. 安全的 API 密钥处理：通过 dotenv 从环境变量加载密钥
3. 可定制分析：可根据偏好选择基础或详细的情感分析
4. 结构化输出：返回情感类别、置信度、解释与可选的详细分析
5. JSON 处理：处理来自 OpenAI 的结构化 JSON 响应
6. 测试策略：在测试中 mock OpenAI 调用，避免消耗实际 API 额度

该模块展示了如何集成最前沿的 AI 服务来增强代理能力。借助 OpenAI 集成，您可以实现难以用简单规则实现的复杂文本分析。

在编写自定义模块时，请始终考虑：

• 如何安全地处理 API 密钥
• 为 API 失败提供清晰的错误信息
• 设计可灵活使用的输入
• 将输出结构化，便于下游模块消费

关于创建自定义模块的更多细节（包括字段类型、认证、Webhook 集成与最佳实践），请参见 AutoGPT 官方模块文档。

结语

AutoGPT 通过直观的模块化界面，提供了创建与部署自主式 AI 代理的强大平台。本教程带您完整走通流程——从本地安装与配置，到理解界面、创建基础代理，再到用自定义模块扩展功能。 

借助 AutoGPT 的模块化架构，技术从业者无需深厚编码功底即可自动化复杂工作流，同时在需要时仍可灵活添加自定义能力。

如欲在此基础上进一步探索 AI 代理，请查阅 AutoGPT 官方文档；同时，DataCamp 还提供诸如 理解 AI 代理与 ChatGPT 基础等配套资源。 

此外，Introduction to GPTs 课程可帮助您夯实对大语言模型的理解，而 面向技术文档的 RAG 聊天机器人构建展示了 AI 代理的另一项实用应用。在持续尝试 AI 代理的过程中，您或许也想了解 Mistral Agents API、Dify AI 与 Langflow 等新工具。