Guide PentAGI sur Kali Linux (WSL2) — installation Microsoft Store sous Windows

Adaptation du guide PentAGI pour le cas où Kali Linux est installé depuis le Microsoft Store, c'est-à-dire en tant que distribution WSL2 sur Windows. Les commandes PentAGI (récupération, .env, docker compose) sont identiques à la doc officielle — ce qui change, c'est la préparation de l'hôte : WSL2, Docker, GPU/Ollama et surtout le réseau.

Version de référence : dépôt vxcontrol/pentagi, branche master.

---

0. Ce qui change par rapport à une install Linux native

Sujet	Linux natif	Kali WSL2 / Windows
Hôte Docker	Docker Engine local	Docker Desktop + intégration WSL (recommandé) ou Docker Engine natif dans Kali
GPU / Ollama	Ollama sur l'hôte Linux	Ollama natif sur Windows (GPU géré par le pilote Windows)
URL Ollama depuis les conteneurs	http://172.17.0.1:11434	http://host.docker.internal:11434
Accès UI	https://localhost:8443	idem — WSL2 forwarde localhost vers Windows automatiquement
systemd	présent	à activer dans /etc/wsl.conf
Ressources	natives	à cadrer via .wslconfig

Bon à savoir : ici, Kali ne sert que d'environnement Linux pour faire tourner Docker/Compose. Pas besoin de charger toute la boîte à outils Kali sur l'hôte — PentAGI lance ses propres conteneurs Kali worker (nmap, metasploit, sqlmap…) de façon isolée.

---

1. Architecture cible sur Windows/WSL2

┌──────────────────────────── Windows 11 ─────────────────────────────┐
│                                                                     │
│   Pilote NVIDIA (Windows)                                           │
│        │                                                            │
│        ▼                                                            │
│   Ollama (Windows natif)  ── GPU RTX 5060 ──  port 11434            │
│        ▲                                                            │
│        │ host.docker.internal                                       │
│   ┌────┴──────────────── WSL2 : Kali Linux ──────────────────────┐  │
│   │                                                             │  │
│   │   Docker Desktop (backend WSL2)                             │  │
│   │      │                                                      │  │
│   │      ▼                                                      │  │
│   │   Stack PentAGI (compose) : UI 8443 / backend / Postgres   │  │
│   │      │  socket Docker                                       │  │
│   │      ▼                                                      │  │
│   │   Conteneurs WORKER Kali éphémères (nmap, metasploit…)      │  │
│   └─────────────────────────────────────────────────────────────┘  │
│                                                                     │
│   Navigateur Windows ──► https://localhost:8443                     │
└─────────────────────────────────────────────────────────────────────┘
        interface réseau dédiée ──► LAB isolé (cibles vulnérables)

Pourquoi Ollama sur Windows plutôt que dans Kali ? Le pilote NVIDIA Windows gère le GPU nativement — tu évites toute la configuration GPU-dans-WSL. Les conteneurs PentAGI atteignent Ollama via host.docker.internal, qui pointe vers l'hôte Windows sous Docker Desktop.

---

2. Prérequis Windows

• Windows 10 22H2 / Windows 11 (WSL2 requis).
• Virtualisation activée dans le BIOS (VT-x/AMD-V).
• 16 Go de RAM minimum (32 Go confortable avec Ollama + workers).
• Pilote NVIDIA récent (série 570+ pour la RTX 5060 / Blackwell), installé côté Windows.
• ~40 Go libres (images Docker + workers).

---

3. Étape 1 — Installer WSL2 + Kali Linux

3.1 Activer WSL2 et installer Kali

Dans un PowerShell administrateur :

wsl --install
wsl --set-default-version 2

Installe Kali Linux depuis le Microsoft Store (ou en ligne de commande) :

wsl --install -d kali-linux

Lance Kali une première fois (menu Démarrer → « Kali Linux ») pour créer ton utilisateur, puis vérifie qu'il tourne bien en version 2 :

wsl -l -v
# La colonne VERSION doit indiquer 2 pour kali-linux. Sinon :
wsl --set-version kali-linux 2

3.2 Mettre Kali à jour

Dans le terminal Kali :

sudo apt-get update && sudo apt-get full-upgrade -y
sudo apt-get install -y curl git openssl perl ca-certificates

3.3 Activer systemd dans WSL2

Nécessaire si tu veux gérer des services (Docker natif, etc.) proprement. Édite /etc/wsl.conf :

sudo tee /etc/wsl.conf >/dev/null <<'EOF'
[boot]
systemd=true
EOF

Puis, depuis PowerShell :

wsl --shutdown

Rouvre Kali. Vérifie : systemctl is-system-running doit répondre (running/degraded, pas « offline »).

---

4. Étape 2 — Cadrer les ressources WSL2

WSL2 + Docker + Ollama + workers, c'est lourd. Alloue explicitement RAM/CPU via un fichier C:\Users\<TonUser>\.wslconfig (côté Windows) :

[wsl2]
memory=16GB
processors=8
swap=8GB

Applique en fermant WSL depuis PowerShell :

wsl --shutdown

---

5. Étape 3 — Docker

Option A — Docker Desktop + intégration WSL (recommandé)

C'est le chemin le plus fiable sous Windows, et host.docker.internal y fonctionne d'office.

1. Installe Docker Desktop for Windows et coche « Use the WSL 2 based engine ».
2. Dans Settings → Resources → WSL Integration, active l'intégration pour la distro kali-linux.
3. Dans le terminal Kali, vérifie :

docker --version
docker compose version
docker run --rm hello-world

Le socket Docker exposé dans Kali via l'intégration pointe vers le moteur Docker Desktop. PentAGI pourra créer ses conteneurs worker à travers ce socket (garde PENTAGI_DOCKER_SOCKET par défaut).

Option B — Docker Engine natif dans Kali (sans Docker Desktop)

Plus « pur », mais host.docker.internal n'est pas automatique (voir §12).

sudo apt-get install -y docker.io docker-compose-plugin
sudo systemctl enable --now docker      # systemd activé au §3.3
# Sans systemd : sudo service docker start
sudo usermod -aG docker $USER && newgrp docker
docker run --rm hello-world

---

6. Étape 4 — Ollama + GPU (côté Windows)

6.1 Installer Ollama sur Windows

Télécharge l'installeur Ollama pour Windows depuis ollama.com et installe-le. Le pilote NVIDIA Windows lui donne accès au GPU automatiquement, sans config WSL.

6.2 Rendre Ollama joignable depuis les conteneurs

Par défaut Ollama n'écoute que sur localhost. Pour que les conteneurs PentAGI l'atteignent, définis une variable d'environnement système Windows :

OLLAMA_HOST = 0.0.0.0

(Paramètres Windows → Variables d'environnement → Nouvelle variable système, puis redémarre le service/app Ollama.)

6.3 Tirer un modèle adapté à ta VRAM

Dans un terminal Windows (PowerShell) :

# 8 Go de VRAM : q4/q5
ollama pull llama3.1:8b
# ou qwen2.5:7b
# 16 Go : la variante q8 documentée par PentAGI passe
ollama pull llama3.1:8b-instruct-q8_0

Vérifie que le GPU est bien utilisé : lance une requête et regarde ollama ps (doit indiquer le GPU) ou le Gestionnaire des tâches / nvidia-smi.

---

7. Étape 5 — Récupérer PentAGI (dans Kali)

Dans le terminal Kali :

mkdir pentagi && cd pentagi

# Modèle de configuration
curl -o .env https://raw.githubusercontent.com/vxcontrol/pentagi/master/.env.example

# Exemples de config providers (pour le routage par agent)
curl -o example.custom.provider.yml \
  https://raw.githubusercontent.com/vxcontrol/pentagi/master/examples/configs/custom-openai.provider.yml
curl -o example.ollama.provider.yml \
  https://raw.githubusercontent.com/vxcontrol/pentagi/master/examples/configs/ollama-llama318b.provider.yml

# Compose principal
curl -O https://raw.githubusercontent.com/vxcontrol/pentagi/master/docker-compose.yml

Astuce WSL : travaille bien dans le système de fichiers Linux (~/pentagi), pas dans /mnt/c/.... Les performances Docker et la gestion des permissions sont bien meilleures dans le FS natif WSL2.

---

8. Étape 6 — Configurer le .env (adapté WSL2)

Édite .env. La seule différence notable avec le guide Linux natif est l'URL d'Ollama, qui pointe vers l'hôte Windows via host.docker.internal :

# --- Anthropic (Claude) : raisonnement / planification ---
ANTHROPIC_API_KEY=sk-ant-...ta_cle...
ANTHROPIC_SERVER_URL=https://api.anthropic.com/v1

# --- Google Gemini : alternative raisonnement / analyse ---
GEMINI_API_KEY=...ta_cle...
GEMINI_SERVER_URL=https://generativelanguage.googleapis.com

# --- Ollama sur Windows : agents rapides / recon ---
OLLAMA_SERVER_URL=http://host.docker.internal:11434
OLLAMA_SERVER_MODEL=llama3.1:8b-instruct-q8_0

# --- OpenAI (optionnel : requis seulement si tu actives Graphiti) ---
OPEN_AI_KEY=sk-...ta_cle...
OPEN_AI_SERVER_URL=https://api.openai.com/v1

# --- Recherche OSINT (optionnel, sans clé) ---
DUCKDUCKGO_ENABLED=true

Option B (Docker Engine natif) : host.docker.internal n'existe pas d'office. Soit tu ajoutes --add-host=host.docker.internal:host-gateway (via un override compose), soit tu remplaces l'URL par l'IP de l'hôte Windows depuis WSL :

ip route show default | awk '{print $3}'   # IP passerelle = hôte Windows
# puis OLLAMA_SERVER_URL=http://<cette_ip>:11434

---

9. Étape 7 — Sécuriser le .env

Identique au guide standard. Génère des secrets forts :

openssl rand -hex 32     # COOKIE_SIGNING_SALT
openssl rand -base64 32  # mots de passe DB

COOKIE_SIGNING_SALT=<hex_64_caracteres>
PUBLIC_URL=https://localhost:8443
CORS_ORIGINS=https://localhost:8443
PENTAGI_POSTGRES_USER=pentagi
PENTAGI_POSTGRES_PASSWORD=<mot_de_passe_fort>
SERVER_USE_SSL=true
SERVER_PORT=8443
SERVER_HOST=0.0.0.0

Nettoie les commentaires en ligne :

perl -i -pe 's/\s+#.*$//' .env

---

10. Étape 8 — Lancer et accéder

Dans Kali :

docker compose up -d
docker compose ps                 # tout doit être "running"
docker compose logs -f pentagi    # repérer une clé invalide au démarrage

Depuis un navigateur Windows, ouvre : https://localhost:8443 (WSL2 forwarde localhost automatiquement ; accepte le certificat auto-signé).

Identifiants par défaut :

• Email : admin@pentagi.com
• Mot de passe : admin → change-le immédiatement.

Crée un assistant de test dans l'UI pour vérifier que Claude/Gemini/Ollama répondent.

---

11. Étape 9 — Router les modèles par agent

Inchangé par rapport au guide principal : tu affectes un LLM par type d'agent via les fichiers YAML providers (example.ollama.provider.yml, example.custom.provider.yml), référencés par PENTAGI_LLM_SERVER_CONFIG_PATH / PENTAGI_OLLAMA_SERVER_CONFIG_PATH.

Répartition recommandée : Claude/Gemini sur Researcher et Developer (raisonnement, planification), Ollama local sur l'Executor (volume, coût nul). Schéma YAML exact : voir la Configuration Guide sur deepwiki.com/vxcontrol/pentagi et le dossier examples/configs/ du dépôt.

---

12. Spécificités et pièges WSL2

• host.docker.internal : fonctionne d'office avec Docker Desktop. Avec Docker Engine natif dans Kali, il faut l'ajouter (host-gateway) ou utiliser l'IP passerelle (§8).
• Ollama injoignable : vérifie que OLLAMA_HOST=0.0.0.0 est bien défini côté Windows et qu'Ollama a été redémarré. Le pare-feu Windows peut bloquer le port 11434 → autorise-le pour le réseau vSwitch WSL.
• Système de fichiers : reste dans ~/ (FS Linux), pas /mnt/c/. Sinon lenteurs Docker et soucis de permissions.
• Ressources : si les conteneurs sont tués ou lents, augmente memory/processors dans .wslconfig puis wsl --shutdown.
• Socket Docker & sécurité : PentAGI utilise le socket Docker pour créer ses workers — sous Docker Desktop, c'est lié au moteur Windows. Machine dédiée au lab, jamais un poste de prod.
• Isolation réseau : place tes cibles vulnérables sur un réseau isolé (VM host-only sous Hyper-V/VirtualBox, ou sous-réseau sans route vers ton LAN). WSL2 convient à un lab d'apprentissage ; l'architecture deux nœuds reste réservée à un usage avancé.
• Arrêt propre :

  docker compose down          # arrêter PentAGI

  wsl --shutdown               # libérer la RAM WSL2 côté Windows

---

13. Dépannage

Symptôme	Cause / Solution
docker introuvable dans Kali	Intégration WSL non activée dans Docker Desktop (Settings → Resources → WSL Integration)
UI inaccessible sur localhost:8443	Conteneur non démarré (docker compose ps) ou port en conflit ; certificat auto-signé à accepter
Ollama : connexion refusée	OLLAMA_HOST=0.0.0.0 côté Windows + redémarrage Ollama + pare-feu Windows
Conteneur tué / OOM	Augmenter memory dans .wslconfig puis wsl --shutdown
Lenteurs extrêmes	Projet placé dans /mnt/c/... → déplacer dans le FS Linux ~/
host.docker.internal ne résout pas (Option B)	Ajouter host-gateway ou utiliser l'IP passerelle WSL
Kali reste en WSL1	wsl --set-version kali-linux 2

---

14. Résumé du chemin le plus court

1. PowerShell admin : wsl --install → wsl --install -d kali-linux → vérifier wsl -l -v (version 2)
2. Kali : apt full-upgrade, activer systemd (/etc/wsl.conf), puis wsl --shutdown
3. Windows : .wslconfig (16 Go RAM), pilote NVIDIA, Ollama pour Windows + OLLAMA_HOST=0.0.0.0 + ollama pull llama3.1:8b
4. Docker Desktop + intégration WSL pour kali-linux (docker run hello-world OK dans Kali)
5. Kali : mkdir pentagi && cd pentagi → curl le .env, les providers et le docker-compose.yml
6. .env : ANTHROPIC_API_KEY, GEMINI_API_KEY, OLLAMA_SERVER_URL=http://host.docker.internal:11434, secrets openssl, perl -i -pe
7. docker compose up -d → navigateur Windows → https://localhost:8443 (admin@pentagi.com / admin → change le mdp)

Ce guide reprend et adapte le Guide d'installation PentAGI principal. Pour le routage par agent détaillé, les services optionnels (Graphiti, Langfuse, observabilité) et l'architecture deux nœuds, réfère-toi au guide standard.