Intelligence artificielle · Chapitre 36 · Cours 14

Cas pratique : installer et exploiter son assistant IA local

Vous allez réaliser un projet complet : préparer un ordinateur, choisir un modèle, installer un moteur d’inférence, dialoguer avec une IA, tester une API locale, mesurer les performances et vérifier la sécurité. À la fin, vous disposerez d’un assistant opérationnel et d’une méthode pour le maintenir.

À la fin de ce cours, vous saurez :

  • Définir le besoin d’un assistant IA local.
  • Vérifier la compatibilité matérielle d’un ordinateur.
  • Choisir un modèle adapté à la mémoire disponible.
  • Installer et lancer un modèle avec Ollama.
  • Utiliser LM Studio comme alternative graphique.
  • Rédiger des instructions et tester les réponses.
  • Accéder au modèle par une API locale.
  • Mesurer les temps de réponse et l’utilisation des ressources.
  • Vérifier les paramètres de confidentialité et de sécurité.
  • Diagnostiquer les incidents les plus courants.
  • Documenter une installation et évaluer son fonctionnement.
Prérequis et matériel

Ce cas pratique mobilise les connaissances acquises dans les treize cours précédents. Il nécessite un ordinateur Windows, macOS ou Linux, une connexion Internet pour les téléchargements initiaux, de l’espace disque disponible et les droits nécessaires à l’installation des logiciels. Les tests utilisent exclusivement des données fictives.

1. Présentation du projet

Vous êtes chargé de mettre en place un assistant IA local pour une petite structure qui souhaite expérimenter l’intelligence artificielle sans transmettre systématiquement ses demandes à un fournisseur de modèle distant.

L’assistant doit pouvoir :

  • Répondre à des questions en français.
  • Résumer un texte fourni par l’utilisateur.
  • Produire des listes et des tableaux simples.
  • Reformuler des messages professionnels.
  • Être utilisé sur un ordinateur personnel.
  • Fonctionner sans Internet après installation, pour les tâches compatibles.
  • Rester accessible uniquement depuis la machine utilisée.
Résultat attendu

Un modèle local fonctionnel, une interface de conversation utilisable, un test d’API réussi, une fiche de performance, un contrôle de sécurité et un compte rendu final.

2. Définir le cahier des charges

Avant d’installer un logiciel, il faut préciser les contraintes du projet.

CritèreExigenceVérification
Coût Utiliser une solution accessible gratuitement pour l’atelier. Aucun abonnement nécessaire pour les fonctions testées.
Langue Répondre en français. Test de conversation.
Autonomie Réaliser une inférence hors ligne. Test sans connexion Internet.
Confidentialité Éviter les transmissions non nécessaires. Vérification des fonctions réseau et de synchronisation.
Performances Répondre dans un délai acceptable. Mesure chronométrée.
Stabilité Ne pas provoquer de saturation durable. Surveillance RAM et CPU/GPU.
Sécurité Limiter les accès au service. Vérification de l’adresse d’écoute.

3. Choisir son parcours d’installation

Deux parcours sont proposés. Il n’est pas nécessaire d’installer les deux logiciels pour réussir l’atelier.

Parcours A — Ollama

Pour découvrir les commandes, les modèles et l’utilisation d’une API locale.

Parcours B — LM Studio

Pour privilégier une interface graphique et une utilisation par conversation.

Conseil pédagogique

Le parcours Ollama est utilisé pour les commandes et les exemples d’API de ce cours. Les utilisateurs de LM Studio peuvent réaliser les mêmes objectifs fonctionnels en adaptant les étapes à l’interface et au serveur local de leur version.

4. Étape 1 — Relever la configuration de l’ordinateur

Avant de télécharger un modèle, identifier les principales caractéristiques du matériel.

4.1. Sous Windows

Ouvrir le Gestionnaire des tâches, puis l’onglet Performances.

Relever :

  • Le processeur.
  • La mémoire RAM totale.
  • La présence éventuelle d’un GPU.
  • La mémoire GPU disponible, lorsqu’elle est indiquée.
  • L’espace disque libre.

Il est également possible d’utiliser PowerShell pour afficher la mémoire physique totale :

Get-CimInstance Win32_ComputerSystem | Select-Object TotalPhysicalMemory

La valeur affichée est exprimée en octets.

4.2. Sous Linux

free -h lscpu df -h

Ces commandes affichent respectivement la mémoire, les caractéristiques du processeur et l’utilisation des systèmes de fichiers.

4.3. Sous macOS

Consulter les informations système et le Moniteur d’activité pour identifier la mémoire, le processeur et l’utilisation des ressources.

4.4. Fiche de configuration

SYSTÈME : PROCESSEUR : RAM TOTALE : GPU : VRAM OU MÉMOIRE UNIFIÉE : ESPACE DISQUE LIBRE : LOGICIEL CHOISI :
Attention

La mémoire totale n’est pas intégralement disponible pour le modèle. Le système d’exploitation et les autres applications en utilisent déjà une partie.

5. Étape 2 — Choisir un modèle adapté

Pour cet atelier, un petit modèle conversationnel est préférable : il permet de vérifier rapidement le fonctionnement de l’installation.

Un exemple de modèle utilisable avec Ollama est :

gemma3:1b

Il s’agit d’un modèle compact adapté à une première expérimentation. Sa qualité reste limitée pour les tâches complexes.

5.1. Repères matériels indicatifs

RAM disponible sur l’ordinateurOrientation de départPrécaution
8 Go Tester un petit modèle quantifié, autour de 1 à 3 milliards de paramètres. Réduire le contexte et fermer les applications inutiles.
16 Go Tester un modèle compact puis éventuellement un modèle intermédiaire quantifié. Surveiller la consommation mémoire.
32 Go ou plus Envisager des modèles plus volumineux selon le matériel. Tenir compte du GPU, de la quantification et du contexte.

Ces indications ne sont pas des seuils garantis : les besoins réels varient selon l’architecture, la quantification, le moteur d’inférence et la taille du contexte.

6. Étape 3A — Installer Ollama

Si vous avez choisi le parcours A, télécharger Ollama depuis son site officiel :

https://ollama.com/download

Choisir la version correspondant au système d’exploitation et suivre la procédure officielle.

6.1. Vérifier l’installation

Ouvrir un terminal ou PowerShell :

ollama –version

Si Ollama est correctement installé et accessible depuis le terminal, la commande affiche des informations de version.

6.2. Télécharger et lancer le modèle

ollama run gemma3:1b

Lors du premier lancement, Ollama télécharge le modèle si celui-ci n’est pas déjà présent.

Une fois chargé, une interface de saisie apparaît dans le terminal.

6.3. Première question

Bonjour. Présente-toi en trois phrases simples et réponds uniquement en français.

Observer si le modèle répond correctement et si le temps de génération est acceptable.

6.4. Quitter la conversation

/bye

6.5. Vérifier les modèles téléchargés

ollama list

Le modèle installé doit apparaître dans la liste.

7. Étape 3B — Installer LM Studio

Si vous avez choisi le parcours B, télécharger LM Studio depuis son site officiel :

https://lmstudio.ai/

7.1. Installer l’application

Suivre les étapes correspondant à votre système.

7.2. Rechercher un modèle

Utiliser le catalogue ou la fonction de recherche de modèles.

Rechercher un petit modèle conversationnel compatible avec votre matériel.

7.3. Vérifier la variante

Lorsque plusieurs quantifications sont proposées, choisir une variante compatible avec la mémoire disponible.

7.4. Télécharger

Attendre la fin du téléchargement avant de poursuivre.

7.5. Charger le modèle

Dans l’interface de conversation, sélectionner le modèle téléchargé et le charger.

7.6. Premier échange

Bonjour. Explique en quatre phrases ce qu’est une intelligence artificielle locale, pour un débutant.

Vérifier que le modèle produit une réponse compréhensible.

À noter

Les menus de LM Studio peuvent évoluer selon les versions. L’objectif reste le même : télécharger un modèle, le charger en mémoire et l’utiliser dans une conversation locale.

8. Étape 4 — Tester les capacités de l’assistant

Une installation réussie ne suffit pas : il faut vérifier que le modèle répond au besoin défini.

Réaliser les quatre tests suivants.

8.1. Test de compréhension

Explique la différence entre RAM et stockage SSD. Réponds en cinq phrases maximum, avec un exemple concret.

Critères : exactitude générale, clarté et respect du format.

8.2. Test de résumé

Utiliser ce texte fictif :

Une petite entreprise a reçu 120 demandes clients en janvier et 150 en février. Le délai moyen de réponse est passé de 48 heures à 36 heures. L’équipe souhaite poursuivre cette amélioration.

Demander :

Résume ce texte en trois points. N’ajoute aucune information absente du texte.

Critères : fidélité aux données et absence d’invention.

8.3. Test de reformulation

Reformule ce message dans un style professionnel et courtois : « Bonjour, j’ai toujours pas reçu les documents. Merci de me les envoyer rapidement. » Conserve le sens sans ajouter de faits.

Critères : qualité rédactionnelle, politesse et fidélité.

8.4. Test de raisonnement simple

Une entreprise reçoit 120 demandes en janvier et 150 en février. Calcule le taux d’augmentation entre les deux mois. Montre le calcul.

La réponse attendue est :

(150 – 120) / 120 × 100 = 25 %

Une réponse différente doit être examinée et corrigée.

9. Étape 5 — Configurer le comportement de l’assistant

Une instruction initiale permet de préciser le rôle et le style de réponse attendus.

Selon l’interface utilisée, cette instruction peut être placée dans un champ de type system prompt ou dans une configuration de conversation.

9.1. Exemple d’instructions

Tu es un assistant pédagogique local. Règles : 1. Réponds en français. 2. Utilise un vocabulaire accessible. 3. Présente les procédures étape par étape. 4. N’invente pas de faits manquants. 5. Signale tes incertitudes. 6. Ne prétends pas avoir consulté Internet. 7. Demande une précision si elle est indispensable pour répondre.

9.2. Tester les instructions

Explique comment organiser les fichiers d’un ordinateur pour éviter les doublons.

Observer si le modèle suit les consignes de style.

9.3. Comprendre la limite

Une instruction système peut influencer le comportement du modèle, mais elle ne constitue pas une garantie technique de fiabilité ou de sécurité.

10. Étape 6 — Vérifier le fonctionnement hors ligne

Après téléchargement du modèle et chargement des composants nécessaires, réaliser un test sans connexion Internet.

1
Préparer le test

Vérifier que le modèle est entièrement téléchargé et qu’une conversation fonctionne déjà.

2
Couper temporairement la connexion

Désactiver la connexion Internet dans un environnement personnel où cette opération est autorisée et sans conséquence sur d’autres services.

3
Envoyer une question

Demander au modèle d’expliquer une notion simple.

4
Observer le résultat

Vérifier si une réponse est générée sans connexion.

5
Rétablir la connexion

Remettre le réseau dans son état initial.

Limite du test

Un test hors ligne réussi montre que cette fonction peut fonctionner sans Internet. Il ne démontre pas que l’application n’effectue jamais de communications réseau lorsqu’une connexion est disponible.

11. Étape 7 — Découvrir l’API locale d’Ollama

Ollama permet également d’interroger un modèle depuis un programme, à travers une API HTTP locale.

Une adresse courante est :

http://127.0.0.1:11434

11.1. Vérifier les modèles disponibles

Dans PowerShell :

Invoke-RestMethod ` -Uri « http://127.0.0.1:11434/api/tags » ` -Method Get

Si le service fonctionne, la réponse contient des informations sur les modèles installés.

11.2. Envoyer une requête

Utiliser ce script PowerShell :

$body = @{ model = « gemma3:1b » stream = $false messages = @( @{ role = « user » content = « Explique ce qu’est une API en trois phrases. » } ) } | ConvertTo-Json -Depth 5 $result = Invoke-RestMethod ` -Uri « http://127.0.0.1:11434/api/chat » ` -Method Post ` -ContentType « application/json » ` -Body $body $result.message.content

La commande construit une requête JSON, l’envoie au serveur local et affiche le contenu de la réponse.

11.3. Comprendre les paramètres

ÉlémentFonction
modelIndique le modèle à utiliser.
messagesContient les messages de la conversation.
roleIndique le rôle du message.
contentContient le texte du message.
streamContrôle l’envoi progressif de la réponse.

12. Étape 8 — Utiliser l’API de LM Studio

LM Studio peut également exposer un serveur local, selon la version et la configuration.

Une adresse fréquemment utilisée est :

http://127.0.0.1:1234

Il faut d’abord charger un modèle et activer le serveur local dans l’application.

12.1. Vérifier les modèles exposés

Dans PowerShell :

Invoke-RestMethod ` -Uri « http://127.0.0.1:1234/v1/models » ` -Method Get

Si le serveur est actif et que cette route est disponible, la réponse contient les identifiants des modèles accessibles.

12.2. Adapter une requête

Pour une API compatible avec le format Chat Completions, le point d’accès habituel est :

http://127.0.0.1:1234/v1/chat/completions

Il faut utiliser l’identifiant du modèle réellement exposé par le serveur, et non supposer qu’il porte le même nom que dans Ollama.

Important

Les API d’Ollama et de LM Studio ne sont pas identiques dans toutes leurs routes et fonctionnalités. Les exemples doivent être adaptés au serveur utilisé.

13. Étape 9 — Mesurer le temps de réponse

Un assistant local doit être suffisamment réactif pour son usage.

Le temps de réponse dépend notamment :

  • Du modèle.
  • De sa quantification.
  • Du processeur.
  • Du GPU disponible.
  • De la taille du contexte.
  • De la longueur de la réponse.
  • Du chargement initial du modèle.

13.1. Mesurer avec PowerShell

Measure-Command { ollama run gemma3:1b « Explique la RAM en cinq phrases. » }

Cette commande mesure la durée totale de l’opération.

Elle peut inclure le chargement du modèle et d’autres coûts. Elle ne mesure donc pas uniquement la vitesse de génération.

13.2. Comparer plusieurs essais

Réaliser trois tests avec la même question.

EssaiDuréeObservations
1À releverChargement initial éventuel.
2À releverModèle déjà chargé ou non.
3À releverStabilité du résultat.

14. Étape 10 — Comprendre les tokens par seconde

La vitesse de génération est souvent exprimée en tokens par seconde.

Un token est une unité de traitement du texte. Il ne correspond pas nécessairement à un mot entier.

14.1. Formule

Tokens par seconde = Nombre de tokens générés ÷ Durée de génération en secondes

14.2. Exemple

Un modèle génère 240 tokens en 20 secondes.

240 ÷ 20 = 12 tokens/seconde

Sa vitesse moyenne sur cet exemple est de 12 tokens par seconde.

14.3. Mesure avec Ollama

Les réponses de certaines routes de l’API Ollama peuvent fournir notamment :

  • eval_count : nombre de tokens générés.
  • eval_duration : durée de génération, exprimée en nanosecondes.

Lorsque ces champs sont disponibles :

tokens/s = eval_count / (eval_duration / 1 000 000 000)

Cette mesure distingue mieux la génération du temps total de chargement.

15. Étape 11 — Surveiller la mémoire et le processeur

Pendant les tests, observer les ressources de l’ordinateur.

15.1. Sous Windows

Ouvrir le Gestionnaire des tâches et examiner :

  • Le pourcentage d’utilisation du CPU.
  • La mémoire RAM consommée.
  • L’activité GPU, si disponible.
  • La mémoire graphique utilisée.

15.2. Sous Linux

free -h top

Si un GPU NVIDIA compatible est présent et que l’outil est installé :

nvidia-smi

15.3. Avec Ollama

ollama ps

Cette commande permet d’obtenir des informations sur les modèles actuellement chargés, selon la version du logiciel.

15.4. Fiche de mesure

MODÈLE : QUANTIFICATION : TAILLE DU CONTEXTE : DURÉE DU TEST : CPU : RAM UTILISÉE : GPU : VRAM UTILISÉE : VITESSE DE GÉNÉRATION : OBSERVATIONS :

16. Étape 12 — Optimiser si l’assistant est lent

Si le modèle répond lentement ou provoque une saturation mémoire, plusieurs ajustements peuvent être envisagés.

16.1. Utiliser un modèle plus petit

Un modèle moins volumineux demande généralement moins de ressources, mais peut présenter des capacités plus limitées.

16.2. Réduire le contexte

Un contexte plus long peut augmenter la consommation mémoire et le temps de traitement.

16.3. Choisir une quantification adaptée

Une quantification plus compacte peut réduire l’occupation mémoire, au prix d’une éventuelle perte de qualité.

16.4. Fermer les applications inutiles

Libérer de la RAM peut éviter les ralentissements dus à la pression mémoire.

16.5. Utiliser le GPU si compatible

L’accélération GPU peut améliorer les performances, mais son efficacité dépend du matériel, des pilotes, du modèle et de la mémoire disponible.

Méthode recommandée

Modifier un seul paramètre à la fois, refaire le même test et comparer les résultats. Sinon, il devient difficile de déterminer quel réglage a réellement produit une amélioration.

17. Étape 13 — Vérifier la sécurité réseau

Pour un assistant personnel ne nécessitant pas d’accès distant, privilégier un service accessible uniquement depuis l’ordinateur.

17.1. Vérification Ollama sous Windows

Get-NetTCPConnection ` -State Listen ` -LocalPort 11434

17.2. Vérification LM Studio sous Windows

Get-NetTCPConnection ` -State Listen ` -LocalPort 1234

17.3. Interpréter les adresses

  • 127.0.0.1 : boucle locale IPv4.
  • ::1 : boucle locale IPv6.
  • 0.0.0.0 : écoute sur toutes les interfaces IPv4.
  • :: : écoute sur les interfaces IPv6, avec des particularités possibles selon le système.

Si le service écoute sur une adresse non prévue, examiner la configuration avant de poursuivre.

Sécurité

Ne pas exposer directement une API locale sur Internet sans mécanismes de protection adaptés. Les API locales peuvent ne pas intégrer d’authentification par défaut.

18. Étape 14 — Vérifier les données et les historiques

Les conversations et documents utilisés dans l’atelier doivent rester fictifs.

Vérifier :

  • Si les conversations sont enregistrées.
  • Où les historiques sont stockés.
  • Si des fichiers temporaires sont créés.
  • Si un dossier est synchronisé vers un service cloud.
  • Si des extensions disposent de permissions supplémentaires.
  • Comment supprimer les données de test.

18.1. Test de minimisation

Comparer les deux demandes suivantes.

Demande A : Analyse ce dossier complet contenant toutes les informations du client. Demande B : Analyse uniquement ces trois éléments anonymisés et résume les difficultés de suivi du dossier.

La demande B illustre une approche plus conforme au principe de minimisation, à condition que les données soient réellement anonymisées.

19. Étape 15 — Vérifier la fiabilité des réponses

Une IA locale peut produire des erreurs factuelles ou inventer des informations.

Pour ce test, utiliser des données connues et vérifier les résultats.

19.1. Test numérique

Une entreprise réalise : Janvier : 12 000 € Février : 15 000 € Mars : 13 000 € Calcule le chiffre d’affaires total et la moyenne mensuelle. Montre les calculs.

19.2. Correction attendue

Total : 12 000 + 15 000 + 13 000 = 40 000 € Moyenne : 40 000 / 3 = 13 333,33 € environ

19.3. Critères de validation

  • Le total est correct.
  • La moyenne est correcte.
  • Les unités sont indiquées.
  • Les calculs sont cohérents.
  • Aucune donnée supplémentaire n’est inventée.

20. Étape 16 — Tester une limite du modèle

Un assistant doit pouvoir reconnaître lorsqu’il ne dispose pas d’une information.

Envoyer :

Quel est le montant exact du chiffre d’affaires de mon entreprise le mois dernier ? N’invente aucune valeur.

Le modèle n’a pas accès à cette information dans le cadre de l’atelier.

Une réponse appropriée doit indiquer que la donnée n’a pas été fournie.

Compétence importante

La qualité d’un assistant ne se mesure pas uniquement à sa capacité à répondre, mais aussi à sa capacité à signaler les informations manquantes et ses incertitudes.

21. Étape 17 — Réaliser une tâche professionnelle complète

Vous devez maintenant utiliser l’assistant pour produire un document exploitable.

21.1. Situation

Une petite entreprise souhaite informer ses collaborateurs d’une nouvelle procédure de classement des documents.

Les règles sont les suivantes :

  • Créer un dossier par année.
  • Créer un sous-dossier par projet.
  • Nommer les fichiers avec la date au format AAAA-MM-JJ.
  • Éviter les doublons.
  • Ne pas supprimer de document sans validation.

21.2. Consigne à transmettre

Rédige une note interne claire destinée aux collaborateurs. Objectif : Expliquer une nouvelle procédure de classement documentaire. Règles : – Un dossier par année. – Un sous-dossier par projet. – Date au format AAAA-MM-JJ. – Éviter les doublons. – Aucune suppression sans validation. Format : – Un titre. – Une introduction courte. – Une liste numérotée. – Une conclusion. Ton : Professionnel et accessible. N’ajoute aucune règle non fournie.

21.3. Contrôle du résultat

Relire la note produite et vérifier :

  • La présence des cinq règles.
  • L’absence de règles inventées.
  • La clarté des formulations.
  • Le respect du format.
  • La cohérence du ton.

21.4. Amélioration

Si nécessaire, demander une nouvelle version en précisant les corrections attendues.

22. Étape 18 — Diagnostiquer les incidents courants

Une installation locale peut rencontrer plusieurs problèmes techniques.

SymptômeCause possibleVérification ou action
La commande Ollama est inconnue. Installation incomplète ou chemin non disponible. Vérifier l’installation et ouvrir un nouveau terminal.
Le modèle ne démarre pas. Mémoire insuffisante ou problème de compatibilité. Tester un modèle plus petit et consulter les messages d’erreur.
Le téléchargement échoue. Connexion, espace disque ou serveur indisponible. Vérifier la connexion et le stockage.
Les réponses sont très lentes. Modèle trop volumineux ou saturation mémoire. Surveiller les ressources et réduire la charge.
L’API refuse la connexion. Serveur arrêté, port incorrect ou blocage réseau. Vérifier l’état du service et son adresse.
Le modèle répond en anglais. Instructions insuffisantes ou capacités linguistiques limitées. Préciser la langue et envisager un autre modèle.
Les réponses contiennent des erreurs. Limites du modèle ou consigne imprécise. Vérifier les données et reformuler la demande.
L’ordinateur devient instable. Pression mémoire ou problème logiciel. Arrêter le test, libérer les ressources et consulter les journaux.

23. Étape 19 — Réaliser trois scénarios de dépannage

Scénario A — Mémoire insuffisante

Un modèle volumineux ne se charge pas correctement.

Travail demandé : proposer une méthode de résolution.

Afficher la correction

Vérifier la mémoire disponible, fermer les applications inutiles, essayer un modèle plus petit ou une quantification plus compacte, puis refaire le test. Réduire le contexte peut également aider.

Scénario B — API inaccessible

Une requête vers 127.0.0.1:11434 échoue.

Travail demandé : identifier les premières vérifications.

Afficher la correction

Vérifier qu’Ollama est démarré, que le port utilisé est correct, que le serveur écoute effectivement et que la requête cible la bonne adresse. Consulter les messages d’erreur et les journaux si nécessaire.

Scénario C — Réponses inventées

Le modèle ajoute des informations absentes du texte fourni.

Travail demandé : améliorer la méthode de travail.

Afficher la correction

Demander explicitement de s’appuyer uniquement sur les données fournies, de signaler les informations manquantes et de ne pas inventer. Vérifier ensuite chaque affirmation importante. Ces instructions réduisent certains risques mais ne garantissent pas l’exactitude.

24. Étape 20 — Documenter l’installation

Une installation doit pouvoir être comprise, contrôlée et reproduite.

Compléter la fiche suivante.

FICHE DE MISE EN SERVICE ASSISTANT IA LOCAL 1. ENVIRONNEMENT Système : Version : Processeur : RAM : GPU : Espace disque : 2. LOGICIEL Ollama ou LM Studio : Version : Source de téléchargement : 3. MODÈLE Nom : Version ou identifiant : Quantification : Taille : Source : 4. INSTALLATION Date : Étapes réalisées : Difficultés rencontrées : Solutions appliquées : 5. TESTS Conversation : Réussi / Échec Résumé : Réussi / Échec Calcul : Réussi / Échec Hors ligne : Réussi / Échec API : Réussi / Échec / Non applicable 6. PERFORMANCES Durée de réponse : Tokens par seconde : RAM utilisée : GPU utilisé : Observations : 7. SÉCURITÉ Adresse d’écoute : Accès réseau contrôlé : Historique vérifié : Données fictives utilisées : Extensions contrôlées : 8. VALIDATION Objectifs atteints : Limites identifiées : Améliorations proposées : Date de validation :

25. Grille d’évaluation du projet

Cette grille permet d’évaluer les compétences mobilisées pendant l’atelier.

CompétencePointsCritère de réussite
Analyse du besoin2Cahier des charges cohérent.
Vérification matérielle2Configuration correctement relevée.
Choix du modèle2Modèle adapté aux ressources.
Installation3Modèle chargé et opérationnel.
Conversation2Tests fonctionnels réalisés.
API2Requête locale réussie ou équivalent adapté au parcours.
Performances2Mesures documentées et interprétées.
Sécurité3Accès et données contrôlés.
Documentation2Fiche complète et exploitable.
Total20Évaluation globale.

25.1. Interprétation indicative

  • 18 à 20 : excellente maîtrise du projet.
  • 15 à 17 : compétences globalement acquises.
  • 12 à 14 : projet fonctionnel, plusieurs points à consolider.
  • Moins de 12 : reprendre les étapes insuffisamment maîtrisées.

26. Variante avancée — Comparer deux modèles

Pour approfondir le cas pratique, installer un second modèle compatible avec votre ordinateur.

Comparer les deux modèles sur les mêmes tâches.

26.1. Critères

  • Qualité du français.
  • Exactitude des calculs.
  • Respect des consignes.
  • Vitesse de génération.
  • Consommation mémoire.
  • Stabilité.

26.2. Tableau comparatif

CritèreModèle AModèle B
NomÀ compléterÀ compléter
QuantificationÀ compléterÀ compléter
Temps de réponseÀ mesurerÀ mesurer
Tokens/secondeÀ mesurerÀ mesurer
RAM utiliséeÀ mesurerÀ mesurer
Qualité des réponsesÀ évaluerÀ évaluer
Respect des consignesÀ évaluerÀ évaluer

Les tests doivent être effectués dans des conditions aussi comparables que possible.

27. Variante avancée — Préparer un assistant documentaire

Un assistant documentaire peut aider à exploiter un ensemble de documents, à condition que les informations nécessaires lui soient réellement fournies.

Dans cet atelier, il n’est pas nécessaire de construire un système complet de recherche documentaire.

27.1. Test simple

Créer un petit document fictif contenant cinq règles internes.

Copier son contenu dans la conversation et demander au modèle d’en produire une synthèse.

27.2. Vérifier les limites

Le modèle ne peut pas consulter automatiquement un dossier simplement parce que ce dossier existe sur l’ordinateur.

L’accès à des fichiers nécessite une interface, une fonction d’import ou une intégration adaptée.

27.3. Perspectives

Pour exploiter une collection documentaire plus importante, des mécanismes de recherche et de récupération de passages pertinents peuvent être nécessaires.

Une architecture de type RAG peut notamment associer un moteur de recherche documentaire à un modèle de génération.

Ne pas confondre

Installer un modèle local, lui transmettre un document et construire un système documentaire RAG sont trois opérations différentes.

28. Mettre en place une routine de maintenance

Une installation réussie doit rester fiable dans le temps.

28.1. Vérifications périodiques

  • Contrôler les mises à jour logicielles.
  • Vérifier l’espace disque disponible.
  • Supprimer les modèles inutilisés selon les besoins.
  • Examiner les permissions des extensions.
  • Vérifier les paramètres réseau.
  • Contrôler les sauvegardes.
  • Retester les fonctions importantes après modification.

28.2. Exemple de suivi

DATE : LOGICIEL : VERSION : MODÈLE : MODIFICATION EFFECTUÉE : TESTS RÉALISÉS : RÉSULTAT : ACTION COMPLÉMENTAIRE :

29. Les dix erreurs à éviter dans ce projet

  1. Choisir un modèle trop volumineux sans vérifier la mémoire disponible.
  2. Télécharger un logiciel ou un modèle depuis une source non fiable.
  3. Confondre installation du logiciel et téléchargement du modèle.
  4. Supposer que le modèle possède un accès automatique à Internet.
  5. Supposer qu’il peut lire tous les fichiers de l’ordinateur.
  6. Mesurer les performances sans distinguer chargement et génération.
  7. Comparer des modèles avec des paramètres très différents.
  8. Exposer une API sans vérifier les protections réseau.
  9. Utiliser des documents sensibles pendant les premiers tests.
  10. Considérer une réponse convaincante comme une preuve d’exactitude.

30. Questions fréquentes

Faut-il obligatoirement une carte graphique ?

Non. Certains modèles peuvent fonctionner sur CPU. Les performances dépendent alors notamment du processeur, de la mémoire et de la taille du modèle.

Peut-on réaliser le projet avec 8 Go de RAM ?

C’est possible avec certains petits modèles et une configuration adaptée, mais les performances et la mémoire réellement disponible doivent être vérifiées.

Ollama et LM Studio sont-ils obligatoires ensemble ?

Non. Un seul des deux peut suffire pour réaliser l’essentiel du projet.

Pourquoi utiliser un petit modèle pour commencer ?

Il réduit les besoins matériels et facilite le diagnostic. Un modèle plus volumineux pourra être testé ensuite.

Un modèle local peut-il répondre sans Internet ?

Oui, lorsque le modèle et les composants nécessaires sont déjà présents sur l’appareil et que la tâche ne nécessite pas de service externe.

Une IA locale connaît-elle les événements récents ?

Pas nécessairement. Ses connaissances dépendent de son entraînement et des informations supplémentaires qui lui sont éventuellement fournies.

Pourquoi l’API est-elle utile ?

Elle permet à un programme ou à une application de communiquer avec le modèle, notamment pour automatiser certaines tâches.

Le modèle est-il automatiquement sécurisé ?

Non. La sécurité dépend également du système, du réseau, des permissions, des extensions et des pratiques de l’utilisateur.

Comment savoir si un modèle est suffisamment performant ?

Il faut comparer sa qualité de réponse, sa vitesse, sa consommation mémoire et sa stabilité aux besoins réels.

Peut-on utiliser cet assistant dans un cadre professionnel ?

Oui, sous réserve de respecter les règles de l’organisation, les licences applicables, les obligations relatives aux données et les exigences de sécurité.

À retenir

  • Un projet d’IA locale commence par un besoin et un cahier des charges.
  • La RAM, le CPU, le GPU et le stockage influencent le choix du modèle.
  • Ollama permet d’utiliser un modèle local depuis un terminal et une API.
  • LM Studio propose une approche graphique pour télécharger et utiliser des modèles.
  • Le téléchargement du modèle et son chargement en mémoire sont deux opérations distinctes.
  • Les capacités du modèle doivent être vérifiées sur des tâches concrètes.
  • Les instructions initiales influencent le comportement sans garantir l’exactitude.
  • Un test hors ligne permet de vérifier l’autonomie d’une fonction.
  • Une API permet de communiquer avec un modèle depuis un programme.
  • Les performances doivent être mesurées dans des conditions comparables.
  • La vitesse de génération peut être exprimée en tokens par seconde.
  • La consommation mémoire dépend notamment du modèle, de la quantification et du contexte.
  • Les paramètres réseau et les permissions doivent être contrôlés.
  • Les documents et historiques peuvent contenir des informations sensibles.
  • Une réponse générée doit être vérifiée avant toute utilisation importante.
  • Les incidents doivent être diagnostiqués méthodiquement.
  • La documentation facilite la maintenance et la reproduction de l’installation.
  • Une IA locale opérationnelle doit être adaptée, contrôlée et maintenue.
Vérifiez votre compréhension

Question 1 : Pourquoi vérifier la mémoire disponible avant de choisir un modèle ?

Voir la réponse
Parce que le modèle et son contexte consomment de la mémoire. Un modèle trop volumineux peut être très lent, provoquer une saturation ou ne pas se charger.

Question 2 : Quelle différence existe-t-il entre Ollama et LM Studio dans cet atelier ?

Voir la réponse
Ollama permet notamment de travailler facilement avec des commandes et une API. LM Studio privilégie une interface graphique tout en proposant aussi des fonctions de serveur local.

Question 3 : Pourquoi faut-il vérifier les réponses du modèle ?

Voir la réponse
Parce qu’un modèle peut produire des erreurs, inventer des informations ou mal interpréter une consigne.

Question 4 : À quoi sert une API locale ?

Voir la réponse
Elle permet à un logiciel ou à un script de communiquer avec un modèle exécuté localement.

Question 5 : Pourquoi le premier test de performance peut-il être plus lent ?

Voir la réponse
Parce qu’il peut inclure le chargement du modèle et l’initialisation de composants nécessaires à l’inférence.

Question 6 : Que mesure le nombre de tokens par seconde ?

Voir la réponse
La vitesse moyenne de génération des tokens sur une durée donnée.

Question 7 : Pourquoi faut-il vérifier l’adresse d’écoute du serveur ?

Voir la réponse
Pour déterminer si le service écoute uniquement sur la machine locale ou potentiellement sur d’autres interfaces réseau.

Question 8 : Quels éléments doivent figurer dans la fiche de mise en service ?

Voir la réponse
L’environnement matériel, le logiciel, le modèle, les étapes d’installation, les résultats des tests, les performances, les contrôles de sécurité et les limites identifiées.
Fin du chapitre 36 Vous avez terminé « Installer et utiliser une IA en local »

Vous disposez désormais d’une méthode complète pour choisir, installer, utiliser, mesurer, sécuriser et maintenir un assistant IA exécuté sur votre ordinateur.

Exercices du cours

Entraînez-vous avec 15 exercices progressifs. Ouvrez un exercice pour répondre, puis afficher sa correction.