Les administrateurs système et les développeurs peuvent auto-héberger AgentGPT sur leur propre infrastructure en quelques minutes grâce à Docker et Docker Compose. En déployant l'application localement ou au sein d'un cloud privé virtuel (VPC), les organisations conservent un contrôle total sur la définition des objectifs, les étapes de raisonnement intermédiaire, l'historique des requêtes et les enregistrements en base de données, éliminant ainsi le risque d'exposer des contextes opérationnels sensibles à des services SaaS publics mutualisés.
Ce guide présente l'architecture globale, les prérequis techniques, les procédures de déploiement conteneurisé (automatisé et manuel), les recommandations de durcissement de sécurité ainsi que les considérations opérationnelles liées au cycle de vie du projet.
Architecture du système et fonctionnement
AgentGPT orchestre l'exécution récursive d'agents autonomes via une architecture modulaire multiconteneur :
- Service Frontend (
frontend) : Application web développée avec Next.js 13, TypeScript, Tailwind CSS et HeadlessUI. Accessible sur le port3000, elle fournit l'interface utilisateur permettant de nommer un agent, de définir son objectif principal, de visualiser en temps réel la création et l'exécution des sous-tâches, puis d'exporter les résultats. - Moteur Backend (
platform) : Service Python FastAPI opérant sur le port8000. Il coordonne les chaînes d'outils de modèles de langage via LangChain, gérant la décomposition des tâches, la file d'attente prioritaire, les boucles d'itération et l'appel d'outils externes. - Couche de persistance : Prise en charge par Prisma ORM sur la couche web et SQLModel côté backend, elle enregistre de manière fiable les configurations des agents, les sessions utilisateurs et les journaux détaillés dans une base de données MySQL.
- Interactions avec les API externes : L'état applicatif et l'orchestration demeurent sur l'hôte Docker privé, tandis que les inférences s'effectuent via des requêtes sortantes sécurisées (HTTPS) vers l'API OpenAI, avec la possibilité d'adjoindre l'API Serper (recherche web) et Replicate (génération d'images).
Prérequis indispensables
Avant de commencer l'installation, assurez-vous que la machine cible respecte les exigences suivantes :
- Docker et Docker Compose : Docker Engine 20.10+ ou Docker Desktop opérationnel avec le support de Compose v2.
- Git : Requis pour cloner le dépôt source officiel.
- Node.js 18+ : Nécessaire si vous optez pour le script d'installation interactif en ligne de commande.
- Clés d'accès aux API :
- Une clé d'API OpenAI valide disposant d'un quota de jetons suffisant (supportant GPT-4 ou GPT-3.5-turbo).
- (Optionnel) Une clé d'API Serper pour permettre à l'agent d'effectuer des recherches sur le Web.
- (Optionnel) Un jeton d'API Replicate pour la génération de visuels.
Méthode 1 : Déploiement rapide via le script de configuration automatisé
Le dépôt AgentGPT inclut un utilitaire interactif qui configure automatiquement les variables d'environnement, installe les dépendances et compile les conteneurs Docker.
1. Cloner le dépôt
git clone https://github.com/reworkd/AgentGPT.git
cd AgentGPT
2. Exécuter le script d'initialisation
Lancez la commande correspondant à votre système d'exploitation :
- Linux / macOS :
./setup.sh - Windows (PowerShell ou Invite de commandes) :
setup.bat
3. Répondre aux invites de configuration
L'assistant vous demandera de renseigner :
- Votre clé d'API OpenAI.
- Les clés optionnelles pour Serper et Replicate.
- Vos préférences de réseau et d'assignation de ports.
Une fois la compilation et le lancement terminés, ouvrez votre navigateur à l'adresse http://localhost:3000 pour accéder à la console de gestion.
Méthode 2 : Déploiement manuel avec Docker Compose
Pour les serveurs de production, les pipelines d'intégration continue (CI/CD) ou les environnements de serveurs sans session interactive, le déploiement direct via Docker Compose est la méthode recommandée.
1. Cloner et inspecter le projet
git clone https://github.com/reworkd/AgentGPT.git
cd AgentGPT
Le fichier docker-compose.yml situé à la racine spécifie les deux services fondamentaux : frontend (basé sur ./next/Dockerfile) et platform (basé sur ./platform avec la cible prod).
2. Configurer les variables d'environnement
Copiez le modèle de configuration dans le répertoire attendu par Next.js :
cp .env.example ./next/.env
Ouvrez le fichier ./next/.env avec un éditeur et renseignez les paramètres essentiels :
# Limite maximale de boucles pour éviter une consommation excessive de jetons
NEXT_PUBLIC_MAX_LOOPS="50"
REWORKD_PLATFORM_MAX_LOOPS="50"
# Points de terminaison réseau internes
NODE_ENV="production"
NEXT_PUBLIC_BACKEND_URL="http://localhost:8000"
# Sécurité des sessions et de l'authentification
NEXTAUTH_SECRET="generez-une-chaine-aleatoire-robuste-dau-moins-32-octets"
NEXTAUTH_URL="http://localhost:3000"
# Clés d'API pour les modèles et outils
OPENAI_API_KEY="sk-votre-cle-openai"
SERPER_API_KEY="votre-cle-optionnelle-serper"
3. Compiler et démarrer les conteneurs en arrière-plan
Compilez les images et démarrez les services en mode détaché :
docker compose up --build -d
4. Vérifier l'état des services et les journaux
Contrôlez le statut des conteneurs actifs :
docker compose ps
Consultez les journaux en direct pour valider le bon déroulement du démarrage :
docker compose logs -f
Accédez à http://localhost:3000 pour créer et exécuter votre premier agent autonome en environnement privé.
Durcissement de la sécurité pour les réseaux d'entreprise
La configuration par défaut de Docker Compose est conçue pour le développement local. Pour une exploitation sereine sur un réseau d'entreprise partagé, appliquez les mesures suivantes :
1. Restreindre l'exposition des ports de l'hôte
Par défaut, Docker lie les ports 3000 et 8000 à toutes les interfaces réseau (0.0.0.0). Cela peut exposer les services à des accès non autorisés sur le réseau local. Modifiez docker-compose.yml pour les restreindre à l'adresse de bouclage locale (127.0.0.1) :
services:
frontend:
ports:
- "127.0.0.1:3000:3000"
platform:
ports:
- "127.0.0.1:8000:8000"
2. Mettre en place un reverse proxy avec terminaison TLS
Placez un reverse proxy tel que Nginx, Traefik ou Caddy en amont de l'application pour imposer le chiffrement HTTPS et intégrer l'authentification d'entreprise (SSO/OAuth). Exemple de configuration Nginx :
server {
listen 443 ssl http2;
server_name agent.internal.example.com;
ssl_certificate /etc/ssl/certs/internal.crt;
ssl_certificate_key /etc/ssl/private/internal.key;
location / {
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
3. Imposer un plafonnement strict des boucles
Les agents autonomes confrontés à des objectifs trop généraux peuvent entrer dans des cycles récursifs continus de planification. Définissez impérativement des valeurs mesurées pour NEXT_PUBLIC_MAX_LOOPS et REWORKD_PLATFORM_MAX_LOOPS (typiquement entre 20 et 50) afin de préserver votre budget d'API.
4. Circonscrire la frontière de confidentialité des données
L'auto-hébergement garantit que le code source, la base de données locale et les traces d'exécution restent strictement confinés à votre infrastructure interne. Cependant, le contenu textuel des requêtes et le raisonnement continuent de transiter sur Internet vers l'API OpenAI. Pour les opérations hautement sensibles, envisagez de faire transiter les flux par une passerelle Azure OpenAI privée ou un proxy d'inspection muni de règles de prévention des fuites de données (DLP).
Cycle de vie du projet et maintenance opérationnelle
Avant d'ériger AgentGPT en outil central de vos flux d'automatisation, il convient de prendre en compte l'état actuel de son écosystème :
- Statut d'archivage : Le dépôt open-source
reworkd/AgentGPTsur GitHub a été officiellement archivé (en lecture seule) au début de l'année 2026 suite à l'évolution des priorités des mainteneurs. Le code demeure stable et pertinent pour des preuves de concept (PoC) et des flux isolés, mais ne bénéficiera plus de correctifs de vulnérabilités en amont. - Verrouillage des dépendances : Lorsque vous compilez les images Docker depuis les sources, figez les versions des images de base ainsi que les dépendances npm et Python pour éviter d'éventuelles régressions de build futures.
- Perspective d'évolution : Pour des architectures avancées exigeant une collaboration multi-agents complexe, l'intégration continue de nouveaux outils personnalisés ou des étapes d'approbation humaine rigoureuses (Human-in-the-loop), il est conseillé d'évaluer en parallèle des frameworks activement maintenus tels que CrewAI, AutoGen ou LangGraph.