> 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-Agenten-Framework

Deploye SuperAGI auf Clore.ai — ein entwicklerorientiertes autonomes KI-Agenten-Framework mit GUI-Dashboard, Tool-Marktplatz, parallelen Agenten und optionaler lokaler LLM-Unterstützung auf leistungsstarken GPU-Cloud-Servern.

## Überblick

[SuperAGI](https://github.com/TransformerOptimus/SuperAGI) ist ein quelloffenes, entwicklerorientiertes 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 unabhängig mehrstufige Aufgaben planen, ausführen, Werkzeuge verwenden und sich ohne ständigen menschlichen Input einem Ziel annähern.

**Warum SuperAGI auf Clore.ai ausführen?**

* **GPU optional mit leistungsstarker lokaler LLM-Unterstützung** — Führen Sie von lokalen Modellen (Llama, Mistral usw.) gestützte Agenten auf Clore.ai-GPUs aus, für vollständig private, kostengesteuerte autonome KI.
* **Gleichzeitige Ausführung von Agenten** — Führen Sie mehrere Agenten parallel auf demselben Server aus, wobei jeder gleichzeitig an unterschiedlichen Aufgaben arbeitet.
* **Persistentes Agentengedächtnis** — Agenten behalten den Kontext bei, lernen aus Tool-Ausgaben und speichern zwischen Läufen Langzeitgedächtnis in Vektordatenbanken.
* **Tool-Marktplatz** — Vorgefertigte Integrationen für Google Search, GitHub, E-Mail, Jira, Notion und mehr.
* **Clore.ai-Ökonomie** — Für 0,07–0,21 $/Std. für eine RTX 3090 können Sie leistungsfähige autonome Agenten zu einem Bruchteil der Kosten von Cloud-KI-Diensten betreiben.

### Hauptfunktionen

| Funktion                          | Beschreibung                                                     |
| --------------------------------- | ---------------------------------------------------------------- |
| Bereitstellung von Agenten        | Agenten über GUI erstellen, konfigurieren und bereitstellen      |
| Tool-Marktplatz                   | 30+ integrierte Tools (Suche, Code, Dateien, APIs)               |
| Unterstützung für mehrere Modelle | OpenAI, Anthropic, lokale LLMs über benutzerdefinierten Endpunkt |
| Gleichzeitige Agenten             | Mehrere Agenten gleichzeitig ausführen                           |
| Agentengedächtnis                 | Kurzfristig (Kontextfenster) + langfristig (Vektor-DB)           |
| GUI-Dashboard                     | Vollständige Weboberfläche für die Agentenverwaltung             |
| Ressourcenmanager                 | Token-Nutzung und Kosten pro Agent verfolgen                     |
| Workflow-Vorlagen                 | Vorgefertigte Agentenvorlagen für häufige Aufgaben               |

### Architektur

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

***

## Anforderungen

### Serverspezifikationen

| Komponente   | Minimum           | Empfohlen              | Hinweise                                           |
| ------------ | ----------------- | ---------------------- | -------------------------------------------------- |
| **GPU**      | Keine (API-Modus) | RTX 3090 (lokale LLMs) | GPU für die lokale Modellinferenz erforderlich     |
| **VRAM**     | —                 | 24 GB                  | Für den Betrieb lokaler 13B+-Modelle               |
| **CPU**      | 4 vCPU            | 8 vCPU                 | Die Ausführung von Agenten ist CPU-intensiv        |
| **RAM**      | 8 GB              | 16 GB                  | Mehrere gleichzeitige Agenten benötigen Speicher   |
| **Speicher** | 20 GB             | 100+ GB                | Agentenprotokolle, Vektordatenbank, Modellspeicher |

### Clore.ai-Preisreferenz

| Servertyp           | Ca. Kosten                                | Anwendungsfall                                 |
| ------------------- | ----------------------------------------- | ---------------------------------------------- |
| CPU (8 vCPU, 16 GB) | \~0,10–0,20 $/Std.                        | SuperAGI + externe API (OpenAI/Anthropic)      |
| RTX 3090 (24 GB)    | ca. 0,07–0,21 $/h                         | SuperAGI + lokales Ollama-13B-Modell           |
| RTX 4090 (24 GB)    | ca. 0,14–0,42 $/h                         | SuperAGI + Ollama, schnellere Inferenz         |
| 2× RTX 3090         | ca. 0,14–0,42 $/h                         | SuperAGI + 70B-Modell (Q4-quantisiert)         |
| A100 80 GB          | [Bare Metal](https://clore.ai/bare-metal) | SuperAGI + große Modelle, hohe Parallelität    |
| H100 80 GB          | \~$1.04/hr                                | Autonome Agentensysteme in Produktionsqualität |

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

### Voraussetzungen

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

***

## Schnellstart

### Methode 1: Docker Compose (offiziell — empfohlen)

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

**Schritt 1: Mit Ihrem Clore.ai-Server verbinden**

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

Mindestkonfiguration:

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

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

# Vektordatenbank
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: Starten Sie den Stack**

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

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

**Schritt 5: Start überwachen**

```bash
# Beobachten, wie alle Dienste hochkommen
docker compose ps

# Protokolle verfolgen
docker compose logs -f

# Warten, bis "Application startup complete" in den Backend-Protokollen erscheint
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 einen schnelleren Start mit vorgefertigten Images (Build-Schritt überspringen):

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

# Konfigurieren Sie die API-Schlüssel in der config
nano config.yaml

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

***

### Methode 3: Minimales Einzelmodell-Setup

Ein schlankes Setup zum Testen nur mit OpenAI:

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

# Minimale Konfiguration erstellen
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

# Build-Fortschritt überwachen
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)
# Im UI festlegen: 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"

# ============================================================
# Vektordatenbank (Langzeitgedächtnis des Agenten)
# ============================================================
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 bestimmte Tools)
# ============================================================
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"        # Lokale Dateispeicherung
# 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 Tools verbinden

Tools werden über die GUI unter **Einstellungen → Toolkit**. konfiguriert. Jedes Tool kann pro Agent aktiviert/deaktiviert werden.

**Integrierte Tools:**

| Tool            | Zweck                          | API-Schlüssel erforderlich |
| --------------- | ------------------------------ | -------------------------- |
| Google-Suche    | Websuche                       | Ja (Google API)            |
| DuckDuckGo      | Websuche                       | Nein                       |
| GitHub          | Zugriff auf Code-Repositories  | 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            | Vorgangsverfolgung             | Ja                         |
| Notion          | Wissensdatenbank               | Ja                         |
| Bildgenerierung | DALL-E 3, Stable Diffusion     | Ja (OpenAI-Schlüssel)      |

### Ihren ersten Agenten erstellen

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

1. **Name** — Geben Sie Ihrem Agenten einen aussagekräftigen Namen
2. **Beschreibung** — Was dieser Agent tut
3. **Ziele** — Listen Sie die Ziele auf (eins pro Zeile)
4. **Anweisungen** — System-Prompt für das Verhalten
5. **Modell** — LLM auswählen (GPT-4, Claude oder lokal)
6. **Tools** — Relevante Tools aktivieren
7. **Maximale Iterationen** — Sicherheitsgrenze (typisch 10–50)

Über die REST-API:

```bash
# Einen Agenten per API erstellen
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \\
  -d '{
    "name": "Research Agent",
    "description": "Recherchiert Themen und schreibt Zusammenfassungen",
    "goal": [
      "Das bereitgestellte Thema recherchieren",
      "Eine umfassende Zusammenfassung schreiben",
      "Die Zusammenfassung in einer Datei speichern"
    ],
    "agent_type": "Task Queue",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "Kein Ausstiegskriterium",
    "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 die lokale LLM-Inferenz über jeden OpenAI-kompatiblen Endpunkt und ist damit ideal für GPU-gestützte Clore.ai-Bereitstellungen.

### Ollama als LLM-Backend des Agenten einrichten

Siehe [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md) für das vollständige Ollama-Setup. Integration mit SuperAGI:

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

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

# Ein leistungsfähiges Modell für die Agentennutzung herunterladen (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-intensive Agenten
```

**Schritt 2: SuperAGI für die Verwendung von Ollama konfigurieren**

In `config.yaml`:

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

Oder im SuperAGI-UI konfigurieren:

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

### vLLM für Agenten mit hohem Durchsatz einrichten

Für Produktionsbereitstellungen mit vielen gleichzeitigen Agenten (siehe [vLLM-Anleitung](/guides/guides_v2-de/sprachmodelle/vllm.md)):

```bash
# vLLM auf GPU-Server starten
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-Dimensionierung für Agenten-Workloads

| Anwendungsfall            | Modell              | GPU         | VRAM  | Gleichzeitige Agenten     |
| ------------------------- | ------------------- | ----------- | ----- | ------------------------- |
| Testen                    | GPT-4o-mini (API)   | Keine       | —     | Unbegrenzt (ratebegrenzt) |
| 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 Praktiken

### Agentendesign

* **Seien Sie bei Zielen präzise** — Vage Ziele wie "recherchiere etwas" führen dazu, dass Agenten in Schleifen geraten. Verwenden Sie "Recherchiere X und schreibe eine Zusammenfassung mit 500 Wörtern in die Datei output.txt."
* **Iterationslimits festlegen** — Immer festlegen `max_iterations` (20–50). Unbegrenzte Agenten können schnell Tokens verbrauchen.
* **Task-Queue-Modus verwenden** — Für mehrstufige Pipelines sind "Task Queue"-Agenten zuverlässiger als der Modus "Nicht begrenzen".
* **Zuerst mit günstigen Modellen testen** — Validieren Sie die Agentenlogik mit GPT-4o-mini oder einem lokalen 7B-Modell, bevor Sie teure Modelle verwenden.

### Kostenmanagement auf Clore.ai

```bash
# Token-Nutzung in Echtzeit über das SuperAGI-Dashboard überwachen
# Einstellungen → Ressourcen → Token-Nutzung

# Organisationsweite Limits in config.yaml festlegen
MAX_BUDGET_TOKENS: 100000  # Weiches Limit pro Sitzung
```

Da Clore.ai stundenweise abrechnet:

```bash
# Agentenkonfigurationen vor dem Stoppen der Instanz speichern
docker compose exec superagi-backend \
  python -c "import json; from superagi.models import Agent; ..."

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

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

### SuperAGI absichern

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

# API auf localhost beschränken (SSH-Tunnel verwenden)
# docker-compose.yml so ändern, dass das externe Port-Binding entfernt wird:
# ports:
#   - "127.0.0.1:8001:8001"  # API nur lokal
#   - "127.0.0.1:3000:3000"  # UI nur lokal

# Dann über SSH-Tunnel zugreifen:
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>
```

### Persistenter Speicher zwischen Clore.ai-Sitzungen

```bash
# Vollständiges Backup-Skript erstellen
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
```

### SuperAGI aktualisieren

```bash
cd ~/SuperAGI

# Aktuelle Konfiguration speichern
cp config.yaml config.yaml.backup

# Neueste Änderungen abrufen
git pull origin main

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

# Prüfen, ob alle Dienste fehlerfrei laufen
docker compose ps
docker compose logs superagi-backend --tail 20
```

***

## Fehlerbehebung

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

```bash
# Build-Protokolle im Detail prüfen
docker compose build superagi-backend --no-cache 2>&1 | tail -50

# Häufige Lösung: Speicherplatz freigeben
docker system prune -f
df -h  # Sicherstellen, dass mindestens 10 GB frei sind

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

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

### Backend stürzt beim Start ab

```bash
# Backend-Protokolle prüfen
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 in Ordnung"

# 2. Datenbank noch nicht bereit
docker compose restart superagi-backend  # Warten Sie zuerst, bis die Datenbank startet

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

### Frontend wird nicht geladen (Port 3000)

```bash
# Frontend-Container prüfen
docker compose ps superagi-frontend
docker compose logs superagi-frontend --tail 30

# Port-Zuordnung überprüfen
ss -tlnp | grep 3000

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

### Agenten laufen unendlich in einer Schleife

```bash
# Agentenprotokolle in der SuperAGI-UI prüfen:
# Dashboard → Agent → Protokolle anzeigen

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

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

### Redis-Verbindungsfehler

```bash
# Redis-Status prüfen
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

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

# Redis neu starten
docker compose restart super__agi-redis-1
```

### Ollama ist vom SuperAGI-Container aus nicht erreichbar

```bash
# Docker-Bridge-IP ermitteln
docker network inspect bridge | grep Gateway

# Vom Backend-Container aus testen
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: Ollama zum selben Compose-Netzwerk hinzufügen
# Zu docker-compose.yml-Diensten hinzufügen:
# ollama:
#   image: ollama/ollama
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: all
#             capabilities: [gpu]
```

### Datenbankverbindungspool erschöpft

```bash
# Die maximale Anzahl an PostgreSQL-Verbindungen in docker-compose.yml erhöhen
# Unter dem db-Dienst:
command: postgres -c max_connections=200

# Datenbank neu starten
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, Probleme, 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) — Inferenz mit hohem Durchsatz für gleichzeitige Agenten
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — die richtige Clore.ai-Stufe wählen
* [SuperAGI-Tool-Marktplatz](https://superagi.com/marketplace/) — von der Community erstellte Agenten-Tools
* [SuperAGI Discord](https://discord.gg/dXbRe5BHJC) — Community-Support und Diskussionen
* [FastAPI-Dokumentation (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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/superagi.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.