> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/autogpt.md).

# 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](/guides/guides_v2-de/erste-schritte/gpu-comparison.md).

### 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](/guides/guides_v2-de/sprachmodelle/ollama.md)
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md)
* [Clore.ai GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md)
* [AutoGPT Discord-Community](https://discord.gg/autogpt)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/autogpt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.