> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/autogpt.md).

# Agent autonome AutoGPT

## Aperçu

[AutoGPT](https://github.com/Significant-Gravitas/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](https://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

```bash
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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# ── 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

```bash
# 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

```bash
# 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

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

```bash
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](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md).

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

```bash
# 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

```bash
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

```bash
# 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é

```bash
# 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

```bash
# 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

```bash
# 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 »

```bash
# 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 »

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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](https://docs.agpt.co)
* [Dépôt GitHub d'AutoGPT](https://github.com/Significant-Gravitas/AutoGPT)
* [Guide d'installation de la plateforme AutoGPT](https://docs.agpt.co/platform/getting-started)
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md)
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md)
* [Comparaison GPU Clore.ai](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md)
* [Communauté Discord d'AutoGPT](https://discord.gg/autogpt)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/autogpt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.