> 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

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

## Ü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 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](https://clore.ai/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](https://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

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

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

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

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

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

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

```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 die gesamte LLM-Inferenz an externe Anbieter. 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 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:

```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 der RTX 3090 (\~30 tok/s) funktionieren, aber A100 80 GB ermöglicht schnellere Iterationen. 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            | 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

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

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

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

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

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

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

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

### Frontend zeigt „Verbindung zum Backend fehlgeschlagen“

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

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

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

```bash
# 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](https://docs.agpt.co)
* [AutoGPT-GitHub-Repository](https://github.com/Significant-Gravitas/AutoGPT)
* [Einrichtungsleitfaden für die AutoGPT-Plattform](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)
* [GPU-Vergleich von Clore.ai](/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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.