Agent autonome AutoGPT

Déployez AutoGPT sur Clore.ai — exécutez la plateforme d'agent IA autonome d'origine avec navigation web, exécution de code et automatisation de tâches à long terme.

Aperçu

AutoGPT est la plateforme pionnière d'agents IA autonomes open source, avec plus de 175 k é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 générateur visuel de workflows, une orchestration multi-agents et une suite de benchmark d'agents auto-améliorante.

La plateforme AutoGPT actuelle se compose de :

• Interface frontend — générateur 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 de l'état des agents et des exécutions

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

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

Sur Clore.ai, AutoGPT s'exécute entièrement sur CPU (il délègue les appels LLM à des API cloud), ce qui le rend abordable à 0,05 à 0,20 $/h. Vous pouvez éventuellement intégrer des modèles locaux via la prise en charge de fournisseurs compatibles OpenAI.

Fonctionnalités clé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, aspirer des pages et synthétiser des informations

• 💻 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 — créer des sous-agents spécialisés et les orchestrer de manière 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 du fait que vous utilisiez des API LLM cloud (par défaut) ou des modèles locaux. La plateforme elle-même est légère.

Configuration	GPU	VRAM	RAM système	Disque	Prix Clore.ai
Minime (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,07–0,21 $/h
+ grand LLM local	A100 40 Go	40 Go	32 Go	100 Go	bare metal

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 point de terminaison de modèle local via Ollama ou un autre serveur compatible OpenAI.

Clés API requises

Vous aurez besoin d'au moins l'un des éléments suivants :

• Clé API OpenAI (GPT-4o recommandé pour les meilleures performances de l'agent)

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

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

# Vérifier Docker et Compose
docker --version
docker compose version   # Doit être en 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

# Modifier le fichier d'environnement
nano .env

4. Définir les variables d'environnement requises

# Minimum requis dans .env :

# ── Fournisseur LLM (en 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 (définir sur 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 (le premier lancement prend 5 à 10 minutes)
docker compose up -d --build

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

# Après le démarrage, vérifiez 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 en cours d'exécution attendus :
# autogpt_platform-db-1        Démarré (sain)
# autogpt_platform-redis-1     Démarré
# autogpt_platform-minio-1     Démarré
# autogpt_platform-backend-1   Démarré
# autogpt_platform-frontend-1  Démarré
# autogpt_platform-executor-1  Démarré

# 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

Référence .env complète

# ── Application ──────────────────────────────────────────────────────────────
ENVIRONMENT=production
APP_SECRET_KEY=<generate-with-openssl-rand-hex-32>
JWT_SECRET_KEY=<generate-with-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 les modèles locaux via Ollama/vLLM) ────────────────────
OPENAI_API_BASE=http://localhost:11434/v1   # Point de terminaison compatible OpenAI d'Ollama
OPENAI_API_KEY=ollama                        # Clé fictive pour Ollama

# ── Base de données ─────────────────────────────────────────────────────────────────
DATABASE_URL=postgresql://postgres:password@db:5432/autogpt
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password    # À changer 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   # À changer en production !
MINIO_URL=http://minio:9000

# ── Frontend ─────────────────────────────────────────────────────────────────
NEXT_PUBLIC_AGPT_SERVER_URL=http://<clore-server-ip>:8000/api
NEXTAUTH_SECRET=<generate-with-openssl-rand-hex-32>
NEXTAUTH_URL=http://<clore-server-ip>:3000

Personnalisation des capacités de l'agent

# 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 de l'exécuteur pour des exécutions parallèles d'agents
docker compose up -d --scale executor=4

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

---

Accélération GPU

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

Se connecter à Ollama sur le même serveur

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

# Télécharger un modèle capable (Llama 3 70B nécessite une A100, 8B fonctionne sur une RTX 3090)
ollama pull llama3:8b
# Pour de meilleures performances de l'agent :
ollama pull llama3.1:70b   # Nécessite une A100 40 Go+

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

# Tester le point de terminaison compatible OpenAI
curl http://localhost:11434/v1/models

Dans .env, faites pointer AutoGPT vers Ollama :

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

Remarque 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 une A100 80 Go permet une itération plus rapide. Voir Comparaison des 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	Excellente	40 Go	A100 40 Go
Mixtral 8x7B	Bon	24 Go	RTX 3090
Qwen 2.5 72B	Excellente	40 Go	A100 40 Go

---

Conseils et bonnes pratiques

Gestion des coûts sur Clore.ai

# Le plus gros coût d'AutoGPT est souvent constitué par les appels API LLM, pas par le calcul
# Définir des limites de budget de jetons 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 vers la machine locale
scp -P <port> root@<ip>:autogpt-backup-*.sql.gz ./

Mise à jour d'AutoGPT

cd AutoGPT

# Récupérer les dernières modifications
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 la base de données si nécessaire
docker compose exec backend alembic upgrade head

Surveillance des exécutions d'agents

# Surveiller les journaux du backend pour l'activité de l'agent
docker compose logs -f backend executor

# Surveiller les ressources système pendant les exécutions de l'agent
htop
# ou
docker stats

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

Renforcement de la sécurité

# N'exposez JAMAIS directement les ports 8000/3000 à Internet sans authentification
# Utilisez Nginx ou Caddy comme proxy inverse avec HTTPS :

# Fichier Caddy :
# autogpt.yourdomain.com {
#     reverse_proxy localhost:3000
# }
# api.autogpt.yourdomain.com {
#     reverse_proxy localhost:8000
# }

# Restreindre l'accès du système de fichiers de l'agent
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 de manque de mémoire

# Le build Docker a besoin de 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 renvoie 500 / « Base de données non prête »

# Vérifier l'état de la base de données
docker compose ps db
docker compose logs db

# Exécuter les migrations de la base de données manuellement
docker compose exec backend alembic upgrade head

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

Le frontend affiche « Échec de connexion au backend »

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

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

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

L'exécuteur d'agents plante / est arrêté pour 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 le nombre d'exécutions d'agents simultanées
MAX_CONCURRENT_RUNS=2

Connexion Redis refusée

# Vérifier que Redis est en cours d'exécution
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 nécessite une authentification, définissez :
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

---

Pour aller plus loin

• 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 des GPU sur Clore.ai

• Communauté Discord d'AutoGPT