AutoGPT autonomer Agent

Deploye AutoGPT auf Clore.ai — betreibe die ursprüngliche autonome KI-Agenten-Plattform mit Web-Browsing, Code-Ausführung und langfristiger Aufgabenautomatisierung.

Überblick

AutoGPT ist die wegweisende Open-Source-Plattform für autonome KI-Agenten, mit 175K+ GitHub-Sternen — eines der Repositories mit den meisten Sternen auf GitHub. Ursprünglich ein Python-CLI-Tool, das 2023 viral ging, hat sich AutoGPT zu einer voll ausgestatteten Plattform mit Web-Frontend, visuellem Workflow-Builder, Multi-Agenten-Orchestrierung und einer Benchmark-Suite zur Selbstverbesserung von Agenten entwickelt.

Die aktuelle AutoGPT-Plattform besteht aus:

• Frontend — visueller Agenten-Builder auf Basis von Next.js (Port 3000)

• Backend / API — FastAPI-Dienst, der die Ausführung von Agenten verarbeitet (Port 8000)

• Agenten-Executor — Python-Worker, die autonome Aufgabenzyklen ausführen

• Postgres — persistenter Speicher für Agentenzustand und Läufe

• Redis — Job-Queue und Pub/Sub

• Minio — S3-kompatibler Objektspeicher für Agenten-Artefakte

Auf Clore.ai, läuft AutoGPT vollständig auf der CPU (es delegiert LLM-Aufrufe an Cloud-APIs), wodurch es kostengünstig ist bei $0,05–0,20/Std.. Sie können optional lokale Modelle über die Unterstützung für OpenAI-kompatible Anbieter integrieren.

Wichtige Funktionen:

• 🤖 Autonome Agenten — Agenten zerlegen Aufgaben in Teilziele und führen sie iterativ aus

• 🌐 Web-Browsing — Agenten können im Web suchen, Seiten scrapen und Informationen zusammenfassen

• 💻 Codeausführung — sandboxierte Python-Ausführungsumgebung für Coding-Agenten

• 📁 Dateioperationen — Dateien lesen, schreiben und verwalten als Teil der Aufgabenausführung

• 🔗 Multi-Agent — spezialisierte Unteragenten erzeugen und hierarchisch orchestrieren

• 🧠 Langzeitgedächtnis — vektorbasiertes Gedächtnis, das sitzungsübergreifend gespeichert wird

• 📈 Agenten-Benchmarking — integrierte AgentBenchmark-Suite zur Bewertung der Agentenleistung

---

Anforderungen

Die Rechenanforderungen von AutoGPT hängen davon ab, ob Sie Cloud-LLM-APIs (Standard) oder lokale Modelle verwenden. Die Plattform selbst ist leichtgewichtig.

Konfiguration	GPU	VRAM	System-RAM	Festplatte	Clore.ai-Preis
Minimal (Cloud-APIs)	Keine / CPU	—	4 GB	20 GB	~0,05 $/Std. (CPU)
Standard	Keine / CPU	—	8 GB	40 GB	~0,08 $/Std.
Empfohlen	Keine / CPU	—	16 GB	60 GB	~0,12 $/Std.
+ Lokales LLM (Ollama)	RTX 3090	24 GB	16 GB	80 GB	ca. 0,07–0,21 $/h
+ großes lokales LLM	A100 40 GB	40 GB	32 GB	100 GB	Bare Metal

Hinweis: AutoGPT verwendet standardmäßig API-basierte LLMs (OpenAI GPT-4, Anthropic Claude usw.). Eine GPU ist nur dann nützlich, wenn Sie über Ollama oder einen anderen OpenAI-kompatiblen Server einen lokalen Modell-Endpunkt konfigurieren.

API-Schlüssel erforderlich

Sie benötigen mindestens einen von:

• OpenAI-API-Schlüssel (GPT-4o wird für die beste Agentenleistung empfohlen)

• Anthropic-API-Schlüssel (Claude 3.5 Sonnet ist ausgezeichnet für Agenten)

• Google AI-Schlüssel (Gemini-Modelle werden unterstützt)

---

Schnellstart

1. Miete einen Clore.ai-Server

Anmelden bei clore.ai und einen Server mit starten:

• 2+ CPU-Kerne, 8 GB RAM Minimum

• Freigegebene Ports 8000 (Backend-API) und 3000 (Frontend)

• SSH-Zugriff aktiviert

• 20+ GB Speicherplatz

2. Mit dem Server verbinden

ssh root@<clore-server-ip> -p <ssh-port>

# Pakete aktualisieren
apt-get update && apt-get upgrade -y

# Docker und Compose überprüfen
docker --version
docker compose version   # Muss v2.x sein

3. AutoGPT klonen und konfigurieren

# Das Repository klonen
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform

# Umgebungsvorlage kopieren
cp .env.example .env

# Die Umgebungsdatei bearbeiten
nano .env

4. Erforderliche Umgebungsvariablen festlegen

# Mindestanforderungen in .env:

# ── LLM-Anbieter (mindestens einen auswählen) ───────────────────────────────
OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...

# ── Geheimschlüssel (DIESE ÄNDERN) ──────────────────────────────────────────
APP_SECRET_KEY=$(openssl rand -hex 32)
JWT_SECRET_KEY=$(openssl rand -hex 32)

# ── Datenbank ───────────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt

# ── Backend-URL (auf Ihre Clore-Server-IP setzen) ───────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

5. Erstellen und starten

# Bilder erstellen und alle Dienste starten (der erste Lauf dauert 5–10 Minuten)
docker compose up -d --build

# Den Fortschritt von Build und Start überwachen
docker compose logs -f

# Nach dem Start prüfen, ob alle Container laufen
docker compose ps

6. Dienste auf Gesundheit prüfen

# Jeden Dienst prüfen
docker compose ps

# Erwartete laufende Dienste:
# autogpt_platform-db-1        Läuft (gesund)
# autogpt_platform-redis-1     Läuft
# autogpt_platform-minio-1     Läuft
# autogpt_platform-backend-1   Läuft
# autogpt_platform-frontend-1  Läuft
# autogpt_platform-executor-1  Läuft

# Backend-API testen
curl http://localhost:8000/api/health
# Erwartet: {"status": "ok"}

7. Auf AutoGPT zugreifen

Öffnen Sie Ihren Browser:

• Frontend: http://<clore-server-ip>:3000

• Backend-API: http://<clore-server-ip>:8000

• API-Dokumentation (Swagger): http://<clore-server-ip>:8000/docs

Erstellen Sie ein Konto im Frontend, konfigurieren Sie Ihren LLM-Anbieter in den Einstellungen und beginnen Sie mit dem Erstellen von Agenten.

---

Konfiguration

Vollständige .env Referenz

# ── Anwendung ──────────────────────────────────────────────────────────────
ENVIRONMENT=production
APP_SECRET_KEY=<mit-openssl-rand-hex-32-erzeugen>
JWT_SECRET_KEY=<mit-openssl-rand-hex-32-erzeugen>
ALLOWED_ORIGINS=http://<clore-server-ip>:3000

# ── LLM-Anbieter ────────────────────────────────────────────────────────────
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GROQ_API_KEY=gsk_...

# ── OpenAI-kompatibel (für lokale Modelle über Ollama/vLLM) ────────────────
OPENAI_API_BASE=http://localhost:11434/v1   # OpenAI-kompatibler Endpunkt von Ollama
OPENAI_API_KEY=ollama                        # Platzhalter-Schlüssel für Ollama

# ── Datenbank ───────────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password    # In der Produktion ändern!
POSTGRES_DB=autogpt

# ── Redis (Job-Queue) ───────────────────────────────────────────────────────
REDIS_URL=redis://redis:6379/0

# ── Minio (Objektspeicher) ──────────────────────────────────────────────────
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=minioadmin   # In der Produktion ändern!
MINIO_URL=http://minio:9000

# ── Frontend ─────────────────────────────────────────────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
NEXTAUTH_SECRET=<mit-openssl-rand-hex-32-erzeugen>
NEXTAUTH_URL=http://<clore-server-ip>:3000

Anpassen der Agentenfähigkeiten

# Web-Browsing-Fähigkeit aktivieren
WEB_BROWSER_ENABLED=true
SELENIUM_CHROME_DRIVER_URL=http://selenium:4444/wd/hub

# Selenium für Web-Browsing zu docker-compose hinzufügen:
# services:
#   selenium:
#     image: selenium/standalone-chrome:latest
#     shm_size: 2gb
#     ports:
#       - "4444:4444"

# Dateisystemzugriff (Arbeitsbereich des Agenten)
WORKSPACE_PATH=/workspace
RESTRICT_TO_WORKSPACE=true

Skalierung des Agenten-Executors verwalten

# Executor-Worker für parallele Agentenläufe skalieren
docker compose up -d --scale executor=4

# Executor-Logs überwachen
docker compose logs -f executor

---

GPU-Beschleunigung

AutoGPT delegiert standardmäßig die gesamte LLM-Inferenz an externe Anbieter. Um lokal GPU-beschleunigte Modelle zu verwenden:

Mit Ollama auf demselben Server verbinden

# Ollama auf dem Clore-Server installieren
curl -fsSL https://ollama.com/install.sh | sh

# Ein leistungsfähiges Modell herunterladen (Llama 3 70B benötigt A100, 8B läuft auf RTX 3090)
ollama pull llama3:8b
# Für die beste Agentenleistung:
ollama pull llama3.1:70b   # Erfordert A100 40 GB+

# Ollama für Docker-Container zugänglich machen
OLLAMA_HOST=0.0.0.0 ollama serve &

# Den OpenAI-kompatiblen Endpunkt testen
curl http://localhost:11434/v1/models

In .env, AutoGPT auf Ollama verweisen:

OPENAI_API_BASE=http://host.docker.internal:11434/v1
OPENAI_API_KEY=ollama
OPENAI_DEFAULT_MODEL=llama3.1:70b

Leistungshinweis: Autonome Agenten führen viele sequentielle LLM-Aufrufe aus. Lokale Modelle auf der RTX 3090 (~30 tok/s) funktionieren, aber A100 80 GB ermöglicht schnellere Iterationen. Siehe GPU-Vergleich.

Empfehlungen für lokale Modelle für Agenten

Modell	Agentenqualität	VRAM	Clore-GPU
Llama 3 8B	Gut	8 GB	RTX 3080
Llama 3.1 8B Instruct	Gut	8 GB	RTX 3080
Llama 3.1 70B	Hervorragend	40 GB	A100 40GB
Mixtral 8x7B	Gut	24 GB	RTX 3090
Qwen 2.5 72B	Hervorragend	40 GB	A100 40GB

---

Tipps & bewährte Praktiken

Kostenmanagement auf Clore.ai

# Die größten Kosten von AutoGPT sind oft LLM-API-Aufrufe, nicht die Rechenleistung
# Token-Budget-Grenzen in der Agentenkonfiguration festlegen:
# MAX_TOKENS_PER_RUN=100000
# MAX_COST_PER_RUN=1.00   # USD

# Agentenzustand vor dem Stoppen der Clore-Instanz sichern
docker exec autogpt_platform-db-1 \
  pg_dump -U postgres autogpt | gzip > autogpt-backup-$(date +%Y%m%d).sql.gz

# Auf den lokalen Rechner kopieren
scp -P <port> root@<ip>:autogpt-backup-*.sql.gz ./

AutoGPT aktualisieren

cd AutoGPT

# Neueste Änderungen abrufen
git pull origin master

cd autogpt_platform

# Mit neuem Code neu erstellen
docker compose down
docker compose up -d --build

# Falls nötig DB-Migrationen ausführen
docker compose exec backend alembic upgrade head

Agentenläufe überwachen

# Backend-Logs auf Agentenaktivität überwachen
docker compose logs -f backend executor

# Systemressourcen während der Agentenläufe überwachen
htop
# oder
docker stats

# Verlauf der Agentenläufe über die API anzeigen
curl http://localhost:8000/api/v1/runs | python3 -m json.tool

Härtung der Sicherheit

# Ports 8000/3000 NIEMALS ohne Authentifizierung direkt dem Internet aussetzen
# Nginx oder Caddy als Reverse-Proxy mit HTTPS verwenden:

# Caddyfile:
# autogpt.yourdomain.com {
#     reverse_proxy localhost:3000
# }
# api.autogpt.yourdomain.com {
#     reverse_proxy localhost:8000
# }

# Dateisystemzugriff des Agenten einschränken
RESTRICT_TO_WORKSPACE=true
WORKSPACE_PATH=/agent-workspace

# Benutzerregistrierung nach der Ersteinrichtung deaktivieren
ALLOW_SIGNUP=false

Build-Zeiten optimieren

# Der erste Build ist langsam (~10 Min.); nachfolgende Builds verwenden den Cache
# BuildKit für schnellere Builds verwenden:
DOCKER_BUILDKIT=1 docker compose up -d --build

# Basis-Images vorab ziehen, um Builds zu beschleunigen
docker pull python:3.11-slim
docker pull node:20-alpine

---

Fehlerbehebung

Build schlägt mit Speicherfehler aufgrund von Out-of-Memory fehl

# Docker-Build benötigt ausreichend Speicher (4 GB+)
# Falls nötig Swap-Speicher hinzufügen:
fallocate -l 8G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# Permanent machen
echo '/swapfile none swap sw 0 0' >> /etc/fstab

Backend gibt 500 / „Datenbank noch nicht bereit“ zurück

# DB-Gesundheit prüfen
docker compose ps db
docker compose logs db

# DB-Migrationen manuell ausführen
docker compose exec backend alembic upgrade head

# Wenn Migrationen fehlschlagen, DATABASE_URL in .env prüfen
docker compose exec backend printenv DATABASE_URL

Frontend zeigt „Verbindung zum Backend fehlgeschlagen“

# Prüfen, ob NEXT_PUBLIC_AGPT_SERVER_URL korrekt gesetzt ist
grep NEXT_PUBLIC_AGPT_SERVER_URL .env

# Muss die öffentliche IP sein, nicht localhost (der Browser sendet diese Anfrage)
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

# Frontend nach Änderung dieser Umgebungsvariable neu erstellen
docker compose up -d --build frontend

Agenten-Executor stürzt ab / wird wegen OOM beendet

# Speichernutzung prüfen
docker stats autogpt_platform-executor-1

# Executor-Speicher begrenzen und Wiederstart-Richtlinie hinzufügen
# In docker-compose.yaml:
#   executor:
#     mem_limit: 2g
#     restart: unless-stopped

# Oder gleichzeitige Agentenläufe reduzieren
MAX_CONCURRENT_RUNS=2

Redis-Verbindung abgelehnt

# Prüfen, ob Redis läuft
docker compose ps redis
docker compose logs redis

# Verbindung vom Backend aus testen
docker compose exec backend redis-cli -h redis ping
# Erwartet: PONG

# Falls Redis Authentifizierung erfordert, setzen Sie:
REDIS_URL=redis://:password@redis:6379/0

Agent steckt in einer Schleife fest

# AutoGPT-Agenten können manchmal in Endlosschleifen geraten
# Ein maximales Zykluslimit festlegen:
MAX_AGENT_CYCLES=50

# Oder einen laufenden Agenten über die API unterbrechen:
curl -X POST http://localhost:8000/api/v1/runs/<run-id>/stop

---

Weiterführende Lektüre

• Offizielle AutoGPT-Dokumentation

• AutoGPT-GitHub-Repository

• Einrichtungsleitfaden für die AutoGPT-Plattform

• Ollama auf Clore.ai ausführen

• vLLM auf Clore.ai ausführen

• GPU-Vergleich von Clore.ai

• AutoGPT-Discord-Community