Auto-GPT 2026 复兴：原创自主智能体框架如何将设置时间缩短 80% — 全新安装指南

python --version
# Expected: Python 3.10.x or higher

# 用于克隆的 Git
git --version

# Docker（可选，用于沙箱执行）
docker --version

# 克隆仓库
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT

# 使用 pip 安装 —— 2026 年的安装程序自动处理依赖
pip install -e .

# 或使用安装脚本（推荐）
./setup.sh
# 这会安装依赖、配置默认路径并验证环境

# 复制示例配置
cp .env.example .env

# 使用你的 API 密钥编辑 .env
nano .env

# .env —— 最低所需配置
# OpenAI（默认）
OPENAI_API_KEY=sk-your-openai-key-here

# 或 Anthropic Claude
# ANTHROPIC_API_KEY=sk-ant-your-anthropic-key

# 或通过 ollama 使用本地模型
# OLLAMA_BASE_URL=http://localhost:11434
# OLLAMA_MODEL=llama3.2

# 内存后端
MEMORY_BACKEND=chroma
CHROMA_PERSIST_DIR=./data/memory

# 沙箱代码执行
EXECUTE_LOCAL_COMMANDS=False
DOCKER_CONTAINER_NAME=autogpt-sandbox

# 智能体设置
CONTINUOUS_MODE=True
CONTINUOUS_LIMIT=50  # 每次运行最大迭代次数

# 交互模式 —— 智能体在每一步请求确认
autogpt

# 连续模式 —— 自动运行直到迭代限制
autogpt --continuous

# 使用特定目标（单次模式）
autogpt --goal "Research the top 5 Python web frameworks in 2026 and write a comparison report"

# 使用本地模型
autogpt --llm ollama --model llama3.2

# 健康检查命令
autogpt --version
# Expected: autogpt 0.6.x

# 测试工具注册表
autogpt --test-tools
# Expected output: All 12 default tools loaded successfully

{
  "protocol_version": "2.1",
  "message_type": "task_delegate",
  "sender_id": "research_agent",
  "recipient_id": "writer_agent",
  "payload": {
    "task_id": "task_001",
    "task_description": "Write a summary of Python async frameworks",
    "context": {
      "source_material": "...",
      "target_length": 500,
      "style": "technical"
    },
    "deadline": "2026-05-19T12:00:00Z"
  },
  "timestamp": "2026-05-19T10:30:00Z"
}

# multi_agent_demo.py
from autogpt.agent import Agent
from autogpt.protocol import AgentProtocol
from autogpt.orchestrator import Orchestrator

# 创建专用智能体
researcher = Agent(
    name="researcher",
    role="Research specialist — finds and analyzes information from the web",
    llm_provider="openai",
    tools=["web_browse", "memory_search"]
)

writer = Agent(
    name="writer",
    role="Technical writer — creates clear, structured documentation",
    llm_provider="openai",
    tools=["file_ops", "memory_search"]
)

code_agent = Agent(
    name="code_agent",
    role="Python developer — writes and tests code",
    llm_provider="openai",
    tools=["code_execute", "file_ops", "shell_command"]
)

# 编排器管理通信
orchestrator = Orchestrator(agents=[researcher, writer, code_agent])

# 定义需要协作的复杂目标
result = orchestrator.run(
    goal="Research the latest Python async frameworks, write a comparison guide, "
         "and provide working code examples for each framework",
    max_iterations=30
)

print(result.final_output)

# 智能体可以动态地将子任务委托给其他智能体
class ResearchAgent(Agent):
    def handle_task(self, task):
        if task.complexity > 0.7:
            # 将写作委托给 writer 智能体
            return self.protocol.delegate(
                to="writer",
                task="summarize_research",
                context=self.gather_sources()
            )
        return self.execute(task)

# Auto-GPT 自动处理 JavaScript 渲染页面
# 并提取结构化数据

from autogpt.tools import WebBrowseTool

browser = WebBrowseTool()

# 导航并提取
result = browser.browse(
    url="https://docs.python.org/3/library/asyncio.html",
    extract_type="text",
    max_length=5000
)

print(result.content[:500])
# Output: The asyncio library is used to write concurrent code using...

# 处理表单和搜索
search_result = browser.search(
    query="Python async frameworks 2026 benchmark",
    engine="duckduckgo",
    num_results=5
)

for r in search_result.results:
    print(f"{r.title}: {r.url}")

from autogpt.tools import FileOpsTool

file_tool = FileOpsTool(sandbox_dir="./workspace")

# 读取文件
content = file_tool.read("data/input.txt")

# 写入并自动备份
file_tool.write("output/report.md", "# Analysis Results\n\n...")

# 分析代码
analysis = file_tool.analyze_code("src/app.py")
print(f"Lines: {analysis.line_count}, Functions: {analysis.function_count}")

# 代码在隔离的 Docker 容器中运行
from autogpt.tools import CodeExecuteTool

code_tool = CodeExecuteTool(container="autogpt-sandbox")

# 安全地执行 Python
result = code_tool.execute("""
import numpy as np

data = np.random.randn(1000)
print(f"Mean: {data.mean():.4f}")
print(f"Std: {data.std():.4f}")
""")

print(result.stdout)
# Output: Mean: 0.0123
#         Std: 0.9876

# 执行失败会被捕获并报告
if result.error:
    print(f"Error: {result.error}")

# 注册你自己的工具
from autogpt.tools import ToolRegistry

@ToolRegistry.register(
    name="send_slack",
    description="Send a notification to Slack",
    parameters={
        "channel": "string — Slack channel name",
        "message": "string — Message to send"
    }
)
def send_slack(channel: str, message: str) -> str:
    import requests
    webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
    requests.post(webhook_url, json={"channel": channel, "text": message})
    return f"Message sent to #{channel}"

# 现在智能体可以根据目标自动使用这个工具
# LLM 根据描述决定何时调用它

# Dockerfile.autogpt
FROM python:3.11-slim

WORKDIR /app

# 安装 Playwright 依赖
RUN apt-get update && apt-get install -y \
    chromium-driver \
    && rm -rf /var/lib/apt/lists/*

# 复制并安装
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN playwright install chromium

COPY . .

# 以连续模式运行，使用目标文件
CMD ["autogpt", "--continuous", "--goal-file", "/app/goals/main.json"]

# docker-compose.yml
version: "3.8"

services:
  autogpt:
    build:
      context: .
      dockerfile: Dockerfile.autogpt
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - MEMORY_BACKEND=chroma
      - CHROMA_HOST=chroma
      - CHROMA_PORT=8000
      - CONTINUOUS_MODE=True
      - CONTINUOUS_LIMIT=100
    volumes:
      - ./workspace:/app/workspace
      - ./goals:/app/goals
      - ./data:/app/data
    depends_on:
      - chroma
      - redis
    restart: unless-stopped

  chroma:
    image: chromadb/chroma:0.6.0
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

  # 可选：代码执行沙箱
  sandbox:
    image: python:3.11-slim
    command: tail -f /dev/null
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp

volumes:
  chroma_data:
  redis_data:

# 部署整个栈
docker-compose up -d

# 检查智能体日志
docker-compose logs -f autogpt

# 停止所有服务
docker-compose down

# autogpt-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: autogpt
spec:
  replicas: 1
  selector:
    matchLabels:
      app: autogpt
  template:
    metadata:
      labels:
        app: autogpt
    spec:
      containers:
      - name: autogpt
        image: autogpt:latest
        env:
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: autogpt-secrets
              key: openai-key
        - name: MEMORY_BACKEND
          value: "chroma"
        - name: CHROMA_HOST
          value: "chroma-service"
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"

# 定义专用智能体行为
from autogpt.agent import AgentConfig

config = AgentConfig(
    name="security_auditor",
    role="Security-focused code reviewer who checks for vulnerabilities",
    personality="meticulous, skeptical, thorough",
    constraints=[
        "Never execute code without reviewing it first",
        "Always check for SQL injection vulnerabilities",
        "Flag any use of eval() or exec()"
    ],
    allowed_tools=["file_ops", "code_execute", "web_browse"],
    max_iterations=25
)

agent = Agent(config=config)
result = agent.run("Audit the auth module in src/auth.py")

# 无需更改智能体代码即可切换 LLM 提供商
from autogpt.llm import LLMManager

# 使用 OpenAI
llm = LLMManager.create(provider="openai", model="gpt-4o")

# 切换到 Anthropic
llm = LLMManager.create(provider="anthropic", model="claude-sonnet-4-20250514")

# 使用本地模型
llm = LLMManager.create(provider="ollama", model="llama3.2", base_url="http://localhost:11434")

# 无论后端如何，智能体工作方式相同
agent = Agent(llm=llm)

# Auto-GPT 支持插件来扩展功能
# 将插件放在 plugins/ 目录中

# plugins/custom_logger.py
from autogpt.plugins import Plugin

class CustomLogger(Plugin):
    def on_agent_start(self, agent):
        print(f"[{agent.name}] Agent started with goal: {agent.goal}")

    def on_step_complete(self, agent, step, result):
        with open("agent_log.txt", "a") as f:
            f.write(f"[{agent.name}] Step {step}: {result.summary}\n")

    def on_agent_finish(self, agent, result):
        print(f"[{agent.name}] Agent finished. Final output length: {len(result.final_output)}")