# AutoGPT Autonomer Agent

## Überblick

[AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) ist die wegweisende Open-Source-Plattform für autonome KI-Agenten, mit **175K+ GitHub-Sternen** — eines der am meisten mit Sternen versehenen Repositories 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-Agent-Orchestrierung und einer sich selbst verbessernden Agenten-Benchmark-Suite entwickelt.

Die aktuelle AutoGPT-Plattform besteht aus:

* **Frontend** — Next.js visueller Agenten-Builder (Port 3000)
* **Backend / API** — FastAPI-Service, der die Agentenausführung übernimmt (Port 8000)
* **Agenten-Ausführer** — Python-Worker, die autonome Aufgaben-Schleifen ausführen
* **Postgres** — persistenter Speicher für Agentenzustand und Ausführungen
* **Redis** — Job-Queue und Pub/Sub
* **Minio** — S3-kompatibler Objektspeicher für Agenten-Artefakte

An **Clore.ai**, AutoGPT läuft vollständig auf der CPU (es delegiert LLM-Aufrufe an Cloud-APIs), wodurch es erschwinglich ist bei **0,05–0,20 $/Std.**. Optional können lokale Modelle über die OpenAI-kompatible Provider-Unterstützung integriert werden.

**Wesentliche Funktionen:**

* 🤖 **Autonome Agenten** — Agenten zerlegen Aufgaben in Teilziele und führen sie iterativ aus
* 🌐 **Web-Browsing** — Agenten können das Web durchsuchen, Seiten scrapen und Informationen synthetisieren
* 💻 **Code-Ausführung** — sandboxed Python-Ausführungsumgebung für Coding-Agenten
* 📁 **Dateioperationen** — lesen, schreiben und verwalten von Dateien als Teil der Aufgabenausführung
* 🔗 **Multi-Agent** — spezialisierte Unteragenten erzeugen und hierarchisch orchestrieren
* 🧠 **Langzeitgedächtnis** — vektorbasiertes Gedächtnis, das über Sitzungen hinweg persistiert
* 📈 **Agenten-Benchmarking** — eingebaute AgentBenchmark-Suite zur Bewertung der Agentenleistung

***

## Anforderungen

Die Compute-Anforderungen 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      | \~$0.20/Stunde      |
| **+ Großes lokales LLM**   | A100 40 GB  | 40 GB | 32 GB      | 100 GB     | \~0,80 $/Std.       |

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

### API-Schlüssel erforderlich

Sie benötigen mindestens einen der folgenden:

* **OpenAI-API-Schlüssel** (GPT-4o empfohlen für beste Agentenleistung)
* **Anthropic-API-Schlüssel** (Claude 3.5 Sonnet ist ausgezeichnet für Agenten)
* **Google AI-Schlüssel** (Gemini-Modelle unterstützt)

***

## Schnellstart

### 1. Miete einen Clore.ai-Server

Melden Sie sich an bei [clore.ai](https://clore.ai) und starten Sie einen Server mit:

* **2+ CPU-Kerne, 8 GB RAM** Minimum
* Freigegebene Ports **8000** (Backend-API) und **3000** (Frontend)
* SSH-Zugriff aktiviert
* **20+ GB Festplattenspeicher**

### 2. Verbinden Sie sich mit dem Server

```bash
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

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

# Umgebungs-Template kopieren
cp .env.example .env

# Die Umgebungsdatei bearbeiten
nano .env
```

### 4. Erforderliche Umgebungsvariablen setzen

```bash
# Minimum erforderlich in .env:

# ── LLM Provider (wählen Sie mindestens einen) ────────────────────────────────────────
OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...

# ── Geheime Schlü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. Build und Start

```bash
# Images bauen und alle Services starten (erster Lauf dauert 5–10 Minuten)
docker compose up -d --build

# Build- und Startfortschritt beobachten
docker compose logs -f

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

### 6. Überprüfen, ob Services gesund sind

```bash
# Jeden Service prüfen
docker compose ps

# Erwartete laufende Services:
# autogpt_platform-db-1        Up (healthy)
# autogpt_platform-redis-1     Up
# autogpt_platform-minio-1     Up
# autogpt_platform-backend-1   Up
# autogpt_platform-frontend-1  Up
# autogpt_platform-executor-1  Up

# 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-Provider in den Einstellungen und beginnen Sie mit dem Erstellen von Agenten.

***

## Konfiguration

### Vollständig `.env` Referenz

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

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

# ── OpenAI-kompatibel (für lokale Modelle via Ollama/vLLM) ────────────────────
OPENAI_API_BASE=http://localhost:11434/v1   # Ollamas OpenAI-kompatibler Endpunkt
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 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 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-generieren>
NEXTAUTH_URL=http://<clore-server-ip>:3000
```

### Anpassen der Agenten-Fähigkeiten

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

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

# Zugriff auf das Dateisystem (Agenten-Arbeitsbereich)
WORKSPACE_PATH=/workspace
RESTRICT_TO_WORKSPACE=true
```

### Verwalten der Skalierung des Agenten-Ausführers

```bash
# 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 alle LLM-Inferenz an externe Provider. Um lokal GPU-beschleunigte Modelle zu verwenden:

### Mit Ollama auf demselben Server verbinden

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

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

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

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

In `.env`, richten Sie AutoGPT auf Ollama aus:

```bash
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 RTX 3090 (\~30 Tok/s) funktionieren, aber A100 80GB ermöglicht schnellere Iteration. Siehe [GPU-Vergleich](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison).

### Empfehlungen für lokale Modelle für Agenten

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

***

## Tipps & bewährte Methoden

### Kostenmanagement auf Clore.ai

```bash
# Die größte Kostenquelle von AutoGPT sind oft LLM-API-Aufrufe, nicht die Rechenleistung
# Token-Budgetlimits in der Agentenkonfiguration setzen:
# MAX_TOKENS_PER_RUN=100000
# MAX_COST_PER_RUN=1.00   # USD

# Agentenzustand sichern, bevor die Clore-Instanz gestoppt wird
docker exec autogpt_platform-db-1 \
  pg_dump -U postgres autogpt | gzip > autogpt-backup-$(date +%Y%m%d).sql.gz

# Auf lokale Maschine kopieren
scp -P <port> root@<ip>:autogpt-backup-*.sql.gz ./
```

### AutoGPT aktualisieren

```bash
cd AutoGPT

# Neueste Änderungen ziehen
git pull origin master

cd autogpt_platform

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

# DB-Migrationen ausführen, falls erforderlich
docker compose exec backend alembic upgrade head
```

### Agentenläufe überwachen

```bash
# Backend-Logs für Agentenaktivität beobachten
docker compose logs -f backend executor

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

# Agentenlauf-Historie über API anzeigen
curl http://localhost:8000/api/v1/runs | python3 -m json.tool
```

### Sicherheits-Härtung

```bash
# Ports 8000/3000 niemals ohne Auth direkt ins Internet exponieren
# Verwenden Sie Nginx oder Caddy als Reverse-Proxy mit HTTPS:

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

# Agentenzugriff auf das Dateisystem einschränken
RESTRICT_TO_WORKSPACE=true
WORKSPACE_PATH=/agent-workspace

# Benutzerregistrierung nach der Erstkonfiguration deaktivieren
ALLOW_SIGNUP=false
```

### Build-Zeiten optimieren

```bash
# Der erste Build ist langsam (~10 Min); nachfolgende Builds nutzen 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 Out-of-Memory-Fehler fehl

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

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

### Backend gibt 500 / "Database not ready" zurück

```bash
# 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, prüfen Sie DATABASE_URL in .env
docker compose exec backend printenv DATABASE_URL
```

### Frontend zeigt "Failed to connect to backend"

```bash
# Überprüfen Sie, 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 macht diese Anfrage)
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

# Frontend nach Änderung dieser Umgebungsvariablen neu bauen
docker compose up -d --build frontend
```

### Agenten-Ausführer crasht / wird OOM-getötet

```bash
# Speicherverbrauch prüfen
docker stats autogpt_platform-executor-1

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

# Oder gleichzeitige Agentenläufe reduzieren
MAX_CONCURRENT_RUNS=2
```

### Redis-Verbindung verweigert

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

# Konnektivität vom Backend testen
docker compose exec backend redis-cli -h redis ping
# Erwartet: PONG

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

### Agent steckt in einer Schleife fest

```bash
# AutoGPT-Agenten können manchmal in Endlosschleifen geraten
# Maximale Zyklusanzahl setzen:
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](https://docs.agpt.co)
* [AutoGPT GitHub-Repository](https://github.com/Significant-Gravitas/AutoGPT)
* [AutoGPT Plattform-Einrichtungsanleitung](https://docs.agpt.co/platform/getting-started)
* [Ollama auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)
* [Clore.ai GPU-Vergleich](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison)
* [AutoGPT Discord-Community](https://discord.gg/autogpt)