# SuperAGI Agenten-Framework

## Überblick

[SuperAGI](https://github.com/TransformerOptimus/SuperAGI) ist ein Open-Source-, Entwickler-zentriertes Framework für autonome KI-Agenten mit über 15.000 GitHub-Sternen. Im Gegensatz zu einfachen Chatbots führt SuperAGI **autonome Agenten** — KI-Systeme, die eigenständig planen, mehrstufige Aufgaben ausführen, Werkzeuge nutzen und iterativ auf ein Ziel hinarbeiten, ohne ständige menschliche Eingaben.

**Warum SuperAGI auf Clore.ai betreiben?**

* **GPU-optional mit leistungsfähiger lokaler LLM-Unterstützung** — Führen Sie Agenten, die von lokalen Modellen (Llama, Mistral usw.) unterstützt werden, auf Clore.ai-GPUs für vollständig private, kostenkontrollierte autonome KI aus.
* **Gleichzeitige Agentenausführung** — Führen Sie mehrere Agenten parallel auf demselben Server aus, die gleichzeitig an unterschiedlichen Aufgaben arbeiten.
* **Persistenter Agentenspeicher** — Agenten behalten Kontext, lernen aus Werkzeugausgaben und speichern Langzeiterinnerungen in Vektor-Datenbanken zwischen den Läufen.
* **Werkzeug-Marktplatz** — Vorgefertigte Integrationen für Google Search, GitHub, E-Mail, Jira, Notion und mehr.
* **Clore.ai Ökonomie** — Bei etwa $0,20/Stunde für eine RTX 3090 können Sie leistungsfähige autonome Agenten zu einem Bruchteil der Kosten von Cloud-KI-Diensten betreiben.

### Hauptmerkmale

| Funktion                   | Beschreibung                                                         |
| -------------------------- | -------------------------------------------------------------------- |
| Agentenbereitstellung      | Erstellen, konfigurieren und bereitstellen von Agenten über eine GUI |
| Werkzeug-Marktplatz        | 30+ integrierte Werkzeuge (Suche, Code, Dateien, APIs)               |
| Multi-Modell-Unterstützung | OpenAI, Anthropic, lokale LLMs über benutzerdefinierte Endpunkte     |
| Gleichzeitige Agenten      | Führen Sie mehrere Agenten gleichzeitig aus                          |
| Agentenspeicher            | Kurzfristig (Kontextfenster) + langfristig (Vektor-DB)               |
| GUI-Dashboard              | Vollständige Weboberfläche zur Verwaltung von Agenten                |
| Ressourcenmanager          | Verfolgen Sie Tokenverbrauch und Kosten pro Agent                    |
| Workflow-Vorlagen          | Vorgefertigte Agentenvorlagen für gängige Aufgaben                   |

### Architektur

```
┌────────────────────────────────────────────────────┐
│              SuperAGI Stack                        │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  Frontend (Port 3000)│   │  API (Port 8001)  │   │
│  │   Next.js UI         │   │  FastAPI Backend   │   │
│  └──────────┬──────────┘   └─────────┬─────────┘   │
│             └──────────┬─────────────┘             │
│                        ▼                           │
│  ┌─────────────────────────────────────────────┐   │
│  │              Agent Executor                 │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │   │
│  │  │  Agent 1  │  │  Agent 2  │  │  Agent N  │  │   │
│  │  └──────────┘  └──────────┘  └──────────┘  │   │
│  └───────┬─────────────┬─────────────┬─────────┘   │
│          ▼             ▼             ▼             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐      │
│  │ PostgreSQL │  │  Redis    │  │  Vector   │      │
│  │  (State)  │  │  (Queue)  │  │    DB     │      │
│  └───────────┘  └───────────┘  └───────────┘      │
└────────────────────────────────────────────────────┘
          │
    ┌─────┴──────┐
    ▼            ▼
 OpenAI      Lokales LLM
 Anthropic   (Ollama/vLLM)
```

***

## Anforderungen

### Server-Spezifikationen

| Komponente   | Minimum            | Empfohlen              | Hinweise                                         |
| ------------ | ------------------ | ---------------------- | ------------------------------------------------ |
| **GPU**      | Keines (API-Modus) | RTX 3090 (lokale LLMs) | GPU erforderlich für lokale Modellausführung     |
| **VRAM**     | —                  | 24 GB                  | Zum Ausführen von lokalen Modellen ab 13B+       |
| **CPU**      | 4 vCPU             | 8 vCPU                 | Agentenausführung ist CPU-intensiv               |
| **RAM**      | 8 GB               | 16 GB                  | Mehrere gleichzeitige Agenten benötigen Speicher |
| **Speicher** | 20 GB              | 100+ GB                | Agentenprotokolle, Vektor-DB, Modellspeicher     |

### Clore.ai Preisinformationen

| Servertyp           | Ungefähre Kosten    | Einsatzgebiet                                   |
| ------------------- | ------------------- | ----------------------------------------------- |
| CPU (8 vCPU, 16 GB) | \~$0.10–0.20/Stunde | SuperAGI + externe API (OpenAI/Anthropic)       |
| RTX 3090 (24 GB)    | \~$0.20/Stunde      | SuperAGI + Ollama 13B lokales Modell            |
| RTX 4090 (24 GB)    | \~$0.35/Stunde      | SuperAGI + Ollama, schnellere Inferenz          |
| 2× RTX 3090         | \~$0.40/Stunde      | SuperAGI + 70B Modell (Q4 quantisiert)          |
| A100 80 GB          | \~$1.10/Stunde      | SuperAGI + große Modelle, hohe Gleichzeitigkeit |
| H100 80 GB          | \~$2.50/Stunde      | Produktionsreife autonome Agentensysteme        |

> 💡 **Kosten-Tipp:** Für Entwicklung und Tests verwenden Sie die OpenAI- oder Anthropic-APIs (keine GPU erforderlich). Wechseln Sie zu einer GPU-Instanz nur, wenn Sie lokale LLM-Inferenz aus Datenschutz- oder Kostengründen benötigen. Siehe [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison).

### Voraussetzungen

* Clore.ai-Server mit SSH-Zugang
* Docker + Docker Compose (vorinstalliert auf Clore.ai)
* Git (vorinstalliert)
* 4+ vCPU, 8+ GB RAM (16 GB empfohlen für gleichzeitige Agenten)
* OpenAI API-Schlüssel **oder** lokaler LLM-Endpunkt (Ollama/vLLM)

***

## Schnellstart

### Methode 1: Docker Compose (Offiziell — Empfohlen)

Die offizielle SuperAGI-Bereitstellung verwendet Docker Compose zur Verwaltung aller Dienste.

**Schritt 1: Verbinden Sie sich mit Ihrem Clore.ai-Server**

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

**Schritt 2: Klonen und konfigurieren**

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml
```

**Schritt 3: Bearbeiten `config.yaml`**

```bash
nano config.yaml
```

Mindestanforderung an die Konfiguration:

```yaml
# config.yaml
OPENAI_API_KEY: "sk-your-openai-key-here"

# Datenbank (für Docker Compose als Standard belassen)
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "password"

# Vektor-Datenbank
VECTOR_STORE: "Redis"  # oder "Pinecone", "Qdrant", "Weaviate"
REDIS_URL: "redis://super__agi-redis-1:6379/0"

# App-Einstellungen
ENV: "PROD"
ALLOW_LISTS_CREATION: "true"

# Optional: Zugriff einschränken
# AUTH_SECRET_KEY: "your-random-secret"
```

**Schritt 4: Stack starten**

```bash
docker compose up -d --build
```

Der Build-Prozess lädt Abhängigkeiten herunter und kompiliert das Frontend (\~5–10 Minuten beim ersten Lauf).

**Schritt 5: Start überwachen**

```bash
# Beobachten Sie, wie alle Dienste hochfahren
docker compose ps

# Logs verfolgen
docker compose logs -f

# Warten Sie auf "Application startup complete" in den Backend-Logs
docker compose logs superagi-backend --tail 30
```

**Schritt 6: Auf das Dashboard zugreifen**

```
http://<your-clore-server-ip>:3000
```

Die API ist verfügbar unter:

```
http://<your-clore-server-ip>:8001
```

API-Dokumentation:

```
http://<your-clore-server-ip>:8001/docs
```

***

### Methode 2: Schnellstart mit vorgefertigten Images

Für schnelleren Start mit vorgefertigten Images (überspringen Sie den Build-Schritt):

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml

# Konfigurieren Sie config mit Ihren API-Schlüsseln
nano config.yaml

# Verwenden Sie vorgefertigte Images, wenn verfügbar
docker compose -f docker-compose.yaml pull
docker compose up -d
```

***

### Methode 3: Minimale Ein-Modell-Installation

Eine vereinfachte Einrichtung zum Testen nur mit OpenAI:

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI

# Erstellen Sie eine minimale Konfiguration
cat > config.yaml << 'EOF'
OPENAI_API_KEY: "sk-your-key-here"
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "superagi_password_123"
REDIS_URL: "redis://super__agi-redis-1:6379/0"
ENV: "PROD"
EOF

docker compose up -d --build

# Überwachen Sie den Build-Fortschritt
docker compose logs superagi-frontend --tail 5 -f &
docker compose logs superagi-backend --tail 5 -f
```

***

## Konfiguration

### `config.yaml` Referenz

```yaml
# ============================================================
# LLM-Anbieter
# ============================================================
OPENAI_API_KEY: "sk-..."                    # OpenAI GPT-Modelle
ANTHROPIC_API_KEY: "sk-ant-..."            # Claude-Modelle

# Für lokale Modelle (Ollama oder OpenAI-kompatible API)
# In der UI einstellen: Einstellungen → Modelle → Benutzerdefiniertes Modell
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"  # Ollama auf demselben Host
OPENAI_MODEL: "llama3.1:8b"

# ============================================================
# Datenbank
# ============================================================
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "your-strong-password"

# ============================================================
# Vektor-Datenbank (Agenten-Langzeitspeicher)
# ============================================================
VECTOR_STORE: "Redis"       # Redis (Standard, integriert)
# Oder extern verwenden:
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "your-key"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

# VECTOR_STORE: "Weaviate"
# WEAVIATE_URL: "http://weaviate:8080"

# ============================================================
# Tool-API-Schlüssel (optional, für spezifische Werkzeuge)
# ============================================================
GOOGLE_API_KEY: "your-google-key"
GOOGLE_CUSTOM_SEARCH_ENGINE_ID: "your-cx-id"
GITHUB_TOKEN: "ghp_your-token"
JIRA_EMAIL: "your@email.com"
JIRA_API_TOKEN: "your-jira-token"
JIRA_SERVER_URL: "https://your-org.atlassian.net"

# ============================================================
# Speicher
# ============================================================
STORAGE_TYPE: "File"        # Lokaler Dateispeicher
# STORAGE_TYPE: "S3"        # S3-kompatibel (MinIO, AWS)
# BUCKET_NAME: "superagi"
# AWS_ACCESS_KEY_ID: "..."
# AWS_SECRET_ACCESS_KEY: "..."

# ============================================================
# Sicherheit
# ============================================================
JWT_SECRET_KEY: "your-random-secret-key"
```

### SuperAGI mit Werkzeugen verbinden

Werkzeuge werden über die GUI konfiguriert unter **Einstellungen → Toolkit**. Jedes Werkzeug kann pro Agent ein-/ausgeschaltet werden.

**Eingebaute Werkzeuge:**

| Tool            | Zweck                          | API-Schlüssel erforderlich |
| --------------- | ------------------------------ | -------------------------- |
| Google-Suche    | Websuche                       | Ja (Google API)            |
| DuckDuckGo      | Websuche                       | Nein                       |
| GitHub          | Zugriff auf Code-Repository    | Ja (GitHub-Token)          |
| E-Mail          | E-Mails senden/lesen           | Ja (SMTP-Konfiguration)    |
| Code Writer     | Code schreiben und ausführen   | Nein                       |
| Dateimanager    | Lokale Dateien lesen/schreiben | Nein                       |
| Browser         | Headless-Web-Browsing          | Nein                       |
| Jira            | Issue-Tracking                 | Ja                         |
| Notion          | Wissensdatenbank               | Ja                         |
| Bildgenerierung | DALL-E 3, Stable Diffusion     | Ja (OpenAI-Schlüssel)      |

### Erstellen Ihres ersten Agenten

Über die GUI (Einstellungen → Agents → Agent erstellen):

1. **Name** — Geben Sie Ihrem Agenten einen beschreibenden Namen
2. **Beschreibung** — Was dieser Agent tut
3. **Ziele** — Listen Sie die Ziele auf (jeweils eine pro Zeile)
4. **Anweisungen** — System-Prompt für das Verhalten
5. **Modell** — Wählen Sie LLM (GPT-4, Claude oder lokal)
6. **Werkzeuge** — Aktivieren Sie relevante Werkzeuge
7. **Maximale Iterationen** — Sicherheitsbegrenzung (typisch 10–50)

Über die REST-API:

```bash
# Erstellen Sie einen Agenten über die API
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Research Agent",
    "description": "Researches topics and writes summaries",
    "goal": [
      "Research the topic provided",
      "Write a comprehensive summary",
      "Save the summary to a file"
    ],
    "agent_type": "Task Queue",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "No exit criterion",
    "max_iterations": 25,
    "user_timezone": "UTC",
    "llm_model_config": {
      "model_name": "gpt-4o-mini",
      "temperature": 0.5,
      "max_new_tokens": 2000
    }
  }'
```

***

## GPU-Beschleunigung

SuperAGI unterstützt lokale LLM-Inferenz über jeden OpenAI-kompatiblen Endpunkt, was es ideal für GPU-gestützte Clore.ai-Bereitstellungen macht.

### Einrichtung von Ollama als Agent-LLM-Backend

Siehe [Ollama-Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) für die vollständige Ollama-Einrichtung. Integration mit SuperAGI:

**Schritt 1: Starten Sie Ollama auf demselben Clore.ai-Server**

```bash
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# Ziehen Sie ein leistungsfähiges Modell für den Agenteneinsatz (benötigt gutes Schlussfolgern)
docker exec ollama ollama pull llama3.1:8b        # Schnell, gutes Schlussfolgern
docker exec ollama ollama pull mistral:7b-instruct  # Code-Aufgaben
docker exec ollama ollama pull deepseek-coder:6.7b # Code-lastige Agenten
```

**Schritt 2: Konfigurieren Sie SuperAGI zur Nutzung von Ollama**

In `config.yaml`:

```yaml
# Zeigen Sie auf Ollama (läuft auf dem Docker-Host)
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"
```

Oder konfigurieren Sie es in der SuperAGI-UI:

* **Einstellungen → Modelle → Benutzerdefiniertes Modell hinzufügen**
* Anbieter: OpenAI-kompatibel
* Basis-URL: `http://172.17.0.1:11434/v1`
* API-Schlüssel: `ollama` (beliebiger String)
* Modellname: `llama3.1:8b`

### Einrichtung von vLLM für hochdurchsatzfähige Agenten

Für Produktionsbereitstellungen mit vielen gleichzeitigen Agenten (siehe [vLLM-Leitfaden](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)):

```bash
# Starten Sie vLLM auf dem GPU-Server
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your-token \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --served-model-name mistral-7b \
  --max-model-len 8192 \
  --enable-prefix-caching

# In config.yaml:
# OPENAI_API_BASE: "http://172.17.0.1:8000/v1"
```

### GPU-Bemessung für Agenten-Workloads

| Einsatzgebiet             | Modell              | GPU         | VRAM  | Gleichzeitige Agenten   |
| ------------------------- | ------------------- | ----------- | ----- | ----------------------- |
| Test                      | GPT-4o-mini (API)   | Keine       | —     | Unbegrenzt (drosselbar) |
| Leichte Agenten           | Llama 3.1 8B        | RTX 3090    | 8 GB  | 2–4                     |
| Schlussfolgerungsaufgaben | Mistral 7B Instruct | RTX 3090    | 6 GB  | 3–5                     |
| Komplexe Agenten          | Llama 3.1 70B Q4    | 2× RTX 3090 | 48 GB | 1–2                     |
| Produktion                | Llama 3.1 70B FP16  | A100 80GB   | 80 GB | 3–6                     |

***

## Tipps & bewährte Methoden

### Agenten-Design

* **Seien Sie spezifisch mit Zielen** — Vage Ziele wie "Recherchiere" führen dazu, dass Agenten in Schleifen geraten. Verwenden Sie "Recherchiere X und schreibe eine 500-Wörter-Zusammenfassung in die Datei output.txt."
* **Legen Sie Iterationslimits fest** — Setzen Sie immer `max_iterations` (20–50). Unbegrenzte Agenten können schnell Tokens verbrauchen.
* **Verwenden Sie den Task-Queue-Modus** — Für mehrstufige Pipelines sind "Task Queue"-Agenten zuverlässiger als der Modus "Don't Limit".
* **Testen Sie zuerst mit günstigen Modellen** — Validieren Sie die Agentenlogik mit GPT-4o-mini oder einem lokalen 7B-Modell, bevor Sie teure Modelle verwenden.

### Kostenmanagement auf Clore.ai

```bash
# Überwachen Sie den Tokenverbrauch in Echtzeit über das SuperAGI-Dashboard
# Einstellungen → Ressourcen → Token Usage

# Setzen Sie organisationsweite Limits in config.yaml
MAX_BUDGET_TOKENS: 100000  # Weiches Limit pro Sitzung
```

Da Clore.ai stündlich abrechnet:

```bash
# Speichern Sie Agentenkonfigurationen, bevor Sie die Instanz stoppen
docker compose exec superagi-backend \
  python -c "import json; from superagi.models import Agent; ..."

# Sichern Sie die PostgreSQL-Datenbank
docker compose exec super__agi-db-1 \
  pg_dump -U super_agi super_agi | gzip > superagi-db-$(date +%Y%m%d).sql.gz

# Kopieren Sie das Backup vom Server
scp -P <ssh-port> root@<server-ip>:~/SuperAGI/superagi-db-*.sql.gz ./
```

### Absicherung von SuperAGI

```bash
# Aktivieren Sie Authentifizierung in config.yaml
AUTH_SECRET_KEY: "your-strong-random-secret"

# Beschränken Sie die API auf localhost (verwenden Sie SSH-Tunnel)
# Ändern Sie docker-compose.yml, um externe Portbindung zu entfernen:
# ports:
#   - "127.0.0.1:8001:8001"  # API nur lokal
#   - "127.0.0.1:3000:3000"  # UI nur lokal

# Greifen Sie dann über einen SSH-Tunnel zu:
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>
```

### Persistenter Speicher zwischen Clore.ai-Sitzungen

```bash
# Erstellen Sie ein vollständiges Backup-Skript
cat > /root/backup-superagi.sh << 'EOF'
#!/bin/bash
cd ~/SuperAGI

# Datenbank sichern
docker compose exec -T super__agi-db-1 \
  pg_dump -U super_agi super_agi | \
  gzip > ~/backups/superagi-db-$(date +%Y%m%d-%H%M).sql.gz

# Konfiguration und Arbeitsbereiche sichern
tar -czf ~/backups/superagi-files-$(date +%Y%m%d-%H%M).tar.gz \
  config.yaml \
  workspace/ \
  .env 2>/dev/null || true

echo "Backup abgeschlossen: $(ls -lh ~/backups/ | tail -2)"
EOF

chmod +x /root/backup-superagi.sh
mkdir -p ~/backups
```

### Aktualisierung von SuperAGI

```bash
cd ~/SuperAGI

# Sichern Sie die aktuelle Konfiguration
cp config.yaml config.yaml.backup

# Neueste Änderungen ziehen
git pull origin main

# Neu bauen und neu starten
docker compose down
docker compose up -d --build

# Überprüfen Sie, ob alle Dienste gesund sind
docker compose ps
docker compose logs superagi-backend --tail 20
```

***

## Fehlerbehebung

### Build schlägt fehl während `docker compose up --build`

```bash
# Überprüfen Sie die Build-Logs im Detail
docker compose build superagi-backend --no-cache 2>&1 | tail -50

# Häufige Lösung: Geben Sie Festplattenspeicher frei
docker system prune -f
df -h  # Stellen Sie sicher, dass mindestens 10 GB frei sind

# Wenn npm-Build für das Frontend fehlschlägt
docker compose build superagi-frontend --no-cache

# Überprüfen Sie Node.js-Speicher während des Builds
docker compose build superagi-frontend \
  --build-arg NODE_OPTIONS="--max-old-space-size=4096"
```

### Backend stürzt beim Start ab

```bash
# Überprüfen Sie die Backend-Logs
docker compose logs superagi-backend --tail 50

# Häufige Ursachen:
# 1. Ungültige config.yaml-Syntax
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))" && echo "YAML OK"

# 2. Datenbank nicht bereit
docker compose restart superagi-backend  # Warten Sie zuerst auf den DB-Start

# 3. Fehlender API-Schlüssel
grep OPENAI_API_KEY config.yaml  # Stellen Sie sicher, dass er gesetzt und nicht leer ist
```

### Frontend lädt nicht (Port 3000)

```bash
# Überprüfen Sie den Frontend-Container
docker compose ps superagi-frontend
docker compose logs superagi-frontend --tail 30

# Überprüfen Sie die Portzuordnung
ss -tlnp | grep 3000

# Prüfen Sie, ob das API-Backend vom Frontend erreichbar ist
docker compose exec superagi-frontend \
  curl -s http://superagi-backend:8001/health
```

### Agenten laufen endlos in Schleifen

```bash
# Überprüfen Sie die Agenten-Logs in der SuperAGI-UI:
# Dashboard → Agent → Logs anzeigen

# Stoppen Sie einen laufenden Agenten zwangsweise über die API
curl -X POST "http://localhost:8001/v1/agent/<agent-id>/stop" \
  -H "Content-Type: application/json"

# Oder stoppen Sie alle Agenten über die DB
docker compose exec super__agi-db-1 \
  psql -U super_agi -c "UPDATE agent_executions SET status='COMPLETED' WHERE status='RUNNING';"
```

### Redis-Verbindungsfehler

```bash
# Überprüfen Sie den Redis-Status
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

# Testen Sie die Redis-Verbindung
docker compose exec superagi-backend \
  python3 -c "import redis; r=redis.from_url('redis://super__agi-redis-1:6379/0'); print(r.ping())"

# Neustart von Redis
docker compose restart super__agi-redis-1
```

### Ollama vom SuperAGI-Container nicht erreichbar

```bash
# Finden Sie die Docker-Bridge-IP
docker network inspect bridge | grep Gateway

# Testen Sie aus dem Backend-Container
docker compose exec superagi-backend \
  curl -s http://172.17.0.1:11434/v1/models

# Wenn Host-Netzwerk verwendet wird
docker run -d --network host ...  # Nicht leicht mit docker compose kompatibel

# Alternative: Fügen Sie Ollama zum selben Compose-Netzwerk hinzu
# Fügen Sie in docker-compose.yml Dienste hinzu:
# ollama:
#   image: ollama/ollama
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: all
#             capabilities: [gpu]
```

### Datenbank-Verbindungspool erschöpft

```bash
# Erhöhen Sie max_connections von PostgreSQL in docker-compose.yml
# Unter dem db-Service:
command: postgres -c max_connections=200

# Neustart der Datenbank
docker compose restart super__agi-db-1
docker compose restart superagi-backend
```

***

## Weiterführende Lektüre

* [SuperAGI-Dokumentation](https://superagi.com/docs) — offizielle Anleitungen, API-Referenz
* [SuperAGI GitHub](https://github.com/TransformerOptimus/SuperAGI) — Quellcode, Issues, Community
* [Ollama auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — lokales LLM-Backend für Agenten
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — hochdurchsatzfähige Inferenz für gleichzeitige Agenten
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — Auswahl des richtigen Clore.ai-Tiers
* [SuperAGI Werkzeug-Marktplatz](https://superagi.com/marketplace/) — Community-erstellte Agenten-Werkzeuge
* [SuperAGI Discord](https://discord.gg/dXbRe5BHJC) — Community-Support und Diskussionen
* [FastAPI Docs (SuperAGI API)](http://localhost:8001/docs) — interaktive API-Dokumentation auf Ihrer Instanz