Comment auto-héberger AgentGPT avec Docker et connecter des points de terminaison LLM locaux ou privés

L'auto-hébergement d'AgentGPT sur votre propre infrastructure permet aux équipes d'ingénierie et de sécurité d'exécuter des flux de travail basés sur des agents IA autonomes (Autonomous Agents) sans transmettre d'instructions confidentielles, d'objectifs stratégiques ou de données d'entreprise à des API cloud externes. Comme les agents autonomes procèdent par itérations récursives — décomposant les objectifs en sous-tâches, évaluant les résultats intermédiaires et sollicitant le modèle linguistique des dizaines de fois par exécution —, l'usage de points de terminaison d'inférence locaux ou privés élimine également le coût récurrent des jetons (tokens) et les limites de débit.

Conçu à l'origine en open source par Reworkd, AgentGPT fournit une plateforme web d'orchestration d'agents autonomes articulée autour d'un frontend Next.js, d'un backend de plateforme FastAPI et d'une base de données relationnelle MySQL. Bien que configuré par défaut pour s'interfacer avec l'API publique d'OpenAI, un paramétrage ciblé du réseau Docker, des variables d'environnement et de serveurs d'inférence compatibles OpenAI (tels qu'Ollama, LocalAI ou vLLM) permet de créer un environnement d'exécution totalement souverain et confidentiel.

Vue d'ensemble de l'architecture et gestion du réseau Docker

L'orchestration d'AgentGPT avec Docker Compose repose sur trois conteneurs distincts :

1. Frontend (next) : Port 3000, interface visuelle pour la configuration des agents et le suivi interactif de l'état des tâches.
2. Backend plateforme (platform) : Port 8000, service basé sur FastAPI chargé de la boucle de décision autonome, du séquençage des tâches et des requêtes LLM.
3. Base de données (db) : Port 3306, serveur MySQL enregistrant l'historique d'exécution des agents, le statut des sous-tâches et les réglages de configuration.

+-------------------------------------------------------------------------+
| Réseau interne Docker (agentgpt-network)                                |
|                                                                         |
|  [ Frontend: Next.js ] <---> [ Backend: FastAPI Platform ] <---> [ DB ] |
|         (:3000)                         (:8000)                (:3306)  |
+--------------------------------------------|----------------------------+
                                             | (REWORKD_PLATFORM_OPENAI_API_BASE)
                                             v
                     +--------------------------------------------+
                     | Machine Hôte / Réseau Privé d'Inférence    |
                     | host.docker.internal:11434/v1              |
                     | [ Ollama / vLLM / LocalAI Endpoint ]       |
                     +--------------------------------------------+

Le piège de la communication conteneur-hôte

L'erreur de configuration la plus fréquente lors de la connexion à un modèle local consiste à renseigner l'adresse de l'API avec http://localhost:11434 ou http://127.0.0.1:11434. Au sein d'un conteneur Docker, localhost désigne l'espace réseau isolé du conteneur lui-même, et ne permet pas d'atteindre le serveur d'inférence qui tourne sur le système d'exploitation hôte.

Pour relier correctement les environnements :

• Sous macOS et Windows (Docker Desktop) : Utilisez directement http://host.docker.internal:11434/v1.
• Sous Linux : Ajoutez l'instruction extra_hosts: ["host.docker.internal:host-gateway"] dans la définition du service platform du fichier docker-compose.yml, ce qui permet au conteneur de résoudre l'adresse IP de la passerelle hôte.
• Réseau Compose unifié : Si vous lancez Ollama ou LocalAI dans le même fichier Docker Compose, désignez-le directement par son nom de service (ex. : http://ollama:11434/v1).

Étape 1 : Préparer le point de terminaison LLM local ou privé

Le serveur d'inférence doit exposer une API REST HTTP respectant la spécification d'OpenAI (principalement /v1/chat/completions et /v1/models).

Option A : Ollama (Idéal pour stations de travail et environnements de développement)

Lancez Ollama en l'associant à toutes les interfaces réseau pour autoriser les requêtes entrantes de Docker :

# Sous Linux, ajustez la variable dans systemd ou lancez manuellement
OLLAMA_HOST=0.0.0.0:11434 ollama serve

Téléchargez un modèle réputé pour sa précision logique et sa conformité au format JSON :

ollama pull qwen2.5:14b
# ou
ollama pull llama3.1:8b

Testez l'accessibilité de l'endpoint avec cURL :

curl http://localhost:11434/v1/models

Option B : vLLM (Recommandé pour serveurs GPU dédiés et forte charge)

Sur un serveur de calcul privé équipé de cartes graphiques, démarrez le serveur vLLM :

python3 -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 8000

Étape 2 : Cloner AgentGPT et renseigner les variables d'environnement

Clonez le dépôt officiel du projet :

git clone https://github.com/reworkd/AgentGPT.git
cd AgentGPT

Générez le fichier de configuration à partir du modèle :

cp .env.example .env

Paramètres essentiels dans le fichier .env

Ouvrez le fichier .env à la racine (ainsi que platform/.env si vous compilez les modules séparément) :

# ----------------------------------------
# Configuration du point de terminaison LLM
# ----------------------------------------
# Adresse résolue via host.docker.internal
# ATTENTION : Ne pas inclure de barre oblique finale (/v1 et non /v1/)
REWORKD_PLATFORM_OPENAI_API_BASE=http://host.docker.internal:11434/v1

# Les bibliothèques clientes d'OpenAI requièrent une chaîne non vide
# Les moteurs locaux n'effectuent pas de vérification ; renseignez une valeur fictive
OPENAI_API_KEY=local-secret-key

# ----------------------------------------
# Base de données
# ----------------------------------------
DATABASE_URL=mysql://root:password@db:3306/agentgpt
MYSQL_ROOT_PASSWORD=password
MYSQL_DATABASE=agentgpt

# ----------------------------------------
# Clé de session
# ----------------------------------------
NEXTAUTH_SECRET=generate-a-secure-random-32-byte-hex-key
NEXTAUTH_URL=http://localhost:3000

Règle de syntaxe : La variable REWORKD_PLATFORM_OPENAI_API_BASE ne doit pas contenir /chat/completions ni se terminer par un slash /. Le code du backend concatène automatiquement les chemins de l'API ; un slash supplémentaire produirait une URL incorrecte telle que //chat/completions, provoquant des erreurs HTTP 404.

Étape 3 : Ajuster docker-compose.yml pour les hôtes Linux

Sur les distributions Linux, enrichissez la déclaration du service platform dans docker-compose.yml :

services:
  platform:
    build:
      context: ./platform
      dockerfile: Dockerfile
    environment:
      - REWORKD_PLATFORM_OPENAI_API_BASE=http://host.docker.internal:11434/v1
      - OPENAI_API_KEY=local-secret-key
      - DATABASE_URL=mysql://root:password@db:3306/agentgpt
    ports:
      - "8000:8000"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    depends_on:
      - db

  frontend:
    build:
      context: ./next
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NEXTAUTH_URL=http://localhost:3000
      - NEXTAUTH_SECRET=generate-a-secure-random-32-byte-hex-key
    depends_on:
      - platform

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: agentgpt
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

Étape 4 : Compiler et démarrer les conteneurs

Lancez le déploiement avec Docker Compose :

docker compose up -d --build

Consultez les journaux du backend pour vérifier l'initialisation et la liaison avec la base de données :

docker compose logs -f platform

Une fois que tous les conteneurs fonctionnent normalement, ouvrez votre navigateur et rendez-vous sur http://localhost:3000.

Étape 5 : Configurer l'interface et lancer un agent autonome

1. Ouvrir les Paramètres : Cliquez sur l'icône d'engrenage (Settings) située dans la barre de navigation inférieure gauche.
2. Indiquer le Modèle : Saisissez l'identifiant exact du modèle déployé sur votre serveur local (par exemple qwen2.5:14b ou llama3.1:8b).
3. Régler les Paramètres d'Exécution :
   • Temperature : Définissez une valeur basse comprise entre 0.2 et 0.4. Les agents autonomes requièrent une planification stricte et un formatage JSON rigoureux ; une température élevée induit des corruptions syntaxiques.
   • Seuil d'Itérations (Max Loops) : Fixez une limite initiale de 5 à 10 boucles pour évaluer le temps de traitement de votre matériel.
4. Déployer un Agent :
   • Agent Name : Local-Infra-Auditor
   • Goal : Identifier les trois principaux verrous réseau dans le déploiement sur site d'agents IA et formuler des solutions techniques hiérarchisées.
   • Cliquez sur Deploy Agent.
5. Suivre le Déroulement : Observez la décomposition dynamique de l'objectif, la génération et l'exécution séquentielle des sous-tâches via le modèle local, ainsi que la production du rapport de synthèse final.

Recommandations pratiques et sélection des modèles

1. Exigences fonctionnelles imposées au modèle local

Le flux d'exécution d'un agent autonome sollicite bien plus les capacités de raisonnement du modèle qu'une session de conversation standard :

• Il doit suivre fidèlement les contraintes des prompts système et restituer en permanence un format JSON valide.
• Il doit être capable d'estimer avec discernement si l'objectif est atteint afin d'éviter les boucles d'exécution infinies.

Les modèles de moins de 7 milliards de paramètres (7B) ou non optimisés pour le suivi d'instructions échouent fréquemment lors de l'analyse structurelle des tâches. Nous préconisons :

• Socle minimal recommandé : Llama-3.1-8B-Instruct ou Qwen-2.5-7B-Instruct.
• Niveau de production optimal : Qwen-2.5-14B/32B ou Llama-3.1-70B (quantifié sur serveurs multi-GPU).

2. Gestion de la fenêtre de contexte

Au fur et à mesure que les tâches s'enchaînent, la taille de l'historique conversationnel croît de manière significative :

• Avec Ollama, créez un Modelfile personnalisé incluant PARAMETER num_ctx 16384 pour éviter toute coupure inattendue du contexte lors d'exécutions longues.

3. Statut du dépôt en amont

Le dépôt GitHub reworkd/AgentGPT a été archivé en janvier 2026 et placé en lecture seule. Bien que sa conception architecturale demeure une excellente référence opérationnelle pour prototyper et bâtir des systèmes internes, les organisations souhaitant une exploitation à long terme doivent figer les versions de leurs dépendances, créer leurs propres images Docker privées et gérer de manière autonome la sécurité de leurs identifiants.

Références

• GitHub - reworkd/AgentGPT: 🤖 Assemble, configure, and deploy autonomous AI Agents in your browser.
• Docker Compose | Docker Docs
• GitHub - ollama/ollama: Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.