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

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

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

Mindestkonfiguration:

# 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

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

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

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:

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

# ============================================================
# 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: "[e-mail]"
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:

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

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

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:

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

# 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

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

# 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

# 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

# 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

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

# 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

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

# 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

# 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

# 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

# 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

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

• SuperAGI GitHub — Quellcode, Probleme, Community

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

• vLLM auf Clore.ai ausführen — Inferenz mit hohem Durchsatz für gleichzeitige Agenten

• GPU-Vergleichsleitfaden — die richtige Clore.ai-Stufe wählen

• SuperAGI-Tool-Marktplatz — von der Community erstellte Agenten-Tools

• SuperAGI Discord — Community-Support und Diskussionen

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