IA souveraine
Le guide complet

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.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"

2. 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) }

3. 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) } }

   À retenir — 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.

4. 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

   À retenir — NVIDIA : après installation du driver, redémarrez le PC avant d'installer Ollama.

5. 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

6. 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

   À retenir — Après le redémarrage, relancez ce guide : la progression est sauvegardée.

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.

1. 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

   À retenir — Redémarrez le terminal après l'installation si la commande ollama n'est pas reconnue.

2. 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

   À retenir — 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).

3. 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 ?"

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.

1. 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

2. 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.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

4. 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

   À retenir — Un modèle non utilisé ne consomme rien : il dort sur le disque. Téléchargez à la demande.

5. 3.5 — Vérifier la bibliothèque

   La liste des modèles installés avec leur taille.

   Liste des modèles

   ollama list

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.

1. 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) } }

   À retenir — 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.

2. 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

   À retenir — Dans l'archive portable, cherchez run_nvidia_gpu.bat (GPU NVIDIA) ou run_cpu.bat : ce sont les lanceurs, rien d'autre à installer.

3. 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

   À retenir — 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.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

5. 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

   À retenir — 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.

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.

1. 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

2. 5.2 — Installer OpenCode

   Un simple paquet npm global.

   Installation

   npm install -g opencode-ai@latest

   Vérification

   opencode --version

3. 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

   À retenir — OpenCode s'utilise dans le terminal. La commande `opencode` dans un dossier en fait le point d'entrée.

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.

1. 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"

2. 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 }
           }
         }
       }
     }
   }

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

3. 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

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.

1. 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"

2. 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.

3. 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.

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

4. 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]

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.

1. 8.1 — Lancer OpenCode dans votre dossier projet

   Point de départ de tout test.

   Lancer

   opencode

2. 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.

3. 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.

   À retenir — Dans OpenCode, tapez `/agents` pour voir la liste des agents détectés.

4. 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]

5. 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.

6. 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)

Votre IA locale a une mémoire parfaite mais aucun souvenir : elle n'a accès qu'à ce que vous lui donnez dans chaque conversation. Un cerveau numérique, c'est l'inverse — une base de connaissances personnelle, écrite une fois, lisible par votre machine. La méthode PARA (Tiago Forte) la structure en quatre dossiers. Combinée à un assistant local, elle transforme une IA générique en un collaborateur qui connaît vos projets, vos dossiers et vos centres d'intérêt — sans que la moindre note quitte votre disque.

1. 9.1 — Pourquoi faire ça — l'IA ne vaut que ce que vous lui donnez

   Une IA cloud ne connaît rien de vous au-delà de la conversation en cours. Vos notes personnelles, en revanche, ne doivent jamais traverser internet. Le cerveau numérique local résout les deux : vous écrivez une fois sur votre disque, et votre assistant (OpenCode) relit vos fichiers pour répondre avec VOTRE contexte — vos projets en cours, vos règles, vos décisions passées. La différence se voit immédiatement : « rédige une page de vente » vs « rédige une page de vente pour mon offre, en accord avec mes notes de positioning et le ton de ma dernière lettre ».

   Principe directeur

   Un dossier sur VOTRE disque, lu par VOTRE IA. Zéro cloud, zéro abonnement, zéro fuite.

2. 9.2 — Créer la structure PARA (4 dossiers)

   PARA veut dire : Projets, Areas (domaines), Resources (ressources), Archives. Trois dossiers de classement + une boîte d'arrivée, dans un emplacement unique que vous nommerez votre cerveau.

   Créer l'arborescence (PowerShell)

   $base = "$env:USERPROFILE\MonCerveau"
   New-Item -ItemType Directory -Force "$base\00-Inbox", "$base\01-Projets", "$base\02-Domaines", "$base\03-Ressources", "$base\04-Archives"

   Ouvrir le cerveau

   explorer $env:USERPROFILE\MonCerveau

   À retenir — 00-Inbox est la boîte d'arrivée : toute idée y atterrit d'abord, le tri vient après. Sans Inbox, on ne note plus — et le cerveau meurt en une semaine.

3. 9.3 — Les 4 règles de classement

   Chaque dossier répond à une question. Le classement doit prendre moins de 10 secondes, sinon vous ne le ferez pas.

   01-Projets — : effort avec un résultat et une échéance

   # Ex. « Landing page Compas — en ligne avant janvier ». Fini → tout bouge vers Archives.

   02-Domaines — : responsabilité continue, sans fin

   # Ex. « Trésorerie de l'entreprise », « Ma santé », « Ce site » — jamais « terminé ».

   03-Ressources — : sujets qui vous intéressent

   # Ex. « Momentum », « IA locale », « Notion » — des notes à consulter, pas des obligations.

   04-Archives — : tout ce qui n'est plus actif

   # Projets terminés, domaines abandonnés, ressources devenues inutiles. Rien ne se perd.

   À retenir — En cas de doute : c'est un projet ? Non → c'est un domaine. Ni l'un ni l'autre → ressource.

4. 9.4 — Écrire les notes — format utile pour l'IA

   Une note = une idée, un titre clair, quelques lignes. Le format importe moins que la fidélité : mieux vaut une note imparfaite saisie le jour même qu'une note parfaite jamais écrite. Un fichier Markdown par note : votre IA les lit nativement.

   Gabarit d'une note (Markdown)

   # Titre de la note
   Date : 2026-10-17
   Contexte : pourquoi cette note existe (1 phrase)
   Contenu : l'idée, en quelques lignes utiles
   Suite : prochaine action éventuelle

   Toute idée passe par l'Inbox d'abord

   # Capturer > classer. On trie une fois par semaine (ex. le vendredi), jamais dans l'urgence.

5. 9.5 — Brancher le cerveau sur votre assistant

   Ouvrez OpenCode directement dans le dossier MonCerveau : il peut alors lire, chercher et croiser vos notes dans chaque réponse. C'est ici que le cerveau numérique devient un avantage concurrentiel — personne d'autre n'a votre contexte, et personne d'autre ne peut l'avoir, puisqu'il ne quitte jamais votre machine.

   Lancer OpenCode depuis le cerveau

   cd $env:USERPROFILE\MonCerveau; opencode

   Demandes types à essayer

   « Lis mes notes de projets et dis-moi ce qui avance le moins en ce moment. »
   « À partir de mes notes Domaines, écris le bilan mensuel de [projet]. »
   « Trouve dans Ressources tout ce que j'ai noté sur [sujet] et résume. »

   À retenir — Rituel minimal : 10 minutes par semaine pour vider l'Inbox et archiver ce qui est fini. C'est tout ce que le cerveau réclame.