Agent autonome AutoGPT

Déployez AutoGPT sur Clore.ai — exécutez la plateforme d'agents IA autonomes originale avec navigation web, exécution de code et automatisation de tâches à horizon long.

Aperçu

AutoGPT est la plateforme pionnière open-source d'agents IA autonomes, avec 175K+ étoiles sur GitHub — l'un des dépôts les plus étoilés sur GitHub. À l'origine un outil CLI Python devenu viral en 2023, AutoGPT a évolué en une plateforme complète avec une interface Web, un constructeur de flux visuels, une orchestration multi-agent et une suite de benchmarks auto-améliorante pour agents.

La plateforme AutoGPT actuelle se compose de :

• Frontend — constructeur visuel d'agents Next.js (port 3000)

• Backend / API — service FastAPI gérant l'exécution des agents (port 8000)

• Exécuteur d'agents — workers Python exécutant des boucles de tâches autonomes

• Postgres — stockage persistant pour l'état des agents et les exécutions

• Redis — file de tâches et pub/sub

• Minio — stockage d'objets compatible S3 pour les artefacts des agents

Sur Clore.ai, AutoGPT fonctionne entièrement sur CPU (il délègue les appels LLM aux API cloud), ce qui le rend abordable à 0,05–0,20 $/h. Vous pouvez optionnellement intégrer des modèles locaux via son support de fournisseurs compatibles OpenAI.

Principales capacités :

• 🤖 Agents autonomes — les agents décomposent les tâches en sous-objectifs et les exécutent de manière itérative

• 🌐 Navigation Web — les agents peuvent rechercher sur le web, extraire des pages et synthétiser l'information

• 💻 Exécution de code — environnement d'exécution Python sandboxé pour les agents de codage

• 📁 Opérations sur les fichiers — lire, écrire et gérer des fichiers dans le cadre de l'exécution des tâches

• 🔗 Multi-agent — lancer des sous-agents spécialisés et les orchestrer de façon hiérarchique

• 🧠 Mémoire à long terme — mémoire vectorielle persistée entre les sessions

• 📈 Benchmarking d'agents — suite AgentBenchmark intégrée pour évaluer les performances des agents

---

Exigences

Les besoins en calcul d'AutoGPT dépendent de l'utilisation d'API LLM cloud (par défaut) ou de modèles locaux. La plateforme elle-même est légère.

Configuration	GPU	VRAM	RAM système	Disque	Prix Clore.ai
Minimale (API cloud)	Aucun / CPU	—	4 Go	20 Go	≈ 0,05 $/h (CPU)
Standard	Aucun / CPU	—	8 Go	40 Go	≈ 0,08 $/h
Recommandé	Aucun / CPU	—	16 Go	60 Go	≈ 0,12 $/h
+ LLM local (Ollama)	RTX 3090	24 Go	16 Go	80 Go	~0,20 $/h
+ Grand LLM local	A100 40 GB	40 Go	32 Go	100 Go	≈ 0,80 $/h

Remarque : AutoGPT utilise par défaut des LLM basés sur API (OpenAI GPT-4, Anthropic Claude, etc.). Un GPU n'est utile que si vous configurez un endpoint de modèle local via Ollama ou un autre serveur compatible OpenAI.

Clés API requises

Vous aurez besoin d'au moins l'une des suivantes :

• Clé API OpenAI (GPT-4o recommandé pour de meilleures performances des agents)

• Clé API Anthropic (Claude 3.5 Sonnet est excellent pour les agents)

• Clé Google AI (modèles Gemini pris en charge)

---

Démarrage rapide

1. Louez un serveur Clore.ai

Connectez-vous à clore.ai et lancez un serveur avec :

• 2+ cœurs CPU, 8 Go de RAM minimum

• Ports exposés 8000 (API backend) et 3000 (frontend)

• Accès SSH activé

• 20+ Go d'espace disque

2. Connectez-vous au serveur

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

# Mettre à jour les paquets
apt-get update && apt-get upgrade -y

# Vérifier Docker et Compose
docker --version
docker compose version   # Doit être v2.x

3. Cloner et configurer AutoGPT

# Cloner le dépôt
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT/autogpt_platform

# Copier le modèle d'environnement
cp .env.example .env

# Éditer le fichier d'environnement
nano .env

4. Définir les variables d'environnement requises

# Minimum requis dans .env :

# ── Fournisseur LLM (choisir au moins un) ──────────────────────────────────
OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...

# ── Clés secrètes (CHANGEZ-LES) ─────────────────────────────────────────────
APP_SECRET_KEY=$(openssl rand -hex 32)
JWT_SECRET_KEY=$(openssl rand -hex 32)

# ── Base de données ─────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt

# ── URL du backend (mettre l'IP de votre serveur Clore) ────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

5. Construire et lancer

# Construire les images et démarrer tous les services (la première exécution prend 5-10 minutes)
docker compose up -d --build

# Surveiller la progression de la construction et du démarrage
docker compose logs -f

# Après le démarrage, vérifier que tous les conteneurs sont en cours d'exécution
docker compose ps

6. Vérifier que les services sont sains

# Vérifier chaque service
docker compose ps

# Services attendus en cours d'exécution :
# autogpt_platform-db-1        Up (healthy)
# autogpt_platform-redis-1     Up
# autogpt_platform-minio-1     Up
# autogpt_platform-backend-1   Up
# autogpt_platform-frontend-1  Up
# autogpt_platform-executor-1  Up

# Tester l'API backend
curl http://localhost:8000/api/health
# Attendu : {"status": "ok"}

7. Accéder à AutoGPT

Ouvrez votre navigateur :

• Frontend : http://<clore-server-ip>:3000

• API Backend : http://<clore-server-ip>:8000

• Docs API (Swagger) : http://<clore-server-ip>:8000/docs

Créez un compte sur le frontend, configurez votre fournisseur LLM dans les Paramètres et commencez à créer des agents.

---

Configuration

Complet .env référence

# ── Application ─────────────────────────────────────────────────────────────
ENVIRONMENT=production
APP_SECRET_KEY=<générer-avec-openssl-rand-hex-32>
JWT_SECRET_KEY=<générer-avec-openssl-rand-hex-32>
ALLOWED_ORIGINS=http://<clore-server-ip>:3000

# ── Fournisseurs LLM ───────────────────────────────────────────────────────
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GROQ_API_KEY=gsk_...

# ── Compatible OpenAI (pour modèles locaux via Ollama/vLLM) ───────────────
OPENAI_API_BASE=http://localhost:11434/v1   # Endpoint compatible OpenAI d'Ollama
OPENAI_API_KEY=ollama                        # Clé factice pour Ollama

# ── Base de données ─────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password    # Changez en production !
POSTGRES_DB=autogpt

# ── Redis (file de tâches) ─────────────────────────────────────────────────
REDIS_URL=redis://redis:6379/0

# ── Minio (stockage d'objets) ──────────────────────────────────────────────
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=minioadmin   # Changez en production !
MINIO_URL=http://minio:9000

# ── Frontend ───────────────────────────────────────────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
NEXTAUTH_SECRET=<générer-avec-openssl-rand-hex-32>
NEXTAUTH_URL=http://<clore-server-ip>:3000

Personnalisation des capacités des agents

# Activer la capacité de navigation Web
WEB_BROWSER_ENABLED=true
SELENIUM_CHROME_DRIVER_URL=http://selenium:4444/wd/hub

# Ajouter Selenium à docker-compose pour la navigation Web :
# services :
#   selenium :
#     image : selenium/standalone-chrome:latest
#     shm_size : 2gb
#     ports :
#       - "4444:4444"

# Accès au système de fichiers (espace de travail de l'agent)
WORKSPACE_PATH=/workspace
RESTRICT_TO_WORKSPACE=true

Gestion de la mise à l'échelle de l'exécuteur d'agents

# Mettre à l'échelle les workers exécuteurs pour des exécutions d'agents parallèles
docker compose up -d --scale executor=4

# Surveiller les logs de l'exécuteur
docker compose logs -f executor

---

Accélération GPU

AutoGPT délègue par défaut toute l'inférence LLM à des fournisseurs externes. Pour utiliser des modèles locaux accélérés par GPU :

Connectez-vous à Ollama sur le même serveur

# Installer Ollama sur le serveur Clore
curl -fsSL https://ollama.com/install.sh | sh

# Récupérer un modèle capable (Llama 3 70B nécessite A100, 8B fonctionne sur RTX 3090)
ollama pull llama3:8b
# Pour de meilleures performances des agents :
ollama pull llama3.1:70b   # Nécessite A100 40GB+

# Rendre Ollama accessible aux conteneurs Docker
OLLAMA_HOST=0.0.0.0 ollama serve &

# Tester l'endpoint compatible OpenAI
curl http://localhost:11434/v1/models

Dans .env, pointez AutoGPT vers Ollama :

OPENAI_API_BASE=http://host.docker.internal:11434/v1
OPENAI_API_KEY=ollama
OPENAI_DEFAULT_MODEL=llama3.1:70b

Note sur les performances : Les agents autonomes effectuent de nombreux appels LLM séquentiels. Les modèles locaux sur RTX 3090 (~30 tok/s) fonctionnent, mais un A100 80GB permet une itération plus rapide. Voir Comparaison GPU.

Recommandations de modèles locaux pour les agents

Modèle	Qualité de l'agent	VRAM	GPU Clore
Llama 3 8B	Correct	8 Go	RTX 3080
Llama 3.1 8B Instruct	Bon	8 Go	RTX 3080
Llama 3.1 70B	Excellent	40 Go	A100 40GB
Mixtral 8x7B	Bon	24 Go	RTX 3090
Qwen 2.5 72B	Excellent	40 Go	A100 40GB

---

Conseils et bonnes pratiques

Gestion des coûts sur Clore.ai

# Le coût le plus élevé d'AutoGPT est souvent les appels API LLM, pas le calcul
# Définir des limites de budget en tokens dans la configuration de l'agent :
# MAX_TOKENS_PER_RUN=100000
# MAX_COST_PER_RUN=1.00   # USD

# Sauvegarder l'état de l'agent avant d'arrêter l'instance Clore
docker exec autogpt_platform-db-1 \
  pg_dump -U postgres autogpt | gzip > autogpt-backup-$(date +%Y%m%d).sql.gz

# Copier sur la machine locale
scp -P <port> root@<ip>:autogpt-backup-*.sql.gz ./

Mise à jour d'AutoGPT

cd AutoGPT

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

cd autogpt_platform

# Reconstruire avec le nouveau code
docker compose down
docker compose up -d --build

# Exécuter les migrations de BD si nécessaire
docker compose exec backend alembic upgrade head

Surveillance des exécutions d'agents

# Surveiller les logs du backend pour l'activité des agents
docker compose logs -f backend executor

# Surveiller les ressources système pendant les exécutions d'agents
htop
# ou
docker stats

# Voir l'historique des exécutions d'agents via l'API
curl http://localhost:8000/api/v1/runs | python3 -m json.tool

Renforcement de la sécurité

# NE JAMAIS exposer les ports 8000/3000 directement sur Internet sans authentification
# Utiliser Nginx ou Caddy comme reverse proxy avec HTTPS :

# Caddyfile :
# autogpt.votredomaine.com {
#     reverse_proxy localhost:3000
# }
# api.autogpt.votredomaine.com {
#     reverse_proxy localhost:8000
# }

# Restreindre l'accès système aux fichiers des agents
RESTRICT_TO_WORKSPACE=true
WORKSPACE_PATH=/agent-workspace

# Désactiver l'inscription des utilisateurs après la configuration initiale
ALLOW_SIGNUP=false

Optimisation des temps de build

# Le premier build est lent (~10 min) ; les builds suivants utilisent le cache
# Utiliser BuildKit pour des builds plus rapides :
DOCKER_BUILDKIT=1 docker compose up -d --build

# Pré-télécharger les images de base pour accélérer les builds
docker pull python:3.11-slim
docker pull node:20-alpine

---

Dépannage

Le build échoue avec une erreur d'absence de mémoire

# Le build Docker nécessite suffisamment de mémoire (4 Go+)
# Ajouter de l'espace swap si nécessaire :
fallocate -l 8G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# Rendre permanent
echo '/swapfile none swap sw 0 0' >> /etc/fstab

Le backend retourne 500 / « Database not ready »

# Vérifier la santé de la BD
docker compose ps db
docker compose logs db

# Exécuter les migrations de BD manuellement
docker compose exec backend alembic upgrade head

# Si les migrations échouent, vérifier DATABASE_URL dans .env
docker compose exec backend printenv DATABASE_URL

Le frontend affiche « Failed to connect to backend »

# Vérifier que NEXT_PUBLIC_AGPT_SERVER_URL est correctement défini
grep NEXT_PUBLIC_AGPT_SERVER_URL .env

# Doit être l'IP publique, pas localhost (le navigateur émet cette requête)
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api

# Reconstruire le frontend après avoir modifié cette variable d'env
docker compose up -d --build frontend

L'exécuteur d'agents plante / est tué par OOM

# Vérifier l'utilisation de la mémoire
docker stats autogpt_platform-executor-1

# Limiter la mémoire de l'exécuteur et ajouter une politique de redémarrage
# Dans docker-compose.yaml :
#   executor :
#     mem_limit : 2g
#     restart : unless-stopped

# Ou réduire les exécutions d'agents concurrentes
MAX_CONCURRENT_RUNS=2

Connexion Redis refusée

# Vérifier que Redis fonctionne
docker compose ps redis
docker compose logs redis

# Tester la connectivité depuis le backend
docker compose exec backend redis-cli -h redis ping
# Attendu : PONG

# Si Redis requiert une authentification, définir :
REDIS_URL=redis://:password@redis:6379/0

Agent bloqué dans une boucle

# Les agents AutoGPT peuvent parfois entrer dans des boucles infinies
# Définir une limite maximale de cycles :
MAX_AGENT_CYCLES=50

# Ou interrompre un agent en cours via l'API :
curl -X POST http://localhost:8000/api/v1/runs/<run-id>/stop

---

Lectures complémentaires

• Documentation officielle d'AutoGPT

• Dépôt GitHub d'AutoGPT

• Guide d'installation de la plateforme AutoGPT

• Exécuter Ollama sur Clore.ai

• Exécuter vLLM sur Clore.ai

• Comparaison GPU Clore.ai

• Communauté Discord d'AutoGPT