Atelier IA locale — Installer votre assistant autonome

Préparer le PC

Vérifier la machine avant d'installer quoi que ce soit

Une IA locale sollicite deux mémoires bien distinctes, souvent confondues. La RAM (mémoire système, gérée par le processeur) accueille les modèles texte d'Ollama et le reste du système : 16 GB minimum, 32 GB confortables. La VRAM (mémoire intégrée à la carte graphique) est beaucoup plus rapide mais plus petite : c'est elle qui fait tourner les calculs du GPU. Règle simple : les modèles texte se contentent de la RAM et utilisent la VRAM si elle est libre ; la génération d'images (ComfyUI) vit surtout en VRAM. À cela s'ajoutent le disque (30 à 50 GB de modèles) et un Windows à jour, la veille désactivée laissant le service accessible en arrière-plan.

1.1 — Windows à jour
Vérifiez la version de Windows et lancez Windows Update. Ollama et Node.js nécessitent une version récente (Windows 10 21H2+ ou Windows 11).
Version de Windows
winver (ou : Get-ComputerInfo -Property WindowsProductName,WindowsVersion)
Ouvrir Windows Update
Start-Process "ms-settings:windowsupdate"
1.2 — Inventaire RAM et disque
La RAM est la mémoire principale, partagée par tout le système : elle héberge les modèles texte quand ils ne tiennent pas en VRAM. Repères : 16 GB minimum, 32 GB confortables pour faire tourner un modèle 14B en même temps que votre usage courant. Le disque, lui, doit libérer 30 à 50 GB pour la stack complète.
RAM totale (Go)
Get-CimInstance Win32_ComputerSystem | ForEach-Object { [math]::Round($_.TotalPhysicalMemory/1GB,1) }
Espace disque libre (Go)
Get-PSDrive C | ForEach-Object { [math]::Round($_.Free/1GB,1) }
1.3 — Inventaire VRAM : la mémoire du GPU
La VRAM est la mémoire de la carte graphique, très rapide mais limitée : c'est elle qui détermine quels modèles tiennent « entièrement sur le GPU ». Repères VRAM pour les images (ComfyUI) : 6 GB = modèles légers seulement ; 8 GB = SDXL confortable ; 12 à 16 GB = Flux et modèles lourds ; 24 GB = tout tourne. Pour Ollama : si la VRAM est supérieure ou égale à la taille du modèle, il est chargé entièrement sur le GPU (rapide) ; sinon Ollama partage entre VRAM et RAM (fonctionnel, mais nettement plus lent).
VRAM réelle de chaque GPU (via le registre)
Get-ChildItem "HKLM:\SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}" | ForEach-Object { $p = Get-ItemProperty $_.PSPath -ErrorAction SilentlyContinue; if ($p.'HardwareInformation.qwMemorySize') { "{0} : {1} GB" -f $p.DriverDesc, [math]::Round($p.'HardwareInformation.qwMemorySize'/1GB,1) } }
💡 Attention : la commande classique Win32_VideoController affiche au plus 4 GB de VRAM — c'est un artefact connu de Windows. Seule la commande registre ci-dessus donne la vraie valeur. Si la VRAM vous manque, la voie souveraine : mode CPU (plus lent, mais zéro dépendance), ou économisez vers une carte graphique à vous — louer une GPU cloud recréerait exactement la dépendance que l'on quitte.
1.4 — Mettre à jour les drivers GPU (si NVIDIA/AMD)
Un driver à jour est indispensable pour l'accélération. Pour NVIDIA, GeForce Experience (ou l'app NVIDIA) ; pour AMD, AMD Software. Vérifiez que le nom de votre GPU n'affiche pas « Microsoft Basic Display Adapter » (signe d'un driver manquant). Rappel : c'est la taille de la VRAM (étape précédente) qui détermine quels modèles tiennent sur le GPU, pas seulement le nom du GPU.
Confirmer le GPU réel (pas le driver générique)
Get-CimInstance Win32_VideoController | Select-Object Name, AdapterCompatibility
💡 NVIDIA : après installation du driver, redémarrez le PC avant d'installer Ollama.
1.5 — Désactiver la veille
Si le PC s'endort, le service Ollama s'arrête avec lui et votre assistant devient injoignable. On met la veille sur « Jamais » (sur secteur).
Veille : jamais (sur secteur)
powercfg /change standby-timeout-ac 0
Veille écran : 15 min (économie, sans couper le service)
powercfg /change monitor-timeout-ac 15
1.6 — Redémarrer pour valider
Un redémarrage après les mises à jour drivers et Windows garantit une base saine avant d'installer la stack.
Redémarrer
Restart-Computer
💡 Après le redémarrage, relancez ce guide : la progression est sauvegardée.

Installer Ollama

Le moteur qui fait tourner les modèles en local

Ollama est le logiciel qui télécharge et exécute les modèles d'IA directement sur votre machine. Rien ne part dans le cloud : les données restent chez vous. Il crée un service local (sur le port 11434) auquel les autres outils parleront.

2.1 — Télécharger et installer Ollama
La méthode la plus simple sur Windows : le gestionnaire de paquets winget. Sinon, téléchargez l'installateur sur ollama.com/download.
Installer via winget
winget install Ollama.Ollama
💡 Redémarrez le terminal après l'installation si la commande ollama n'est pas reconnue.
2.2 — Vérifier que tout tourne
Deux vérifications : la version installée, puis le service local qui doit répondre sur le port 11434.
Version
ollama --version
Service actif (ouvrir dans le navigateur)
curl http://localhost:11434
💡 Si le service ne répond pas, lancez `ollama serve` dans un terminal, ou lancez simplement l'application Ollama (elle démarre en arrière-plan).
2.3 — Premier test avec un petit modèle
On commence par Mistral (4,4 GB) : c'est le modèle « rapide » de la stack, idéal pour valider le pipeline avant de télécharger les gros modèles.
Télécharger Mistral
ollama pull mistral
Lancer une conversation test
ollama run mistral "Bonjour, qui es-tu ?"

Télécharger les modèles

La bibliothèque : un modèle par spécialité

Un modèle d'IA n'est pas universel : un modèle de code écrit du code propre, un modèle de raisonnement réfléchit mieux, un modèle léger répond vite. La stack de LÉONARD mélange les rôles. La taille (en GB) dépend du nombre de paramètres (14B = 14 milliards). À l'exécution, Ollama charge le modèle d'abord en VRAM (rapide) et n'utilise la RAM (plus lente) que pour ce qui ne tient pas : une grande VRAM accélère tout, une grande RAM permet de faire tourner des modèles plus gros que la VRAM.

3.1 — Modèle code — Qwen 2.5 Coder 14b (9 GB)
Le spécialiste du code. C'est lui qui génère les pages HTML/CSS/JS et tout le code produit par les agents. Priorité haute.
Télécharger
ollama pull qwen2.5-coder:14b
3.2 — Modèle général — Gemma 3 12b (8,2 GB)
Le couteau suisse : textes, résumés, traductions, questions générales. C'est aussi le moteur de l'agent texte.
Télécharger
ollama pull gemma3:12b
3.3 — Modèle rapide — Mistral (4,4 GB)
Sert de « petit modèle » pour les tâches simples (titres, classifications) : il répond en une fraction de seconde et libère les gros modèles.
Télécharger
ollama pull mistral
3.4 — Modèles optionnels
À télécharger seulement si vous en avez l'usage et la RAM. DeepSeek R1 pour le raisonnement long, Llama 3.1 en généraliste de secours.
Raisonnement
ollama pull deepseek-r1:14b
Généraliste
ollama pull llama3.1
💡 Un modèle non utilisé ne consomme rien : il dort sur le disque. Téléchargez à la demande.
3.5 — Vérifier la bibliothèque
La liste des modèles installés avec leur taille.
Liste des modèles
ollama list

Générer des images (ComfyUI)

Le studio d'images, lui aussi en local

ComfyUI est l'Ollama des images : un moteur de génération par diffusion qui tourne entièrement sur votre machine. Les modèles d'images vivent en VRAM (mémoire du GPU) : une VRAM de 8 GB permet le confort avec SDXL, 12 GB ouvrent la porte de Flux, 24 GB n'ont aucune restriction courante. La RAM intervient en secours quand la VRAM déborde, mais au prix de la vitesse. Sans GPU, le mode CPU existe : c'est le mode patience.

4.1 — Vérifier la VRAM avant tout
La question n'est pas « ai-je une carte graphique ? » mais « combien de GB de VRAM ? ». Repères : 6 GB = modèles légers uniquement ; 8 GB = SDXL confortable ; 12 à 16 GB = Flux et modèles lourds ; 24 GB = aucune restriction courante.
VRAM réelle de chaque GPU (registre Windows)
Get-ChildItem "HKLM:\SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}" | ForEach-Object { $p = Get-ItemProperty $_.PSPath -ErrorAction SilentlyContinue; if ($p.'HardwareInformation.qwMemorySize') { "{0} : {1} GB" -f $p.DriverDesc, [math]::Round($p.'HardwareInformation.qwMemorySize'/1GB,1) } }
💡 Le filtre « out of memory » en cours de génération signale presque toujours une VRAM insuffisante pour le modèle chargé — pas un manque de RAM système.
4.2 — Installer ComfyUI (portable)
La version portable Windows embarque tout : Python, dépendances, lanceurs GPU et CPU. Téléchargez l'archive depuis le dépôt officiel GitHub, décompressez-la, c'est tout.
Page officielle des releases
https://github.com/comfyanonymous/ComfyUI/releases
Alternative git (les avancés)
git clone https://github.com/comfyanonymous/ComfyUI.git
💡 Dans l'archive portable, cherchez run_nvidia_gpu.bat (GPU NVIDIA) ou run_cpu.bat : ce sont les lanceurs, rien d'autre à installer.
4.3 — Télécharger un modèle d'image
Un modèle de diffusion est un fichier .safetensors qui vit dans models/checkpoints. SDXL (~7 GB) est le polyvalent de référence ; Flux (~12 GB) va plus loin en réalisme mais réclame plus de VRAM. Les deux sources majeures : HuggingFace (officiel) et CivitAI (communauté, tous styles).
Dossier des modèles (version portable)
explorer ComfyUI_windows_portable\ComfyUI\models\checkpoints
Modèle SDXL de départ (HuggingFace, ~7 GB)
https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0
💡 Vérifiez la taille du fichier avant de télécharger : au-delà de votre VRAM, ComfyUI basculera en RAM (lent) ou échouera en mode CPU.
4.4 — Première génération
Lancez ComfyUI, ouvrez l'interface dans le navigateur (port 8188), écrivez votre prompt, validez. Une image en 5 à 30 secondes sur GPU selon le modèle et la VRAM.
Lancer (GPU recommandé)
run_nvidia_gpu.bat
Ou mode CPU (sans GPU compatible)
run_cpu.bat
Interface web
http://127.0.0.1:8188
4.5 — Piloter ComfyUI depuis vos agents (optionnel)
ComfyUI expose une API JSON locale : vos agents OpenCode peuvent lui envoyer des workflows pour générer des images à la demande — le début d'un studio créatif autonome, toujours sans cloud.
API accessible (après lancement de ComfyUI)
http://127.0.0.1:8188/system_stats
💡 La liaison agent ↔ ComfyUI se fait par workflow JSON prédéfini : créez d'abord votre workflow dans l'interface, exportez-le, puis les agents ne font que l'envoyer avec votre prompt.

Installer OpenCode

L'assistant qui pilote les modèles

Ollama fait tourner les modèles, mais c'est OpenCode qui les orchestre : il gère la conversation, les fichiers, les commandes, et peut déléguer la tâche à des agents spécialisés. C'est le « cerveau exécutif » de LÉONARD.

5.1 — Installer Node.js (si absent)
OpenCode est un programme Node.js. Vérifiez d'abord s'il est déjà installé (souvent le cas).
Version de Node
node --version
Si absent : installer via winget
winget install OpenJS.NodeJS.LTS
5.2 — Installer OpenCode
Un simple paquet npm global.
Installation
npm install -g opencode-ai@latest
Vérification
opencode --version
5.3 — Premier lancement
Créez un dossier pour vos projets IA, lancez-y OpenCode. La première fois, il vous propose un choix de modèle : sélectionnez Ollama puis le modèle voulu.
Créer et entrer dans le dossier projet
mkdir ia-projets; cd ia-projets
Lancer OpenCode
opencode
💡 OpenCode s'utilise dans le terminal. La commande `opencode` dans un dossier en fait le point d'entrée.

Configurer la stack

opencode.jsonc : le tableau de bord des modèles

Ce fichier dit à OpenComment quelles machines de modèles existent. Chaque modèle déclare ses capacités : `tool_call: true` signifie qu'il peut appeler des outils (lire/écrire des fichiers, lancer des commandes) — indispensable pour un agent autonome. `reasoning: true` marque les modèles qui produisent un raisonnement visible.

6.1 — Localiser le dossier de configuration
OpenCode lit sa configuration dans ~/.config/opencode/. Créez le dossier s'il n'existe pas.
Créer le dossier (PowerShell)
New-Item -ItemType Directory -Force "$env:USERPROFILE\.config\opencode"
Ouvrir le dossier
explorer "$env:USERPROFILE\.config\opencode"

6.2 — Créer opencode.jsonc

Copiez ce fichier dans le dossier de configuration. Il déclare le provider Ollama et la liste des modèles avec leur rôle.

Contenu de opencode.jsonc

{
  "$schema": "https://opencode.ai/config.json",
  "small_model": "ollama/mistral",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": { "baseURL": "http://localhost:11434/v1" },
      "models": {
        "qwen2.5-coder:14b": {
          "name": "Qwen 2.5 Coder 14b — code",
          "tool_call": true,
          "limit": { "context": 32768, "output": 8192 }
        },
        "gemma3:12b": {
          "name": "Gemma 3 12b — général",
          "tool_call": true,
          "limit": { "context": 16384, "output": 8192 }
        },
        "mistral:latest": {
          "name": "Mistral — rapide",
          "tool_call": true,
          "limit": { "context": 16384, "output": 8192 }
        },
        "deepseek-r1:14b": {
          "name": "DeepSeek R1 14b — raisonnement",
          "tool_call": false,
          "reasoning": true,
          "limit": { "context": 32768, "output": 8192 }
        }
      }
    }
  }
}

💡 Le fichier .jsonc accepte les commentaires // — pratique pour annoter votre configuration.

6.3 — Vérifier la détection
Relancez OpenCode : les modèles Ollama doivent apparaître dans la sélection. Si la liste est vide, Ollama n'est pas joignable — vérifiez le service (étape 2.2).
Relancer OpenCode
opencode

Créer les agents autonomes

Des spécialistes délégués par le modèle principal

Un agent OpenCode est un sous-traitant : le modèle principal reçoit votre demande, et délègue à l'agent compétent. Chaque agent est un simple fichier Markdown avec un en-tête (front-matter) qui indique son rôle, son mode et le modèle qu'il utilise. C'est ce qui rend le système « autonome » : la bonne tâche va au bon modèle, sans que vous ayez à choisir.

7.1 — Créer le dossier des agents
Les agents vivent dans un sous-dossier `agent/` de la configuration.
Créer le dossier
New-Item -ItemType Directory -Force "$env:USERPROFILE\.config\opencode\agent"

7.2 — Agent coder-local (Qwen)

Le générateur de code. Créez le fichier `coder-local.md` avec ce contenu.

Fichier agent/coder-local.md

---
description: Génère du code (HTML/CSS/JS, pages web) avec le modèle local Qwen 2.5 Coder via Ollama.
mode: subagent
model: ollama/qwen2.5-coder:14b
---

Tu es un générateur de code local (Ollama, Qwen 2.5 Coder).

- Écris du code complet et fonctionnel, sans commentaires superflus.
- Pour une page HTML : structure HTML5 valide, CSS et JS intégrés si demandé, responsive.
- Termine en retournant le code complet demandé, prêt à être sauvegardé dans un fichier.

7.3 — Agent texte-local (Gemma)

Le spécialiste des textes : résumés, traductions, relectures. Créez `texte-local.md`.

Fichier agent/texte-local.md

---
description: Tâches de texte (résumés, traductions, relectures, questions générales) avec le modèle local Gemma 3 via Ollama.
mode: subagent
model: ollama/gemma3:12b
---

Tu es un assistant de texte local (Ollama, Gemma 3).

- Résume, traduis, relis et réponds aux questions générales de façon claire et concise.
- Réponds dans la langue de l'utilisateur.
- Tu n'écris pas de code : pour le code, renvoie le besoin au modèle principal.

💡 Le champ `mode: subagent` signifie que cet agent est appelé par le modèle principal, pas directement par vous.

7.4 — Agents supplémentaires (optionnel)
Le même schéma permet d'ajouter d'autres spécialistes : un agent « recherche » (deepseek-r1), un agent « relecture », etc. Un fichier = un agent. Réutilisez le même squelette.
Schéma générique d'un nouvel agent
--- description: [Brève description du rôle] mode: subagent model: ollama/[nom-du-modele] --- [Instructions système de l'agent]

Test de bout en bout

Valider que l'ensemble fonctionne

Le test final simule un usage réel : le modèle principal doit comprendre la demande, déléguer au bon agent, récupérer le résultat et vous le rendre. Si une brique manque (modèle absent, service arrêté, agent mal nommé), c'est ici que ça se voit.

8.1 — Lancer OpenCode dans votre dossier projet
Point de départ de tout test.
Lancer
opencode
8.2 — Test du modèle principal
Posez une question simple. Le modèle doit répondre. Si « model not found », vérifiez qu'Ollama tourne et que le nom du modèle dans opencode.jsonc correspond exactement à `ollama list`.
Demande de test dans OpenCode
Explique en 2 phrases ce qu'est l'investissement momentum.
8.3 — Test de l'agent code
Demandez explicitement l'agent. Le bon modèle (Qwen) doit se charger de la tâche.
Demande de test
Utilise l'agent coder-local pour créer une page HTML d'une carte de visite minimaliste.
💡 Dans OpenCode, tapez `/agents` pour voir la liste des agents détectés.
8.4 — Test de l'agent texte
Même principe, avec Gemma en moteur.
Demande de test
Utilise l'agent texte-local pour résumer ceci en 3 points : [collez un texte]
8.5 — Test d'autonomie (multi-étapes)
La vraie preuve : une tâche qui enchaîne plusieurs actions sans votre intervention.
Demande autonome
Crée un fichier index.html avec une landing page simple pour un guide d'investissement, puis ouvre-le dans le navigateur.

8.6 — Dépannage rapide

Les quatre pannes classiques et leur solution.

Panne : « connection refused »

# Ollama n'est pas lancé → ollama serve (ou relancer l'app Ollama)

Panne : modèle absent d'OpenCode

# Vérifier le nom exact : ollama list   puis comparer à opencode.jsonc

Panne : agent non détecté

# Vérifier le dossier : Get-ChildItem "$env:USERPROFILE\.config\opencode\agent"

Panne : « out of memory » en génération d'images

# VRAM insuffisante → fermez les applications GPU, choisissez un modèle plus léger, ou passez en run_cpu.bat (plus lent)

Préparer le PC

1.1 — Windows à jour

1.2 — Inventaire RAM et disque

1.3 — Inventaire VRAM : la mémoire du GPU

1.4 — Mettre à jour les drivers GPU (si NVIDIA/AMD)

1.5 — Désactiver la veille

1.6 — Redémarrer pour valider

Installer Ollama

2.1 — Télécharger et installer Ollama

2.2 — Vérifier que tout tourne

2.3 — Premier test avec un petit modèle

Télécharger les modèles

3.1 — Modèle code — Qwen 2.5 Coder 14b (9 GB)

3.2 — Modèle général — Gemma 3 12b (8,2 GB)

3.3 — Modèle rapide — Mistral (4,4 GB)

3.4 — Modèles optionnels

3.5 — Vérifier la bibliothèque

Générer des images (ComfyUI)

4.1 — Vérifier la VRAM avant tout

4.2 — Installer ComfyUI (portable)

4.3 — Télécharger un modèle d'image

4.4 — Première génération

4.5 — Piloter ComfyUI depuis vos agents (optionnel)

Installer OpenCode

5.1 — Installer Node.js (si absent)

5.2 — Installer OpenCode

5.3 — Premier lancement

Configurer la stack

6.1 — Localiser le dossier de configuration

6.2 — Créer opencode.jsonc

6.3 — Vérifier la détection

Créer les agents autonomes

7.1 — Créer le dossier des agents

7.2 — Agent coder-local (Qwen)

7.3 — Agent texte-local (Gemma)

7.4 — Agents supplémentaires (optionnel)

Test de bout en bout

8.1 — Lancer OpenCode dans votre dossier projet

8.2 — Test du modèle principal

8.3 — Test de l'agent code

8.4 — Test de l'agent texte

8.5 — Test d'autonomie (multi-étapes)

8.6 — Dépannage rapide