Framework d'agents SuperAGI

Déployez SuperAGI sur Clore.ai — un framework d'agents IA autonomes orienté développeur avec tableau de bord GUI, marketplace d'outils, agents concurrents et prise en charge optionnelle de LLM locaux sur de puissants serveurs cloud GPU.

Aperçu

SuperAGI est un framework d'agent IA autonome open source, pensé d'abord pour les développeurs, avec plus de 15 k étoiles sur GitHub. Contrairement aux simples chatbots, SuperAGI s'exécute agents autonomes — des systèmes d'IA qui planifient, exécutent de manière indépendante des tâches en plusieurs étapes, utilisent des outils et itèrent vers un objectif sans apport humain constant.

Pourquoi exécuter SuperAGI sur Clore.ai ?

Sans GPU, avec prise en charge puissante des LLM locaux — Exécutez des agents alimentés par des modèles locaux (Llama, Mistral, etc.) sur les GPU Clore.ai pour une IA autonome entièrement privée et à coût maîtrisé.
Exécution concurrente d'agents — Exécutez plusieurs agents en parallèle sur le même serveur, chacun travaillant simultanément sur des tâches différentes.
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éconfigurées pour Google Search, GitHub, Email, Jira, Notion et plus encore.
Économie Clore.ai — À 0,07–0,21 $/h pour une RTX 3090, vous pouvez exécuter des agents autonomes performants pour une fraction du coût des services d'IA cloud.

Caractéristiques clés

Fonctionnalité

Description

Provisionnement d'agents

Créer, configurer et déployer des agents via l'interface graphique

Place de marché d'outils

30+ outils intégrés (recherche, code, fichiers, API)

Prise en charge multi-modèles

OpenAI, Anthropic, LLM locaux via un point de terminaison personnalisé

Agents concurrents

Exécuter plusieurs agents simultanément

Mémoire des agents

Court terme (fenêtre de contexte) + long terme (base vectorielle)

Tableau de bord GUI

Interface web complète pour la gestion des agents

Gestionnaire de ressources

Suivre l'utilisation des jetons et les coûts par agent

Modèles de workflow

Modèles d'agents préconstruits pour les tâches courantes

Architecture

┌────────────────────────────────────────────────────┐
│              Pile SuperAGI                        │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  Front-end (Port 3000)│   │  API (Port 8001)  │   │
│  │   Interface Next.js  │   │  Backend FastAPI   │   │
│  └──────────┬──────────┘   └─────────┬─────────┘   │
│             └──────────┬─────────────┘             │
│                        ▼                           │
│  ┌─────────────────────────────────────────────┐   │
│  │              Exécuteur d'agents             │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │   │
│  │  │  Agent 1  │  │  Agent 2  │  │  Agent N  │  │   │
│  │  └──────────┘  └──────────┘  └──────────┘  │   │
│  └───────┬─────────────┬─────────────┬─────────┘   │
│          ▼             ▼             ▼             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐      │
│  │ PostgreSQL │  │  Redis    │  │  Base     │      │
│  │  (État)   │  │ (File)    │  │ vectorielle│      │
│  └───────────┘  └───────────┘  └───────────┘      │
└────────────────────────────────────────────────────┘
          │
    ┌─────┴──────┐
    ▼            ▼
 OpenAI      LLM local
 Anthropic   (Ollama/vLLM)

Exigences

Spécifications du serveur

Composant

Minimum

Recommandé

Remarques

GPU

Aucun (mode API)

RTX 3090 (LLM locaux)

GPU requis pour l'inférence de modèles locaux

VRAM

—

24 Go

Pour exécuter des modèles locaux de 13B et plus

CPU

4 vCPU

8 vCPU

L'exécution des agents est gourmande en CPU

RAM

8 Go

16 Go

Plusieurs agents concurrents nécessitent de la mémoire

Stockage

20 Go

100+ Go

Journaux des agents, base vectorielle, stockage des modèles

Référence tarifaire Clore.ai

Type de serveur

Coût approx.

Cas d’utilisation

CPU (8 vCPU, 16 Go)

~0,10–0,20 $/h

SuperAGI + API externe (OpenAI/Anthropic)

RTX 3090 (24 Go)

0,07–0,21 $/h

SuperAGI + modèle local Ollama 13B

RTX 4090 (24 Go)

0,14–0,42 $/h

SuperAGI + Ollama, inférence plus rapide

2× RTX 3090

0,14–0,42 $/h

SuperAGI + modèle 70B (quantifié Q4)

A100 80 Go

bare metal

SuperAGI + grands modèles, forte concurrence

H100 80 Go

~1,04 $/h

Systèmes d'agents autonomes de niveau production

💡 Conseil de coût : Pour le développement et les tests, utilisez les API OpenAI ou Anthropic (aucun GPU requis). Passez à une instance GPU uniquement lorsque vous avez besoin d'une inférence LLM locale pour des raisons de confidentialité ou de coût. Voir Guide de comparaison des 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 les agents concurrents)
Clé API OpenAI ou point de terminaison LLM local (Ollama/vLLM)

Démarrage rapide

Méthode 1 : Docker Compose (officielle — recommandée)

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@<your-clore-server-ip> -p <ssh-port>

Étape 2 : cloner et configurer

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

Étape 3 : modifier config.yaml

nano config.yaml

Configuration minimale requise :

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

# Base de données (laissez la valeur 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'application
ENV: "PROD"
ALLOW_LISTS_CREATION: "true"

# Optionnel : restreindre l'accès
# AUTH_SECRET_KEY: "your-random-secret"

Étape 4 : démarrer la pile

docker compose up -d --build

Le processus de compilation télécharge les dépendances et compile le front-end (~5–10 minutes lors du premier lancement).

Étape 5 : surveiller le démarrage

# Surveillez la montée de tous les services
docker compose ps

# Suivre les journaux
docker compose logs -f

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

Étape 6 : accéder au tableau de bord

http://<your-clore-server-ip>:3000

L'API est disponible à :

http://<your-clore-server-ip>:8001

Documentation de l'API :

http://<your-clore-server-ip>:8001/docs

Méthode 2 : démarrage rapide avec des images préconstruites

Pour un démarrage plus rapide avec des images préconstruites (ignorez l'étape de compilation) :

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

# Modifiez la configuration avec vos clés API
nano config.yaml

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

Méthode 3 : configuration minimale à un seul modèle

Une configuration simplifiée pour les tests avec OpenAI uniquement :

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

# Créer une configuration minimale
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

# Surveiller l'avancement de la compilation
docker compose logs superagi-frontend --tail 5 -f &
docker compose logs superagi-backend --tail 5 -f

Configuration

`config.yaml` Référence

# ============================================================
# Fournisseurs de LLM
# ============================================================
OPENAI_API_KEY: "sk-..."                    # Modèles GPT d'OpenAI
ANTHROPIC_API_KEY: "sk-ant-..."            # Modèles Claude

# Pour les modèles locaux (Ollama ou API compatible OpenAI)
# À définir dans l'interface : Paramètres → Modèles → Modèle personnalisé
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: "your-strong-password"

# ============================================================
# Base de données vectorielle (mémoire à long terme de l'agent)
# ============================================================
VECTOR_STORE: "Redis"       # Redis (par défaut, intégré)
# Ou utilisez un service externe :
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "your-key"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

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

# ============================================================
# Clés API des outils (facultatif, pour des outils spécifiques)
# ============================================================
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"

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

# ============================================================
# Sécurité
# ============================================================
JWT_SECRET_KEY: "your-random-secret-key"

Connexion de SuperAGI aux outils

Les outils se configurent via l'interface graphique à Paramètres → Toolkit. Chaque outil peut être activé/désactivé par agent.

Outils intégrés :

Outil

Objectif

Clé API requise

Recherche Google

Recherche web

Oui (API Google)

DuckDuckGo

Recherche web

Non

GitHub

Accès aux dépôts de code

Oui (jeton GitHub)

E-mail

Envoyer/lire des e-mails

Oui (configuration SMTP)

Rédacteur de code

Écrire et exécuter du code

Non

Gestionnaire de fichiers

Lire/écrire des fichiers locaux

Non

Navigateur

Navigation web sans interface

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 (Paramètres → Agents → Créer un agent) :

Nom — Donnez à votre agent un nom descriptif
Description — Ce que fait cet agent
Objectifs — Listez les objectifs (un par ligne)
Instructions — Prompt système pour le comportement
Modèle — Sélectionnez le LLM (GPT-4, Claude ou local)
Outils — Activez les outils pertinents
Itérations max — Limite de sécurité (10–50 généralement)

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": [
      "Recherchez le sujet fourni",
      "Rédigez un résumé complet",
      "Enregistrez le résumé dans un fichier"
    ],
    "agent_type": "File d'attente des tâches",
    "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 locale de LLM via n'importe quel point de terminaison compatible OpenAI, ce qui le rend idéal pour les déploiements Clore.ai alimentés par GPU.

Configurer Ollama comme backend LLM de l'agent

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

Étape 1 : démarrez 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érez un modèle performant pour l'utilisation par l'agent (nécessite un bon raisonnement)
docker exec ollama ollama pull llama3.1:8b        # Rapide, bon 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 sur le code

Étape 2 : configurez SuperAGI pour utiliser Ollama

Dans config.yaml:

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

Ou configurez-le dans l'interface SuperAGI :

Paramètres → Modèles → Ajouter un modèle personnalisé
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 des déploiements de production avec de nombreux agents concurrents (voir Guide vLLM):

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

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

Dimensionnement GPU pour les charges de travail des agents

Cas d’utilisation

Modèle

GPU

VRAM

Agents concurrents

Test

GPT-4o-mini (API)

Aucune

—

Illimités (limités 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 80 Go

80 Go

3–6

Conseils et bonnes pratiques

Conception des agents

Soyez précis dans les objectifs — Des objectifs vagues comme « faire de la recherche » font tourner les agents en boucle. Utilisez « Recherchez X et rédigez un résumé de 500 mots dans le fichier output.txt. »
Définissez des limites d'itérations — Définissez toujours max_iterations (20–50). Les agents sans limite peuvent consommer des jetons rapidement.
Utilisez le mode file d'attente des tâches — Pour les pipelines en plusieurs é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 jetons en temps réel depuis le tableau de bord SuperAGI
# Paramètres → Ressources → Utilisation des jetons

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

Comme Clore.ai facture à l'heure :

# Enregistrez 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 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: "your-strong-random-secret"

# Restreindre l'API à localhost (utilisez des tunnels SSH)
# Modifiez docker-compose.yml pour supprimer la liaison de port externe :
# ports:
#   - "127.0.0.1:8001:8001"  # API locale uniquement
#   - "127.0.0.1:3000:3000"  # UI locale uniquement

# Ensuite, accédez via un 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 le 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 configuration 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

# Enregistrer la configuration actuelle
cp config.yaml config.yaml.backup

# Récupérer les dernières modifications
git pull origin main

# Reconstruire et redémarrer
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

La compilation échoue pendant `docker compose up --build`

# Vérifier les journaux de compilation 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  # S'assurer qu'il reste au moins 10 Go libres

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

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

Le backend plante au démarrage

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

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

# 2. La base de données n'est pas prête
docker compose restart superagi-backend  # Attendre d'abord le démarrage de la base de données

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

Le frontend ne se charge pas (port 3000)

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

# Vérifier le mappage des 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 journaux de l'agent dans l'interface SuperAGI :
# Tableau de bord → Agent → Voir les journaux

# Forcer l'arrêt d'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 base de données
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 l'état 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 n'est pas joignable depuis le conteneur SuperAGI

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

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

# Si vous utilisez le réseau hôte
docker run -d --network host ...  # Non compatible facilement avec docker compose

# Alternative : ajouter Ollama au même réseau compose
# Ajouter dans les 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

Pour aller plus loin

Documentation SuperAGI — guides officiels, référence de l'API
GitHub SuperAGI — code source, problèmes, 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 des agents simultanés
Guide de comparaison des GPU — choisir le bon niveau Clore.ai
Place de marché d'outils SuperAGI — outils d'agent créés par la communauté
Discord SuperAGI — support et discussions de la communauté
Docs FastAPI (API SuperAGI) — documentation API interactive sur votre instance

PrécédentEntreprise logicielle MetaGPT

SuivantAssistant IA LobeChat

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?