Cadre d'agents SuperAGI

Déployez SuperAGI sur Clore.ai — un cadre d'agents IA autonomes axé développeur avec tableau de bord GUI, place de marché d'outils, agents concurrents et support optionnel de LLM local sur des serveurs cloud GPU puissants.

Aperçu

SuperAGI est un cadre d'agents IA autonomes open-source, orienté développeur, avec plus de 15K étoiles sur GitHub. Contrairement aux simples chatbots, SuperAGI exécute agents autonomes — des systèmes d'IA qui planifient de manière autonome, exécutent des tâches en plusieurs étapes, utilisent des outils et itèrent vers un objectif sans intervention humaine constante.

Pourquoi exécuter SuperAGI sur Clore.ai ?

• GPU optionnel avec prise en charge puissante des LLM locaux — Exécutez des agents soutenus par des modèles locaux (Llama, Mistral, etc.) sur les GPU de Clore.ai pour une IA autonome entièrement privée et à coût contrôlé.

• Exécution concurrente d'agents — Exécutez plusieurs agents en parallèle sur le même serveur, chacun travaillant sur des tâches différentes simultanément.

• Mémoire persistante des agents — Les agents conservent le contexte, apprennent des sorties des outils et stockent une mémoire à long terme dans des bases de données vectorielles entre les exécutions.

• Place de marché d'outils — Intégrations préconstruites pour Google Search, GitHub, Email, Jira, Notion, et plus encore.

• Économie de Clore.ai — À environ 0,20 $/h pour une RTX 3090, vous pouvez exécuter des agents autonomes capables à une fraction du coût des services d'IA cloud.

Principales caractéristiques

Fonction	Description
Provisionnement d'agents	Créez, configurez et déployez des agents via une interface graphique
Place de marché d'outils	Plus de 30 outils intégrés (recherche, code, fichiers, API)
Prise en charge multi-modèle	OpenAI, Anthropic, LLM locaux via endpoint personnalisé
Agents concurrents	Exécutez plusieurs agents simultanément
Mémoire d'agent	Court terme (fenêtre de contexte) + long terme (BD vectorielle)
Tableau de bord GUI	Interface web complète pour la gestion des agents
Gestionnaire de ressources	Suivez l'utilisation des tokens et les coûts par agent
Modèles de workflow	Modèles d'agents préconstruits pour tâches courantes

Architecture

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

---

Exigences

Spécifications du serveur

Composant	Minimum	Recommandé	Remarques
GPU	Aucun (mode API)	RTX 3090 (LLM locaux)	GPU nécessaire pour l'inférence de modèles locaux
VRAM	—	24 Go	Pour exécuter des modèles locaux 13B+
CPU	4 vCPU	8 vCPU	L'exécution d'agents est gourmande en CPU
RAM	8 Go	16 Go	Plusieurs agents concurrents ont besoin de mémoire
Stockage	20 Go	100+ Go	Journaux d'agents, BD vectorielle, stockage de modèles

Référence de tarification Clore.ai

Type de serveur	Coût approximatif	Cas d'utilisation
CPU (8 vCPU, 16 Go)	≈ 0,10–0,20 $/h	SuperAGI + API externe (OpenAI/Anthropic)
RTX 3090 (24 Go)	~0,20 $/h	SuperAGI + Ollama modèle local 13B
RTX 4090 (24 Go)	~0,35 $/h	SuperAGI + Ollama, inférence plus rapide
2× RTX 3090	~0,40 $/h	SuperAGI + modèle 70B (quantifié Q4)
A100 80 Go	~1,10 $/h	SuperAGI + grands modèles, haute concurrence
H100 80 Go	≈ 2,50 $/h	Systèmes d'agents autonomes de niveau production

💡 Conseil sur les coûts : Pour le développement et les tests, utilisez les APIs OpenAI ou Anthropic (aucun GPU requis). Passez à une instance GPU seulement lorsque vous avez besoin d'inférence LLM locale pour des raisons de confidentialité ou de coût. Voir Guide de comparaison GPU.

Prérequis

• Serveur Clore.ai avec accès SSH

• Docker + Docker Compose (pré-installés sur Clore.ai)

• Git (préinstallé)

• 4+ vCPU, 8+ Go de RAM (16 Go recommandés pour agents concurrents)

• Clé API OpenAI ou endpoint LLM local (Ollama/vLLM)

---

Démarrage rapide

Méthode 1 : Docker Compose (Officiel — Recommandé)

Le déploiement officiel de SuperAGI utilise Docker Compose pour gérer tous les services.

Étape 1 : Connectez-vous à votre serveur Clore.ai

ssh root@<votre-ip-serveur-clore> -p <port-ssh>

Étape 2 : Cloner et configurer

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

Étape 3 : Éditer config.yaml

nano config.yaml

Configuration minimale requise :

# config.yaml
OPENAI_API_KEY: "sk-votre-cle-openai-ici"

# Base de données (laisser par défaut pour Docker Compose)
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "password"

# Base de données vectorielle
VECTOR_STORE: "Redis"  # ou "Pinecone", "Qdrant", "Weaviate"
REDIS_URL: "redis://super__agi-redis-1:6379/0"

# Paramètres de l'app
ENV: "PROD"
ALLOW_LISTS_CREATION: "true"

# Optionnel : restreindre l'accès
# AUTH_SECRET_KEY: "votre-secret-aleatoire"

Étape 4 : Démarrer la stack

docker compose up -d --build

Le processus de build télécharge les dépendances et compile le frontend (~5–10 minutes lors de la première exécution).

Étape 5 : Surveiller le démarrage

# Regardez tous les services se lancer
docker compose ps

# Suivre les logs
docker compose logs -f

# Attendez "Application startup complete" dans les logs du backend
docker compose logs superagi-backend --tail 30

Étape 6 : Accéder au tableau de bord

http://<ip-de-votre-serveur-clore>:3000

L'API est disponible à :

http://<ip-de-votre-serveur-clore>:8001

Documentation de l'API :

http://<ip-de-votre-serveur-clore>:8001/docs

---

Méthode 2 : Démarrage rapide avec images préconstruites

Pour un démarrage plus rapide en utilisant des images préconstruites (sauter l'étape de build) :

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

# Éditez la config avec vos clés API
nano config.yaml

# Utilisez des images préconstruites si disponibles
docker compose -f docker-compose.yaml pull
docker compose up -d

---

Méthode 3 : Configuration minimale mono-modèle

Une configuration simplifiée pour tester uniquement avec OpenAI :

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

# Créez une config minimale
cat > config.yaml << 'EOF'
OPENAI_API_KEY: "sk-votre-cle-ici"
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

# Surveillez la progression du build
docker compose logs superagi-frontend --tail 5 -f &
docker compose logs superagi-backend --tail 5 -f

---

Configuration

config.yaml Référence

# ============================================================
# Fournisseurs LLM
# ============================================================
OPENAI_API_KEY: "sk-..."                    # modèles OpenAI GPT
ANTHROPIC_API_KEY: "sk-ant-..."            # modèles Claude

# Pour les modèles locaux (Ollama ou API compatible OpenAI)
# Définir dans l'UI : Settings → Models → Custom Model
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"  # Ollama sur le même hôte
OPENAI_MODEL: "llama3.1:8b"

# ============================================================
# Base de données
# ============================================================
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "votre-mot-de-passe-fort"

# ============================================================
# Base de données vectorielle (mémoire longue des agents)
# ============================================================
VECTOR_STORE: "Redis"       # Redis (par défaut, intégré)
# Ou utilisez externe :
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "votre-cle"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

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

# ============================================================
# Clés API pour outils (optionnel, pour outils spécifiques)
# ============================================================
GOOGLE_API_KEY: "votre-cle-google"
GOOGLE_CUSTOM_SEARCH_ENGINE_ID: "votre-id-cx"
GITHUB_TOKEN: "ghp_votre-token"
JIRA_EMAIL: "[email protected]"
JIRA_API_TOKEN: "votre-jira-token"
JIRA_SERVER_URL: "https://votre-org.atlassian.net"

# ============================================================
# Stockage
# ============================================================
STORAGE_TYPE: "File"        # Stockage de fichiers local
# STORAGE_TYPE: "S3"        # Compatible S3 (MinIO, AWS)
# BUCKET_NAME: "superagi"
# AWS_ACCESS_KEY_ID: "..."
# AWS_SECRET_ACCESS_KEY: "..."

# ============================================================
# Sécurité
# ============================================================
JWT_SECRET_KEY: "votre-cle-secrete-aleatoire"

Connexion de SuperAGI aux outils

Les outils sont configurés via l'interface graphique à Settings → Toolkit. Chaque outil peut être activé/désactivé par agent.

Outils intégrés :

Outil	But	Clé API requise
Recherche Google	Recherche web	Oui (API Google)
DuckDuckGo	Recherche web	Non
GitHub	Accès au dépôt de code	Oui (token GitHub)
Email	Envoyer/recevoir des e-mails	Oui (config SMTP)
Générateur de code	Écrire et exécuter du code	Non
Gestionnaire de fichiers	Lire/écrire des fichiers locaux	Non
Navigateur	Navigation web headless	Non
Jira	Suivi des tickets	Oui
Notion	Base de connaissances	Oui
Génération d'images	DALL-E 3, Stable Diffusion	Oui (clé OpenAI)

Créer votre premier agent

Via l'interface graphique (Settings → Agents → Create Agent) :

1. Nom — Donnez à votre agent un nom descriptif

2. Description — Ce que fait cet agent

3. Objectifs — Listez les objectifs (un par ligne)

4. Instructions — Prompt système pour le comportement

5. Modèle — Sélectionnez LLM (GPT-4, Claude ou local)

6. Outils — Activez les outils pertinents

7. Itérations max — Limite de sécurité (10–50 typique)

Via l'API REST :

# Créer un agent via l'API
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Agent de Recherche",
    "description": "Recherche des sujets et rédige des résumés",
    "goal": [
      "Rechercher le sujet fourni",
      "Écrire un résumé complet",
      "Enregistrer le résumé dans un fichier"
    ],
    "agent_type": "Task Queue",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "Aucun critère de sortie",
    "max_iterations": 25,
    "user_timezone": "UTC",
    "llm_model_config": {
      "model_name": "gpt-4o-mini",
      "temperature": 0.5,
      "max_new_tokens": 2000
    }
  }'

---

Accélération GPU

SuperAGI prend en charge l'inférence LLM locale via tout endpoint compatible OpenAI, ce qui le rend idéal pour les déploiements Clore.ai avec GPU.

Configurer Ollama comme backend LLM pour les agents

Voir Guide Ollama pour la configuration complète d'Ollama. Intégration avec SuperAGI :

Étape 1 : Démarrer Ollama sur le même serveur Clore.ai

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

# Récupérer un modèle capable pour l'utilisation par les agents (nécessite un bon raisonnement)
docker exec ollama ollama pull llama3.1:8b        # Rapide, bon en raisonnement
docker exec ollama ollama pull mistral:7b-instruct  # Tâches de code
docker exec ollama ollama pull deepseek-coder:6.7b # Agents axés code

Étape 2 : Configurer SuperAGI pour utiliser Ollama

Dans config.yaml:

# Pointer vers Ollama (exécuté sur l'hôte Docker)
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"

Ou configurer dans l'UI SuperAGI :

• Settings → Models → Add Custom Model

• Fournisseur : compatible OpenAI

• URL de base : http://172.17.0.1:11434/v1

• Clé API : ollama (n'importe quelle chaîne)

• Nom du modèle : llama3.1:8b

Configurer vLLM pour des agents à haut débit

Pour les déploiements en production avec de nombreux agents concurrents (voir - Débit le plus élevé):

# Démarrer vLLM sur le serveur GPU
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=hf_votre-token \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --served-model-name mistral-7b \
  --max-model-len 8192 \
  --enable-prefix-caching

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

Dimensionnement GPU pour charges de travail d'agents

Cas d'utilisation	Modèle	GPU	VRAM	Agents concurrents
Test	GPT-4o-mini (API)	Aucune	—	Illimité (limité par le débit)
Agents légers	Llama 3.1 8B	RTX 3090	8 Go	2–4
Tâches de raisonnement	Mistral 7B Instruct	RTX 3090	6 Go	3–5
Agents complexes	Llama 3.1 70B Q4	2× RTX 3090	48 Go	1–2
Production	Llama 3.1 70B FP16	A100 80GB	80 Go	3–6

---

Conseils et bonnes pratiques

Conception d'agent

• Soyez précis avec les objectifs — Des objectifs vagues comme « faire des recherches » font boucler les agents. Utilisez « Rechercher X et écrire un résumé de 500 mots dans output.txt. »

• Définir des limites d'itération — Fixez toujours max_iterations (20–50). Les agents illimités peuvent consommer rapidement des tokens.

• Utiliser le mode file de tâches — Pour les pipelines multi-étapes, les agents « Task Queue » sont plus fiables que le mode « Don't Limit ».

• Testez d'abord avec des modèles peu coûteux — Validez la logique de l'agent avec GPT-4o-mini ou un modèle local 7B avant d'utiliser des modèles coûteux.

Gestion des coûts sur Clore.ai

# Surveillez l'utilisation des tokens en temps réel depuis le tableau de bord SuperAGI
# Settings → Resources → Token Usage

# Définissez des limites au niveau organisation dans config.yaml
MAX_BUDGET_TOKENS: 100000  # Limite souple par session

Puisque Clore.ai facture à l'heure :

# Sauvegardez les configurations d'agents avant d'arrêter l'instance
docker compose exec superagi-backend \
  python -c "import json; from superagi.models import Agent; ..."

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

# Copier la sauvegarde hors du serveur
scp -P <ssh-port> root@<server-ip>:~/SuperAGI/superagi-db-*.sql.gz ./

Sécurisation de SuperAGI

# Activer l'authentification dans config.yaml
AUTH_SECRET_KEY: "votre-secret-fort-aleatoire"

# Restreindre l'API à localhost (utiliser des tunnels SSH)
# Modifier docker-compose.yml pour supprimer le binding de port externe :
# ports:
#   - "127.0.0.1:8001:8001"  # API locale uniquement
#   - "127.0.0.1:3000:3000"  # UI locale uniquement

# Puis accéder via tunnel SSH :
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>

Stockage persistant entre les sessions Clore.ai

# Créer un script de sauvegarde complet
cat > /root/backup-superagi.sh << 'EOF'
#!/bin/bash
cd ~/SuperAGI

# Sauvegarder la base de données
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

# Sauvegarder la config et les espaces de travail
tar -czf ~/backups/superagi-files-$(date +%Y%m%d-%H%M).tar.gz \
  config.yaml \
  workspace/ \
  .env 2>/dev/null || true

echo "Sauvegarde terminée : $(ls -lh ~/backups/ | tail -2)"
EOF

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

Mise à jour de SuperAGI

cd ~/SuperAGI

# Sauvegarder la config actuelle
cp config.yaml config.yaml.backup

# Récupérer les derniers changements
git pull origin main

# Rebuild et redémarrage
docker compose down
docker compose up -d --build

# Vérifier que tous les services sont sains
docker compose ps
docker compose logs superagi-backend --tail 20

---

Dépannage

Le build échoue pendant docker compose up --build

# Vérifier les logs de build en détail
docker compose build superagi-backend --no-cache 2>&1 | tail -50

# Correctif courant : libérer de l'espace disque
docker system prune -f
df -h  # Assurez-vous d'avoir au moins 10 Go de libre

# Si le build npm échoue pour le frontend
docker compose build superagi-frontend --no-cache

# Vérifier la mémoire Node.js pendant le build
docker compose build superagi-frontend \
  --build-arg NODE_OPTIONS="--max-old-space-size=4096"

Le backend plante au démarrage

# Vérifier les logs du backend
docker compose logs superagi-backend --tail 50

# Causes courantes :
# 1. Syntaxe config.yaml invalide
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))" && echo "YAML OK"

# 2. Base de données pas prête
docker compose restart superagi-backend  # Attendre que la BD démarre d'abord

# 3. Clé API manquante
grep OPENAI_API_KEY config.yaml  # Assurez-vous qu'elle est définie et non vide

Le frontend ne se charge pas (port 3000)

# Vérifier le conteneur frontend
docker compose ps superagi-frontend
docker compose logs superagi-frontend --tail 30

# Vérifier le mapping de ports
ss -tlnp | grep 3000

# Vérifier si le backend API est joignable depuis le frontend
docker compose exec superagi-frontend \
  curl -s http://superagi-backend:8001/health

Les agents bouclent indéfiniment

# Vérifier les logs d'agent dans l'UI SuperAGI :
# Dashboard → Agent → View Logs

# Arrêter de force un agent en cours via l'API
curl -X POST "http://localhost:8001/v1/agent/<agent-id>/stop" \
  -H "Content-Type: application/json"

# Ou arrêter tous les agents via la BD
docker compose exec super__agi-db-1 \
  psql -U super_agi -c "UPDATE agent_executions SET status='COMPLETED' WHERE status='RUNNING';"

Erreurs de connexion Redis

# Vérifier le statut de Redis
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

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

# Redémarrer Redis
docker compose restart super__agi-redis-1

Ollama non joignable depuis le conteneur SuperAGI

# Trouver l'IP du bridge Docker
docker network inspect bridge | grep Gateway

# Tester depuis le conteneur backend
docker compose exec superagi-backend \
  curl -s http://172.17.0.1:11434/v1/models

# Si vous utilisez le réseau host
docker run -d --network host ...  # Pas facilement compatible avec docker compose

# Alternative : ajouter Ollama au même réseau compose
# Ajouter aux services de docker-compose.yml :
# ollama:
#   image: ollama/ollama
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: all
#             capabilities: [gpu]

Pool de connexions à la base de données épuisé

# Augmenter max_connections de PostgreSQL dans docker-compose.yml
# Sous le service db :
command: postgres -c max_connections=200

# Redémarrer la base de données
docker compose restart super__agi-db-1
docker compose restart superagi-backend

---

Lectures complémentaires

• Documentation SuperAGI — guides officiels, référence API

• SuperAGI GitHub — code source, issues, communauté

• Exécuter Ollama sur Clore.ai — backend LLM local pour les agents

• Exécuter vLLM sur Clore.ai — inférence à haut débit pour agents concurrents

• Guide de comparaison GPU — choisir le bon niveau Clore.ai

• Place de marché des outils SuperAGI — outils d'agents créés par la communauté

• SuperAGI Discord — support communautaire et discussions

• Docs FastAPI (API SuperAGI) — documentation API interactive sur votre instance