Dimensionner son matériel avant de choisir un modèle

Le premier point d'attention est purement matériel, et il est souvent sous-estimé. Le facteur limitant d'un LLM local, c'est la VRAM, la mémoire dédiée du processeur graphique (GPU) dans laquelle sont chargés les paramètres du modèle pendant son exécution. Plus le modèle est grand, plus il en réclame.

Un modèle est désigné par le nombre de milliards de paramètres qu'il contient : 7B, 14B, 70B. Pour réduire son empreinte mémoire, on l'utilise sous forme quantifiée, c'est-à-dire compressée, le plus souvent en 4 bits. Voici les ordres de grandeur que j'utilise pour dimensionner.

VRAM nécessaire par taille de modèle (quantification 4 bits)
Taille du modèleVRAM nécessaireExemples de matériel compatible
7B paramètres 4 à 5 Go NVIDIA RTX 3060 12 Go, Mac M2 Pro 16 Go
14B paramètres 8 à 10 Go NVIDIA RTX 4070 12 Go, Mac M4 Pro 24 Go
30B paramètres 18 à 20 Go NVIDIA RTX 4090 24 Go, Mac M4 Pro 32 Go
70B paramètres 32 à 35 Go NVIDIA RTX 5090 32 Go, Mac M4 Max 64 Go
Valeurs pour une quantification 4 bits (Q4). Une quantification 8 bits double approximativement ces besoins. Prévoyez 1 à 2 Go de marge pour le contexte, qui grossit avec la longueur des conversations.

Le bon réflexe : choisir le modèle en fonction de son matériel, jamais l'inverse. Tenter de faire tourner un 70B sur une machine dotée de 16 Go de VRAM produit au mieux des performances dégradées, avec un déchargement sur la RAM centrale voire sur le disque, au pire une installation instable. Si vous débutez, un 7B offre un bon rapport performance/ressources sur du matériel grand public.

Une nuance apparue avec les modèles à mélange d'experts (MoE), de plus en plus courants : ils n'activent qu'une fraction de leurs paramètres à chaque jeton généré, mais l'ensemble des poids doit tout de même tenir en mémoire. Un modèle annoncé « 30B avec 3B actifs » sera rapide, pas léger. Regardez le poids du fichier, pas l'argument marketing.

Pour les utilisateurs Apple, la mémoire unifiée des puces Apple Silicon (M1 à M4) est partagée entre le CPU et le GPU. Les 16 ou 24 Go affichés correspondent bien à de la mémoire exploitable par le modèle, à condition de ne pas saturer le système avec d'autres applications ouvertes en parallèle.

Vérifier le format des fichiers avant de les charger

Voilà le point que je vois le plus souvent absent des guides d'installation, alors qu'il conditionne tout le reste. Charger un modèle, ce n'est pas ouvrir une image : selon le format, cela peut revenir à exécuter du code.

Les fichiers PyTorch classiques en .bin, .pt ou .pth reposent sur le module pickle de Python, qui exécute du code arbitraire au moment de la désérialisation. Un fichier de poids piégé peut donc lancer une commande sur votre machine dès le chargement, sans que vous ayez rien tapé.

La parade tient en deux formats. Le premier est safetensors, conçu par Hugging Face pour stocker des tenseurs sans mécanisme d'exécution : c'est le format à privilégier systématiquement pour les modèles destinés à PyTorch ou vLLM. Le second est GGUF, utilisé par llama.cpp, Ollama et LM Studio, qui n'exécute pas de code non plus.

Attention toutefois : « pas de code exécutable » ne veut pas dire « pas de risque ». Un parseur peut être bogué, et l'histoire récente d'Ollama le montre bien (j'y reviens plus loin). Le format réduit la surface d'attaque, il ne la supprime pas.

Concrètement, quand je récupère un modèle sur Hugging Face, je regarde l'onglet des fichiers avant de cliquer. Si le dépôt ne propose que des .bin et que le même modèle existe ailleurs en safetensors, je prends l'autre. Hugging Face fait tourner un scanner de sérialisation sur les dépôts et signale les fichiers suspects, mais je ne considère pas ce contrôle comme une garantie suffisante à lui seul.

Verrouiller l'accès au point d'entrée du modèle

Un LLM qui tourne en local expose un endpoint, un point d'accès réseau que les applications utilisent pour lui envoyer des requêtes. Sans authentification, toute personne qui atteint ce port peut interroger le modèle librement, en dehors de tout contexte prévu.

La première question à se poser est bête, mais elle règle 80 % des cas : sur quelle interface le serveur écoute-t-il ? Ollama, par défaut, n'écoute que sur 127.0.0.1:11434, donc uniquement depuis la machine locale. C'est la configuration la plus sûre pour un usage personnel. Le problème surgit quand on bascule sur 0.0.0.0 pour partager l'accès et qu'on oublie le pare-feu derrière.

Pour vérifier ou forcer la liaison locale sous Linux :

sudo systemctl edit ollama.service

[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"

sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434

La dernière ligne doit renvoyer une écoute sur 127.0.0.1. Si elle affiche 0.0.0.0 ou *, votre modèle est accessible depuis le réseau.

Dès que plusieurs postes doivent y accéder, il faut ajouter une couche d'authentification en amont. La bonne pratique consiste à mettre en place une authentification par jeton et à définir des rôles distincts : qui peut interroger le modèle, qui peut modifier sa configuration, qui peut consulter les journaux. Cette séparation limite très concrètement les dégâts en cas de compromission d'un compte.

Qu'est-ce qu'un token JWT ?
Un JWT (JSON Web Token) est un jeton signé qu'un utilisateur reçoit après s'être authentifié. Il contient son identité, ses droits et une date d'expiration. À chaque requête envoyée au modèle, le jeton est transmis et vérifié. S'il est absent, expiré ou falsifié, la requête est refusée, exactement comme sur la plupart des API cloud.
Pourquoi un reverse proxy ?
Un serveur intermédiaire comme Nginx ou Caddy se place devant le moteur d'inférence. Il centralise l'authentification, chiffre les échanges en TLS, limite le débit et journalise les requêtes, sans qu'on ait à modifier la configuration du moteur lui-même.

Voici un bloc Nginx minimal qui protège Ollama par une authentification et le laisse écouter uniquement en local :

server {
    listen 443 ssl;
    server_name llm.monreseau.lan;

    ssl_certificate     /etc/nginx/certs/llm.crt;
    ssl_certificate_key /etc/nginx/certs/llm.key;

    location / {
        auth_basic           "Acces LLM interne";
        auth_basic_user_file /etc/nginx/.htpasswd;

        proxy_pass         http://127.0.0.1:11434;
        proxy_set_header   Host localhost:11434;
        proxy_read_timeout 300s;
        proxy_buffering    off;
    }
}

L'authentification HTTP basique reste rudimentaire, mais elle vaut infiniment mieux qu'un port ouvert. Pour une équipe, je passe plutôt par un proxy d'authentification relié à l'annuaire de l'entreprise, ou par un réseau privé maillé type Tailscale ou WireGuard, qui évite d'exposer quoi que ce soit sur Internet.

Isoler et chiffrer les fichiers du modèle

Les fichiers de poids d'un modèle, ce que le modèle a appris pendant son entraînement, pèsent de quelques gigaoctets à plus de 100 Go. S'ils sont lisibles par tous les comptes du système, n'importe quel utilisateur peut les copier sur une clé USB sans laisser de trace.

La parade est simple et rarement appliquée : stocker ces fichiers sur un volume chiffré, monté en lecture seule dans l'environnement d'exécution, avec des permissions restreintes au seul processus qui fait tourner le modèle. Sur Linux, LUKS pour le chiffrement du volume et un couple chmod/chown pour les permissions suffisent. Sur macOS, FileVault chiffre le disque de façon transparente. Si vous passez par Docker, montez le répertoire des modèles avec l'option :ro et faites tourner le conteneur en utilisateur non privilégié.

Cette précaution couvre aussi un scénario qu'on oublie souvent : le vol du poste ou du serveur. Sans chiffrement, les fichiers du modèle et les données mises en cache pendant les inférences sont directement lisibles par celui qui s'empare de la machine.

Sécuriser la base documentaire connectée au modèle (RAG)

Certains déploiements branchent le LLM sur une base de connaissances interne via un mécanisme appelé RAG (Retrieval-Augmented Generation). Au lieu de se limiter à ce qu'il a appris, le modèle interroge en temps réel des documents internes, contrats, manuels, bases de données, pour enrichir ses réponses.

La fonctionnalité est puissante et elle introduit un risque bien précis. Si la base documentaire n'est pas protégée au même niveau que le modèle, un utilisateur peut, avec des requêtes bien tournées, accéder à des documents qu'il n'a pas à consulter. L'erreur classique consiste à sécuriser l'API d'inférence en laissant la base vectorielle ouverte sur le réseau interne.

Ce que j'applique :

Encadrer les agents et les outils connectés au modèle

C'est la nouveauté de ces derniers mois, et le sujet sur lequel je reçois le plus de questions. Un LLM local ne se contente plus toujours de générer du texte : via le protocole MCP (Model Context Protocol) ou des mécanismes d'appel d'outils équivalents, il peut lire des fichiers, exécuter des commandes, interroger une API ou envoyer un message. On passe d'un générateur de texte à un exécutant.

Le chercheur en sécurité Simon Willison a proposé en 2025 une grille de lecture devenue la référence sur le sujet, qu'il appelle la « triade létale ». Un agent devient structurellement exploitable dès que trois conditions sont réunies en même temps : il accède à des données privées, il traite du contenu venu de l'extérieur, et il dispose d'un moyen de communiquer vers l'extérieur. Réunissez les trois dans une même session et un attaquant n'a plus qu'à glisser une instruction dans un document que l'agent va lire.

Le fait que le modèle tourne sur votre machine ne change rien à cette mécanique. Un modèle local qui lit vos e-mails, ouvre une pièce jointe piégée et dispose d'un outil d'envoi HTTP peut exfiltrer vos données aussi efficacement qu'un service cloud compromis. Et sans journalisation, vous ne le saurez jamais.

Mes règles sur ce point :

Ne pas télécharger depuis des sources non vérifiées

Les modèles ouverts sont distribués via des plateformes identifiées, principalement Hugging Face et la bibliothèque officielle d'Ollama. Des versions modifiées circulent aussi sur des dépôts tiers, des forums, des serveurs Discord ou des liens partagés sur les réseaux.

Un modèle altéré peut embarquer des biais introduits volontairement pour orienter les réponses, un mécanisme d'exfiltration déclenché par certaines formulations, ou un comportement dormant invisible à l'usage courant. La littérature académique parle de sleeper agents : des modèles qui se comportent normalement jusqu'à ce qu'un déclencheur précis apparaisse dans la requête.

Sur Hugging Face, je vérifie systématiquement le badge de l'organisation, le nombre de téléchargements, la date de mise à jour et les discussions ouvertes sur le dépôt. Quand l'auteur publie une empreinte SHA-256, je la compare après téléchargement. Ça prend trente secondes et ça élimine la moitié des scénarios désagréables.

Ne pas exposer le modèle sur le réseau sans protection

La quasi-totalité des outils grand public destinés à l'usage local ne propose aucun système d'identification intégré, parce qu'ils ont été conçus pour tourner sur une seule machine. Le moment où l'on modifie la configuration pour partager l'accès est donc le moment critique. Les outils orientés serveur, eux, commencent à proposer quelque chose, avec des limites qu'il faut connaître.

Comparatif des principaux moteurs LLM locaux
OutilInterfacePoints fortsAuthentification native
Ollama Ligne de commande et application Rapide, léger, API REST, large catalogue Non
LM Studio Interface graphique Chat intégré, prise en main immédiate Non
Jan Interface graphique 100 % hors ligne, sobre Non
GPT4All Interface graphique Multi-modèles, RAG intégré Non
llama.cpp Ligne de commande Très léger, très portable Non
vLLM Serveur Haut débit, multi-utilisateurs, API compatible OpenAI Partielle : clé API sur les routes /v1 seulement
LocalAI Serveur et interface web Comptes utilisateurs, rôles, OAuth, suivi de consommation Oui
La clé API de vLLM ne couvre que les endpoints compatibles OpenAI : d'autres routes sensibles restent accessibles sur le même port. La documentation officielle du projet recommande explicitement de ne pas s'y fier seule. Un proxy d'authentification reste nécessaire pour tout accès partagé.

Mettre à jour le moteur d'inférence

« C'est local, donc ce n'est pas exposé. » Ce raisonnement fait vieillir des installations pendant des mois. Les chiffres de 2026 racontent une autre histoire.

En janvier 2026, un relevé mené par SentinelLABS et Censys a identifié environ 175 000 serveurs Ollama accessibles depuis Internet, dont près de la moitié capables d'exécuter du code ou d'appeler des API externes. Ces serveurs n'avaient pas été piratés : leurs propriétaires avaient basculé OLLAMA_HOST sur 0.0.0.0 et oublié le pare-feu.

En février, une faille critique baptisée « Bleeding Llama » (CVE-2026-7482, score CVSS 9.1) a été corrigée dans la version 0.17.1. Il s'agissait d'une lecture hors limites dans le chargeur de fichiers GGUF : un fichier fabriqué déclarant une taille de tenseur supérieure à son contenu réel permettait à un attaquant non authentifié de lire la mémoire du processus. Prompts système, conversations en cours, variables d'environnement, clés API. Trois requêtes HTTP suffisaient, sans aucune erreur dans les journaux. Le CVE n'a été attribué qu'en avril, ce qui laisse deux mois pendant lesquels les scanners de vulnérabilités classiques n'avaient rien à signaler.

Ce n'était pas la première : en 2024 déjà, la faille « Probllama » (CVE-2024-37032) permettait une exécution de code à distance via une traversée de répertoire, particulièrement triviale à exploiter dans les installations Docker où le serveur tournait en root.

Si votre instance a été joignable depuis Internet avant d'être mise à jour, considérez que les secrets présents dans son environnement ont fuité et faites-les tourner. C'est la recommandation des chercheurs qui ont publié la faille, et elle coûte moins cher qu'un incident.

L'ordre dans lequel je traite le sujet, quand je reprends une installation existante : lier le service à localhost, mettre à jour le moteur, fermer le port au pare-feu, puis seulement ajouter le proxy. Poser un Nginx devant un port qui écoute toujours sur toutes les interfaces ne protège rien du tout.

Logs, RGPD et AI Act : ce qui s'applique vraiment

Beaucoup d'installations locales tournent sans aucune journalisation. Conséquence directe : impossible de savoir qui a interrogé le modèle, quand, et avec quelles données. Au-delà du risque opérationnel, c'est un problème de conformité.

Le RGPD, d'abord

C'est lui qui mord en premier, et de loin. Il s'applique dès qu'une donnée à caractère personnel transite dans une requête adressée au modèle, ce qui arrive vite : un salarié qui colle un e-mail client dans le chat, un CV analysé par un modèle de tri, une base RAG remplie de contrats nominatifs. Les journaux d'inférence deviennent alors un traitement de données à part entière, soumis aux principes de minimisation et de limitation de conservation.

Ce que ça implique en pratique : détecter et masquer les données personnelles avant stockage des journaux, fixer une durée de conservation et l'appliquer réellement, inscrire le traitement au registre, et informer les personnes concernées. La CNIL publie des recommandations dédiées aux systèmes d'IA qui donnent le cadre. Le fait que le modèle tourne sur votre serveur ne vous dispense de rien : ça supprime le transfert vers un sous-traitant, pas les obligations du responsable de traitement.

L'AI Act et le report de juillet 2026

Le calendrier a bougé récemment, et beaucoup d'articles en circulation citent encore les anciennes dates. Le règlement (UE) 2026/1744, dit « omnibus numérique IA », est entré en vigueur le 27 juillet 2026 après un vote du Parlement européen le 16 juin et une adoption formelle du Conseil le 29 juin. Il reporte l'application des obligations les plus lourdes.

Calendrier de l'AI Act après l'omnibus numérique
ObligationDate d'applicationStatut
Pratiques interdites (scoring social, manipulation, reconnaissance des émotions au travail) 2 février 2025 En vigueur
Obligations sur les modèles à usage général (GPAI) 2 août 2025 En vigueur
Transparence de l'article 50 (informer l'utilisateur qu'il parle à une IA, marquage des contenus générés) 2 août 2026 En vigueur
Littératie IA de l'article 4 (formation des équipes) 2 février 2025, assouplie en obligation de moyens En vigueur
Interdiction des contenus intimes non consentis générés par IA 2 décembre 2026 À venir
Systèmes à haut risque autonomes (annexe III) : gestion des risques, documentation technique, journalisation, supervision humaine 2 décembre 2027 (au lieu du 2 août 2026) Reporté
IA à haut risque intégrée à des produits réglementés (annexe I) 2 août 2028 Reporté
Les sanctions liées aux pratiques interdites peuvent atteindre 35 millions d'euros ou 7 % du chiffre d'affaires mondial. Celles liées aux obligations de transparence de l'article 50 plafonnent à 15 millions d'euros ou 3 %.

Le raccourci « l'AI Act est reporté » est faux et dangereux. Le report est ciblé : il concerne le régime lourd applicable aux systèmes à haut risque, pas le reste du règlement. Si votre LLM local sert dans un contexte sensible comme les ressources humaines, le crédit, la santé ou la justice, vous entrez probablement dans la catégorie haut risque, et vous gagnez seize mois pour cartographier vos systèmes, qualifier leur niveau de risque et documenter votre gouvernance. Pas pour ne rien faire.

Même pour un usage strictement interne, une absence totale de journaux ne tient pas lors d'un audit. Mieux vaut des logs anonymisés que pas de logs du tout.

Ne pas confondre « local » et « sécurisé »

C'est le piège le plus répandu, et le plus coûteux à corriger après coup. Le raisonnement « mes données restent sur ma machine, donc je suis protégé » est séduisant. Il est incomplet.

L'injection de prompt, cette technique qui consiste à manipuler le modèle via des requêtes formulées pour contourner ses consignes, fonctionne exactement aussi bien en local que dans le cloud. Un modèle peut ainsi être amené à révéler son prompt système, à ignorer ses filtres internes, ou à extraire des documents de la base RAG à laquelle il est connecté.

Sa variante indirecte est plus retorse encore : l'instruction malveillante n'est pas tapée par l'utilisateur, elle est cachée dans un document que le modèle va lire. Un PDF envoyé par un candidat, une page web récupérée par un agent, un ticket de support. Le modèle ne sait pas distinguer une donnée d'une instruction, et cette limite est structurelle : elle ne se corrige pas par un meilleur prompt système.

Ce type de vulnérabilité figure en tête du Top 10 OWASP pour les applications LLM. Il ne disparaît pas parce que le modèle tourne sur un serveur interne. La sécurité d'un déploiement local exige la même rigueur qu'un service hébergé : validation des entrées, filtrage des sorties, surveillance des comportements anormaux, mises à jour du moteur et des dépendances.

Récapitulatif : checklist à faire et à éviter

Checklist sécurité pour un déploiement LLM en local
À faireÀ éviter
Choisir le modèle en fonction de la VRAM disponible Forcer un modèle trop grand sur du matériel insuffisant
Privilégier les formats safetensors et GGUF Charger des poids en .bin ou .pt sans en connaître l'origine
Vérifier que le service écoute bien sur 127.0.0.1 Basculer sur 0.0.0.0 sans pare-feu ni proxy
Mettre en place une authentification par jeton et des rôles Exposer l'endpoint sans aucune protection réseau
Stocker les poids sur un volume chiffré en lecture seule Laisser les fichiers du modèle lisibles par tous les comptes
Filtrer la base RAG sur l'identité avant la recherche vectorielle Sécuriser l'API d'inférence et laisser la base vectorielle ouverte
Séparer les outils de lecture et d'écriture d'un agent Donner à un agent des données privées, du contenu externe et un canal de sortie
Télécharger uniquement depuis Hugging Face ou les sources officielles Installer un modèle depuis un dépôt tiers non vérifié
Suivre les versions du moteur d'inférence et appliquer les correctifs Considérer qu'un service local n'a pas besoin d'être patché
Activer la journalisation et anonymiser les données personnelles Faire tourner le modèle sans aucun journal d'inférence
Traiter l'injection de prompt comme un risque réel Croire que « local » égale « sécurisé » par nature
Checklist à jour des réglementations et des vulnérabilités connues en août 2026.

Par où commencer selon votre situation

Tout ce qui précède ne s'applique pas au même degré à un usage personnel et à un déploiement d'entreprise. Voici comment je hiérarchise.

Particulier, usage personnel sur un seul poste
Laissez le service écouter sur localhost, tenez le moteur à jour, activez le chiffrement du disque et ne téléchargez que depuis les catalogues officiels. Un modèle 7B ou 14B en GGUF, et vous avez couvert l'essentiel du risque réel.
Petite équipe, quelques postes sur un réseau local
Ajoutez un reverse proxy avec authentification et TLS, ou un réseau privé maillé. Journalisez les requêtes sans stocker leur contenu intégral. Documentez qui a accès à quoi, même sur une simple page. C'est le niveau où l'on passe du bricolage à un service.
Organisation manipulant des données sensibles
Authentification reliée à l'annuaire, rôles distincts, cloisonnement de la base RAG, journaux anonymisés avec durée de conservation définie, registre RGPD à jour, veille sur les CVE des moteurs utilisés, et qualification du système au regard de l'AI Act avant l'échéance de décembre 2027.

Ce que je retiens

Déployer un LLM en local est une démarche légitime, souvent la bonne, aussi bien pour la confidentialité que pour la maîtrise des coûts. Mais cette liberté s'accompagne d'une responsabilité entière sur la sécurité du déploiement, et les 300 000 serveurs qui ont laissé fuiter leur mémoire cette année rappellent que le sujet n'a rien de théorique.

La bonne nouvelle, c'est que la majorité des incidents relèvent de réflexes simples : écouter sur la bonne interface, patcher, chiffrer, journaliser, ne pas donner à un agent plus de droits qu'il n'en faut. Appliqués dès l'installation, ces réflexes coûtent une après-midi. Rattrapés après un incident, ils coûtent beaucoup plus.

Faire tourner un modèle de langage sur sa propre machine ou son serveur interne est à la portée de tous. Mais « local » ne veut pas dire « sécurisé ». Voici les réflexes que j'applique et les erreurs que je vois revenir le plus souvent.

Installer un grand modèle de langage (LLM) sur sa machine ou sur un serveur interne est devenu une opération de quelques minutes, aussi bien pour le particulier curieux que pour l'équipe IT d'une PME. Ollama, LM Studio, Jan, GPT4All ou llama.cpp permettent de télécharger et de lancer un modèle sans dépendre d'un service cloud. Les raisons de franchir le pas sont connues : garder la main sur ses données, maîtriser ses coûts d'inférence, répondre aux exigences du RGPD ou d'une politique interne.

Le problème, c'est que le périmètre à protéger change complètement par rapport à un usage cloud. C'est vous, particulier ou organisation, qui portez désormais la responsabilité de l'infrastructure, des accès au modèle et des données qui transitent. Personne ne patchera le serveur à votre place. Je passe ici en revue ce qu'il faut faire, de la configuration matérielle jusqu'aux obligations réglementaires, avec les commandes concrètes quand elles servent.