> 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-ia-et-agents/autogpt.md).

# 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](https://github.com/Significant-Gravitas/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](https://clore.ai/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](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@<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

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

# Modifier le fichier d'environnement
nano .env
```

### 4. Définir les variables d'environnement requises

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

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

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

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

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

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

```bash
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](/guides/guides_v2-fr/premiers-pas/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         | 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

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

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

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

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

```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 de manque de mémoire

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

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

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

```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 le nombre d'exécutions d'agents simultanées
MAX_CONCURRENT_RUNS=2
```

### Connexion Redis refusée

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

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

***

## Pour aller plus loin

* [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 des GPU sur Clore.ai](/guides/guides_v2-fr/premiers-pas/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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
