SuperAGI Agenten-Framework

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

Überblick

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.

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

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

Schritt 2: Klonen und konfigurieren

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

Schritt 3: Bearbeiten config.yaml

nano config.yaml

Mindestanforderung an die Konfiguration:

# 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

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

# 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):

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:

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

# ============================================================
# 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: "[email protected]"
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:

# 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 für die vollständige Ollama-Einrichtung. Integration mit SuperAGI:

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

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:

# 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):

# 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

# Ü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:

# 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

# 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

# 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

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

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

# Ü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)

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

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

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

# 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

# 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 — offizielle Anleitungen, API-Referenz

• SuperAGI GitHub — Quellcode, Issues, Community

• Ollama auf Clore.ai ausführen — lokales LLM-Backend für Agenten

• vLLM auf Clore.ai ausführen — hochdurchsatzfähige Inferenz für gleichzeitige Agenten

• GPU-Vergleichsanleitung — Auswahl des richtigen Clore.ai-Tiers

• SuperAGI Werkzeug-Marktplatz — Community-erstellte Agenten-Werkzeuge

• SuperAGI Discord — Community-Support und Diskussionen

• FastAPI Docs (SuperAGI API) — interaktive API-Dokumentation auf Ihrer Instanz