> 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/superagi.md).

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

### 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](/guides/guides_v2-de/sprachmodelle/ollama.md) 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](/guides/guides_v2-de/sprachmodelle/vllm.md)):

```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](/guides/guides_v2-de/sprachmodelle/ollama.md) — lokales LLM-Backend für Agenten
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md) — hochdurchsatzfähige Inferenz für gleichzeitige Agenten
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — 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


---

# 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/superagi.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.