Rafiq IA Lab

IA-15 — IA locale avec LM Studio, Ollama et modèles open source

---

1. Titre du module

IA-15 — IA locale avec LM Studio, Ollama et modèles open source

Partie 4 — IA professionnelle, cybersécurité, infrastructure et IA locale (module d'ouverture)

---

2. Objectif pédagogique

À la fin de ce module, l'apprenant doit être capable de :

• définir l'IA locale et la distinguer de l'IA cloud ;
• présenter simplement LM Studio et Ollama ;
• comprendre la notion de modèle open source (poids ouverts) ;
• expliquer simplement la quantization ;
• situer les principaux modèles locaux : Gemma, LLaMA, Mistral, Qwen, Phi ;
• citer les avantages (confidentialité, apprentissage, hors ligne, contrôle, personnalisation) et les limites (matériel, RAM, CPU/GPU, lenteur, qualité variable, contexte limité) ;
• identifier des cas d'usage réalistes pour un profil IT ;
• appliquer les précautions : un modèle local n'est pas forcément fiable, vérifier, choisir un modèle adapté à sa machine.

Prérequis : IA-04 (LLM), IA-09 (vérification) et IA-17 (confidentialité, abordée ici comme principal avantage de l'IA locale).

---

3. Niveau

Professionnel (reste accessible à un intermédiaire motivé).

Premier module de la Partie 4, orientée usages en entreprise. Installer LM Studio ou Ollama est accessible ; le raisonnement (cloud vs local, confidentialité, matériel) est de niveau professionnel.

---

4. Durée estimée

---

5. Résumé clair et simple

Jusqu'ici, les assistants IA utilisés étaient dans le cloud : vos données partent sur les serveurs d'un éditeur, qui exécute le modèle et vous renvoie la réponse. L'IA locale, c'est l'inverse : le modèle s'exécute sur votre propre machine (ou un serveur de votre entreprise). Vos données ne quittent pas votre environnement.

Deux outils rendent cela simple. Ollama permet de télécharger et d'exécuter des modèles en ligne de commande (et de les exposer via une petite API locale). LM Studio est une application de bureau avec interface graphique pour faire la même chose, plus visuellement. Tous deux s'appuient sur des modèles open source (à « poids ouverts ») comme Gemma, LLaMA, Mistral, Qwen, Phi, qu'on peut télécharger et faire tourner soi-même.

Pour tenir sur une machine ordinaire, ces modèles sont souvent quantizés : on réduit la précision de leurs calculs pour qu'ils occupent moins de mémoire et tournent plus vite, au prix d'une légère baisse de qualité. C'est ce qui permet de faire fonctionner un modèle « léger » sur un bon PC, sans data center.

L'IA locale a des avantages majeurs pour un professionnel IT : confidentialité (les données restent chez vous — précieux pour le RGPD, IA-17), fonctionnement hors ligne, contrôle, apprentissage et personnalisation. Mais aussi des limites réelles : il faut du matériel (RAM, CPU/GPU), c'est souvent plus lent, la qualité varie selon le modèle, et le contexte est parfois plus limité. Surtout, une règle ne change pas : un modèle local n'est pas plus « vrai » qu'un modèle cloud. Il peut halluciner tout autant. On vérifie toujours (IA-09).

---

6. Compétences visées

À l'issue de ce module, l'apprenant saura :

• expliquer la différence cloud / local et ses implications de confidentialité ;
• décrire le rôle de LM Studio et d'Ollama ;
• expliquer ce qu'est un modèle open source et la quantization ;
• situer les principaux modèles locaux et leurs ordres de grandeur ;
• peser avantages et limites de l'IA locale pour un usage IT ;
• choisir un modèle adapté à sa machine et à son besoin ;
• garder le réflexe de vérification, quel que soit le modèle.

---

7. Notions clés à comprendre

• IA locale : exécution d'un modèle sur sa propre machine/serveur ; les données ne sortent pas.
• IA cloud : exécution sur les serveurs d'un éditeur ; les données y transitent.
• Ollama : outil (ligne de commande + serveur local) pour télécharger et exécuter des modèles locaux.
• LM Studio : application de bureau avec interface graphique pour exécuter des modèles locaux.
• Modèle open source / à poids ouverts : modèle dont les paramètres sont publiquement disponibles, téléchargeable et exécutable soi-même.
• Quantization : réduction de la précision numérique d'un modèle pour réduire sa taille et accélérer son exécution, au prix d'une légère perte de qualité.
• Paramètres (en milliards / B) : ordre de grandeur de la « taille » d'un modèle (ex. 3B, 7B, 8B…) ; plus c'est grand, plus il faut de mémoire.
• VRAM / RAM : mémoire (de la carte graphique / du système) nécessaire pour charger un modèle.
• Contexte : quantité de texte que le modèle prend en compte (rappel IA-04), souvent plus limité en local.

---

8. Cours complet structuré

8.1 — Qu'est-ce que l'IA locale ?

L'IA locale consiste à exécuter un modèle d'IA sur votre propre matériel : votre PC, un serveur de votre entreprise. À l'inverse de l'IA cloud (ChatGPT, Claude, Gemini…), où le modèle tourne chez l'éditeur, ici rien ne sort de votre environnement.

C'est un changement de logique important pour un professionnel : avec l'IA locale, la question « où vont mes données ? » trouve une réponse simple — elles restent chez moi.

8.2 — Cloud vs local : la comparaison

Il n'y a pas de « meilleur » dans l'absolu : cela dépend du besoin, de la sensibilité des données et du matériel disponible. Le choix cloud / local / privé est approfondi côté gouvernance en IA-18.

8.3 — Ollama, présentation simple

Ollama est un outil qui permet de télécharger et exécuter des modèles localement, principalement en ligne de commande. On « tire » un modèle (par exemple un modèle léger), puis on dialogue avec lui dans le terminal. Ollama peut aussi exposer une petite API locale, ce qui permet de connecter le modèle à d'autres outils (par exemple un workflow n8n local — IA-13 — ou un script).

Points forts : simple, scriptable, intégrable. C'est souvent le choix des profils techniques.

8.4 — LM Studio, présentation simple

LM Studio est une application de bureau avec interface graphique. Elle permet de chercher, télécharger et exécuter des modèles locaux sans ligne de commande, de discuter avec eux dans une fenêtre de chat, et de gérer facilement plusieurs modèles. Elle peut aussi proposer un serveur local compatible avec une API.

Points forts : visuel, accessible, pratique pour découvrir et tester des modèles.

Ollama et LM Studio répondent au même besoin (exécuter de l'IA en local) ; le premier est plutôt terminal, le second plutôt interface graphique. Beaucoup de professionnels utilisent l'un, l'autre, ou les deux.

8.5 — Modèles open source (à poids ouverts)

Un modèle open source / à poids ouverts est un modèle dont les paramètres (les « poids » appris, rappel IA-03) sont publiquement disponibles. On peut le télécharger et l'exécuter soi-même, gratuitement, sans dépendre d'un service.

Principaux exemples cités dans ce parcours :

• Gemma (Google) ;
• LLaMA (Meta) ;
• Mistral (Mistral AI) ;
• Qwen (Alibaba) ;
• Phi (Microsoft).

Ces familles existent en plusieurs tailles (souvent exprimées en milliards de paramètres : 3B, 7B, 8B…). Les petits tournent sur un bon PC ; les gros demandent du matériel costaud. Le paysage évolue vite : pour les versions et performances à jour, consultez les sources officielles.

8.6 — La quantization, expliquée simplement

Un modèle stocke ses paramètres sous forme de nombres. Par défaut, ces nombres sont très précis (donc volumineux). La quantization consiste à les stocker avec moins de précision (par exemple en « 4 bits » au lieu de la précision d'origine).

Résultat :

• le modèle occupe beaucoup moins de mémoire ;
• il s'exécute plus vite ;
• en contrepartie, une légère perte de qualité est possible.

Analogie. C'est comme une photo : la version haute définition est fidèle mais lourde ; une version compressée est plus légère et s'ouvre plus vite, avec une petite perte de détail. La quantization, c'est « compresser » le modèle pour le faire tenir sur votre machine.

C'est grâce à la quantization qu'un modèle « léger » peut tourner sur un ordinateur ordinaire.

8.7 — Avantages de l'IA locale

• Confidentialité : les données ne quittent pas votre environnement — atout majeur pour le RGPD et les données sensibles (IA-17).
• Hors ligne : fonctionne sans Internet (terrain, site isolé, réseau coupé).
• Contrôle : vous maîtrisez le modèle, les versions, l'usage.
• Apprentissage : idéal pour comprendre comment fonctionne un LLM, expérimenter sans coût par requête.
• Personnalisation : possibilité d'adapter (prompts système, voire fine-tuning — IA-05) à votre contexte.
• Coût : pas de facturation par requête (mais un coût matériel et électrique).

8.8 — Limites de l'IA locale

• Besoin matériel : RAM suffisante, idéalement un GPU avec de la VRAM pour les modèles plus gros.
• Lenteur : sur CPU ou matériel modeste, les réponses peuvent être lentes.
• Qualité variable : un petit modèle local est généralement moins performant qu'un grand modèle cloud.
• Contexte limité : la fenêtre de contexte (IA-04) est souvent plus petite en local.
• Maintenance : mises à jour, choix des modèles, configuration à votre charge.
• Pas d'accès web par défaut : pas de faits récents sans intégration supplémentaire.

Choisir un modèle, c'est arbitrer entre taille (qualité) et ressources disponibles. Un modèle trop gros pour votre machine sera inutilisable (trop lent) ou ne se chargera pas.

8.9 — Cas d'usage réalistes pour un profil IT

L'IA locale brille là où la confidentialité et le hors ligne comptent :

• assistant local de documentation : interroger une base interne sans rien envoyer dehors ;
• aide aux commandes Linux : se faire expliquer/proposer des commandes hors ligne (à vérifier, IA-09) ;
• résumé de notes internes (sans cloud) ;
• génération de procédures à partir de notes sensibles ;
• analyse de logs non sensibles ou de tests en environnement isolé ;
• expérimentation / apprentissage sur le fonctionnement des LLM.

Pour des données réellement sensibles, l'IA locale est souvent plus adaptée que le cloud — à condition de garder le réflexe de vérification.

8.10 — Précautions essentielles

• « Local » ≠ « fiable ». Un modèle local hallucine aussi (IA-04). Il est souvent moins performant qu'un grand modèle cloud : la vigilance doit être au moins aussi forte.
• Vérifier les réponses comme toujours (IA-09), surtout les commandes.
• Choisir un modèle adapté à sa machine (taille vs RAM/GPU) et à son besoin.
• Comprendre les limites matérielles : tester avec un petit modèle d'abord, augmenter ensuite.
• Sécuriser le poste/serveur qui héberge le modèle (c'est de l'infrastructure — IA-16).

---

9. Exemples concrets liés au monde IT

1. Assistant doc hors ligne. Sur un site sans Internet, un modèle local répond aux questions des techniciens à partir de notes internes — aucune donnée ne sort.
2. Aide commandes Linux confidentielle. Un admin se fait proposer des commandes en local, sans exposer la configuration de l'entreprise (à vérifier avec man, IA-09).
3. Résumé de notes sensibles. Des comptes rendus internes sont résumés localement, sans passer par un service cloud (RGPD, IA-17).
4. Génération de procédures. À partir de notes confidentielles, le modèle local produit un brouillon de procédure (à vérifier — IA-12).
5. Analyse de logs en lab. Des logs de test (non sensibles) sont analysés localement pour s'entraîner, sans risque de fuite.
6. Banc d'essai / apprentissage. Tester Ollama et LM Studio avec différents modèles (Gemma, Mistral, Phi…) pour comprendre l'impact de la taille et de la quantization.
7. Petit assistant intégré. Via l'API locale d'Ollama, brancher un modèle sur un script ou un workflow local (IA-13) — toujours avec contrôle humain.

Constante : l'IA locale protège les données, mais ne dispense pas de vérifier les réponses.

---

10. Cas pratique guidé

Objectif : choisir et tester un modèle local adapté à sa machine, et comprendre les compromis.

Contexte. Vous voulez un assistant local pour résumer des notes internes sans rien envoyer dans le cloud, sur un PC de bureau correct (sans GPU dédié puissant).

Étape 1 — Définir le besoin et la contrainte. Besoin : résumer du texte en français, en local. Contrainte : matériel modeste (CPU + RAM, peu ou pas de VRAM). → Il faut un petit modèle quantizé.

Étape 2 — Choisir l'outil. Pour découvrir visuellement : LM Studio (interface graphique). Pour intégrer/scripter : Ollama (ligne de commande + API locale). Choisissez selon votre aisance.

Étape 3 — Choisir un modèle adapté. Optez pour un petit modèle (faible nombre de paramètres) en version quantizée, qui tient en RAM. Évitez d'emblée un gros modèle : il serait trop lent ou ne se chargerait pas. (Vérifiez les tailles disponibles dans l'outil.)

Étape 4 — Tester sur un cas réel non sensible. Donnez-lui un texte de test à résumer. Évaluez : la qualité du résumé, la vitesse, et la fidélité (n'a-t-il rien inventé ?). Comparez éventuellement avec un modèle un cran plus grand pour mesurer la différence qualité/vitesse.

Étape 5 — Vérifier et décider. Comme pour le cloud, relisez le résumé (le modèle local peut déformer ou omettre — IA-09). Décidez si la qualité suffit pour votre usage. Si oui, vous avez un assistant confidentiel et hors ligne ; sinon, ajustez le modèle ou le besoin.

Résultat du cas pratique : vous savez choisir un modèle selon votre matériel, mesurer le compromis qualité/vitesse, et garder la vérification — sans exposer vos données.

---

11. Exercice pratique à faire seul

Consigne. Préparez un plan de mise en place d'un assistant IA local pour un besoin de votre choix (résumé de notes, aide commandes, doc interne). Décrivez :

1. le besoin et la raison de choisir le local (ex. confidentialité, hors ligne) ;
2. l'outil retenu (Ollama ou LM Studio) et pourquoi ;
3. la contrainte matérielle de votre machine (RAM, GPU/CPU) ;
4. le type de modèle adapté (petit/moyen, quantizé) et pourquoi ;
5. 2 avantages et 2 limites attendus dans votre cas ;
6. votre méthode de vérification des réponses (IA-09) ;
7. une précaution (le local n'est pas forcément fiable / sécuriser le poste).

Contexte. Vous raisonnez comme un professionnel qui choisit la bonne solution selon données, matériel et besoin.

Résultat attendu. Un plan clair de mise en place d'un assistant local.

Critères de réussite :

• le choix du local est justifié (confidentialité/hors ligne) ;
• l'outil et le modèle sont cohérents avec le matériel ;
• avantages et limites sont réalistes ;
• la vérification des réponses est prévue ;
• une précaution est explicite.

---

12. Quiz de 10 questions QCM

Une seule bonne réponse par question.

Q1. Qu'est-ce que l'IA locale ?

• A. Une IA qui tourne sur les serveurs de l'éditeur
• B. Une IA qui s'exécute sur votre propre machine/serveur
• C. Une IA réservée aux jeux vidéo
• D. Une IA sans modèle

Q2. Quel est le principal avantage de l'IA locale ?

• A. Elle est toujours plus performante que le cloud
• B. La confidentialité : les données ne quittent pas votre environnement
• C. Elle n'a besoin d'aucun matériel
• D. Elle accède toujours au web

Q3. Ollama est principalement :

• A. Une application de bureau graphique
• B. Un outil en ligne de commande (et serveur local) pour exécuter des modèles
• C. Un modèle de langage
• D. Un antivirus

Q4. LM Studio est principalement :

• A. Une application de bureau avec interface graphique pour exécuter des modèles locaux
• B. Un langage de programmation
• C. Un service cloud uniquement
• D. Un type de GPU

Q5. Qu'est-ce qu'un modèle open source (à poids ouverts) ?

• A. Un modèle dont les paramètres sont publiquement disponibles et exécutables soi-même
• B. Un modèle qu'on ne peut jamais télécharger
• C. Un modèle réservé au cloud
• D. Un modèle sans paramètres

Q6. La quantization permet surtout de :

• A. Augmenter la précision et la taille du modèle
• B. Réduire la taille et accélérer le modèle, au prix d'une légère perte de qualité
• C. Connecter le modèle à Internet
• D. Supprimer les hallucinations

Q7. Lequel est une famille de modèles locaux open source ?

• A. Apache
• B. Gemma, LLaMA, Mistral, Qwen, Phi
• C. Windows
• D. Docker

Q8. Quelle est une limite typique de l'IA locale ?

• A. Aucune limite
• B. Besoin de matériel (RAM, CPU/GPU), lenteur possible, qualité variable
• C. Trop de confidentialité
• D. Accès web automatique

Q9. Un modèle local est-il forcément fiable ?

• A. Oui, car il est local
• B. Non : il peut halluciner aussi, et est souvent moins performant qu'un grand modèle cloud
• C. Oui, s'il est gros
• D. Oui, s'il est quantizé

Q10. Comment choisir un modèle local ?

• A. Le plus gros possible, quelle que soit la machine
• B. Un modèle adapté à son matériel (taille vs RAM/GPU) et à son besoin
• C. Au hasard
• D. Toujours le plus petit, sans tenir compte du besoin

---

13. Réponses corrigées du quiz avec explications

Q1 → B. L'IA locale s'exécute sur votre propre matériel. A décrit le cloud, C et D sont faux.

Q2 → B. L'atout majeur est la confidentialité. A est faux (le cloud est souvent plus puissant), C et D sont faux.

Q3 → B. Ollama est surtout un outil en ligne de commande (avec serveur local). A décrit LM Studio, C et D sont faux.

Q4 → A. LM Studio est une application de bureau graphique. Les autres réponses sont fausses.

Q5 → A. Un modèle à poids ouverts a ses paramètres publics et exécutables soi-même. B, C et D sont faux.

Q6 → B. La quantization réduit la taille et accélère, avec une légère perte de qualité. A est l'inverse, C et D sont faux.

Q7 → B. Gemma, LLaMA, Mistral, Qwen, Phi sont des familles de modèles. A est un serveur web, C un OS, D un outil de conteneurs.

Q8 → B. L'IA locale demande du matériel, peut être lente et de qualité variable. A, C et D sont faux.

Q9 → B. Un modèle local hallucine aussi et est souvent moins performant : vigilance au moins aussi forte. A, C et D sont faux.

Q10 → B. On choisit un modèle adapté au matériel et au besoin. A le rendrait inutilisable, C et D ignorent le besoin.

Barème indicatif : 8/10 ou plus = notions acquises. 5 à 7 = relisez les sections 8.2, 8.6 et 8.8. Moins de 5 = reprenez le cours et rejouez le cas pratique.

---

14. Flashcards de révision

Carte 1 Q : Qu'est-ce que l'IA locale ? R : Un modèle exécuté sur votre propre machine/serveur ; les données ne sortent pas.

Carte 2 Q : Différence clé cloud / local ? R : Cloud : données chez l'éditeur, grande puissance. Local : données chez vous, confidentialité forte.

Carte 3 Q : Qu'est-ce qu'Ollama ? R : Un outil (CLI + serveur local) pour télécharger et exécuter des modèles locaux.

Carte 4 Q : Qu'est-ce que LM Studio ? R : Une application de bureau graphique pour exécuter des modèles locaux.

Carte 5 Q : Modèle open source (poids ouverts) ? R : Modèle aux paramètres publics, téléchargeable et exécutable soi-même.

Carte 6 Q : Qu'est-ce que la quantization ? R : Réduire la précision d'un modèle pour le rendre plus léger et rapide, avec une légère perte de qualité.

Carte 7 Q : Cite cinq familles de modèles locaux. R : Gemma, LLaMA, Mistral, Qwen, Phi.

Carte 8 Q : Principal avantage de l'IA locale ? R : La confidentialité (données qui restent chez vous), utile pour le RGPD.

Carte 9 Q : Trois limites de l'IA locale ? R : Besoin de matériel, lenteur possible, qualité variable (et contexte souvent limité).

Carte 10 Q : Un modèle local est-il plus fiable qu'un modèle cloud ? R : Non : il hallucine aussi et est souvent moins performant ; on vérifie autant.

Carte 11 Q : Comment choisir un modèle local ? R : Adapté à son matériel (taille vs RAM/GPU) et à son besoin.

Carte 12 Q : Pourquoi commencer par un petit modèle quantizé ? R : Pour qu'il tienne sur la machine et reste réactif, avant d'essayer plus gros.

---

15. Erreurs fréquentes

• Croire qu'un modèle local est forcément fiable : il hallucine aussi.
• Choisir un modèle trop gros pour sa machine → inutilisable ou ne se charge pas.
• Oublier que la qualité est souvent inférieure à un grand modèle cloud.
• Ne pas vérifier les réponses (surtout les commandes).
• Penser que « local » dispense de sécuriser le poste/serveur.
• Confondre Ollama et LM Studio (CLI vs interface graphique).
• Attendre un accès web par défaut (il n'y en a pas).
• Négliger les limites matérielles (RAM, VRAM) avant de télécharger un modèle.

---

16. Bonnes pratiques

• Choisir local quand la confidentialité ou le hors ligne priment (données sensibles, site isolé).
• Sélectionner un modèle adapté à son matériel (taille/quantization) et à son besoin.
• Commencer petit, mesurer qualité/vitesse, puis ajuster.
• Vérifier les réponses comme pour le cloud (IA-09).
• Sécuriser le poste/serveur hôte (IA-16).
• Tester sur des cas réels (non sensibles d'abord) pour évaluer la qualité.
• Documenter le choix (outil, modèle, matériel, limites) — IA-12.
• Arbitrer cloud / local / privé selon les enjeux (gouvernance, IA-18).

---

17. Point vigilance : limites, risques, sécurité et vérification humaine

Bloc obligatoire à lire attentivement.

Ce qu'il faut vérifier :

• l'exactitude des réponses (un modèle local hallucine aussi — IA-04, IA-09) ;
• l'adéquation du modèle à votre matériel (taille vs RAM/GPU) ;
• la qualité réelle sur vos cas (tester avant d'adopter).

Ce qu'il ne faut pas faire :

• considérer « local » comme synonyme de « fiable » ou de « sans risque » ;
• négliger la sécurité du poste/serveur hébergeant le modèle ;
• supposer un accès web ou des faits récents sans intégration dédiée.

Risques de mauvaise utilisation :

• confiance excessive dans un petit modèle moins performant ;
• application d'une commande hallucinée ;
• machine hôte mal sécurisée devenant un point faible (IA-16).

Risques de confidentialité :

• l'IA locale réduit fortement le risque de fuite (données qui restent chez vous), mais ne dispense pas de sécuriser le stockage et les accès ;
• RGPD et données sensibles : module IA-17 ; choix cloud/local/privé : IA-18.

Limites de l'IA locale :

• qualité souvent inférieure aux grands modèles cloud ;
• besoin de matériel, lenteur possible, contexte limité ;
• maintenance à votre charge.

Cas où une validation humaine est indispensable :

• toute commande/procédure issue d'un modèle local destinée à un usage réel ;
• toute décision sensible ;
• toute mise en service du modèle dans un processus de l'entreprise.

Principe à retenir : l'IA locale offre confidentialité et contrôle, mais la même rigueur de vérification s'applique. Un modèle local n'est pas « plus vrai » qu'un modèle cloud.

---

18. Mini-projet de fin de module

Titre : « Mon assistant IA local confidentiel »

Objectif. Mettre en place (ou planifier en détail) un assistant IA local pour un usage IT confidentiel, en choisissant l'outil et le modèle adaptés à votre matériel.

Contexte. Vous visez un usage où la confidentialité compte (résumé de notes internes, aide commandes hors ligne). Si vous avez une machine adaptée, faites-le réellement ; sinon, produisez un plan détaillé.

Prérequis. Avoir lu le cours (section 8) ; notions de confidentialité (IA-17) et de vérification (IA-09).

Étapes :

1. Définir le besoin et justifier le choix du local (confidentialité, hors ligne).
2. Choisir l'outil (Ollama ou LM Studio) selon votre aisance et votre usage.
3. Évaluer votre matériel (RAM, GPU/CPU) et choisir un modèle adapté (petit/moyen, quantizé).
4. Tester sur 3 cas réels non sensibles : mesurer qualité, vitesse, fidélité.
5. Définir une méthode de vérification des réponses (IA-09).
6. Lister avantages et limites constatés, et une précaution de sécurité du poste (IA-16).
7. Documenter l'ensemble (outil, modèle, matériel, résultats) — IA-12.

Résultat attendu. Un assistant local en place (ou un plan complet), testé et documenté.

Critères de réussite :

• choix du local justifié ;
• outil et modèle cohérents avec le matériel ;
• tests réalisés sur des cas non sensibles ;
• méthode de vérification définie ;
• avantages, limites et précaution de sécurité explicités ;
• documentation claire.

Amélioration possible. Exposez le modèle via l'API locale (Ollama) et reliez-le à un petit workflow local (IA-13) ou à un assistant documentaire (préparation à IA-19/IA-20), toujours avec contrôle humain.

---

19. Ressources gratuites recommandées

Ne recommander que des ressources gratuites ou accessibles gratuitement. Toute ressource dont la gratuité ou la disponibilité n'est pas certaine est signalée par la mention « À vérifier avant publication. »

• Site et documentation d'Ollama — ollama.com — outil gratuit et open source pour exécuter des modèles locaux. À vérifier avant publication (vérifier le lien et les modèles disponibles).
• Site et documentation de LM Studio — lmstudio.ai — application de bureau gratuite pour exécuter des modèles locaux. À vérifier avant publication (conditions et fonctionnalités évoluent).
• Pages officielles des familles de modèles (Gemma, LLaMA, Mistral, Qwen, Phi) — pour connaître tailles, licences et conditions d'usage. À vérifier avant publication (licences et versions changent ; vérifier les conditions d'utilisation).
• « Elements of AI » (version française) — course.elementsofai.com/fr/ — pour consolider les notions de modèles et de paramètres. (Gratuit, vérifié.)
• Matériel de test : un PC correct (idéalement avec un peu de VRAM) suffit pour découvrir des petits modèles quantizés. (Pas de coût logiciel ; coût matériel/électrique à votre charge.)

Remarque : vérifiez toujours la licence d'un modèle avant un usage professionnel. Ce module ne promet aucune certification.

---

20. Résumé final du module

• L'IA locale exécute un modèle sur votre propre matériel : les données ne sortent pas (contrairement à l'IA cloud).
• Ollama (ligne de commande + serveur local) et LM Studio (interface graphique) permettent de télécharger et exécuter des modèles open source : Gemma, LLaMA, Mistral, Qwen, Phi.
• La quantization « compresse » un modèle pour le rendre plus léger et rapide, au prix d'une légère perte de qualité — c'est ce qui le fait tenir sur une machine ordinaire.
• Avantages : confidentialité, hors ligne, contrôle, apprentissage, personnalisation, pas de coût par requête.
• Limites : besoin de matériel (RAM, CPU/GPU), lenteur possible, qualité variable, contexte souvent limité, maintenance à votre charge.
• Précaution centrale : un modèle local n'est pas plus fiable qu'un modèle cloud — il hallucine aussi et est souvent moins performant. On vérifie autant (IA-09), on choisit un modèle adapté à sa machine, et on sécurise le poste hôte (IA-16).
• Confidentialité : IA-17 ; arbitrage cloud/local/privé : IA-18.

---

21. Validation demandée avant le module suivant

Validation demandée avant le module suivant

Souhaites-tu que je passe au module suivant ou que je corrige/améliore ce module d'abord ?

(Module suivant prévu : IA-16 — IA dans l'infrastructure IT et la cybersécurité défensive.)