Modèles de LLM locaux : guide complet pour exécuter des modèles d’IA sur votre matériel

Les modèles de LLM locaux sont des modèles de langage IA qui s’exécutent entièrement sur votre matériel — ordinateur de bureau, ordinateur portable ou serveur — sans envoyer de données vers des API externes. Vous téléchargez les poids du modèle, les chargez en mémoire, puis exécutez l’inférence localement. Cela vous garantit une confidentialité totale, l’absence de coûts par jeton, un fonctionnement hors ligne et un contrôle intégral du comportement du modèle. En contrepartie, cela implique un investissement matériel initial et une inférence plus lente comparée aux fournisseurs cloud exploitant des infrastructures hautement optimisées.

Populaires LLM local Modèles

En 2026, ces modèles offrent le meilleur compromis entre qualité et accessibilité matérielle pour un déploiement local :

Modèle	Paramètres	VRAM (4 bits)	VRAM (16 bits)	Idéal pour
Llama 3.1	8B / 70B / 405B	6 Go / 40 Go / 240 Go	16 Go / 140 Go / 810 Go	Usage général, programmation, raisonnement
Mistral 7B v0.3	7B	5 Go	14 Go	Inférence rapide, bon rapport qualité/taille
Phi-3-medium	14B	9 Go	28 Go	Raisonnement efficace, compatible avec les GPU grand public
Gemma 2	9B / 27B	6 Go / 18 Go	18 Go / 54 Go	Suivi des instructions, réglé pour la sécurité
Qwen 2.5	7B / 72B	5 Go / 42 Go	14 Go / 144 Go	Multilingue, performant en mathématiques et en programmation
DeepSeek-Coder-V2	16B / 236B	10 Go / 140 Go	32 Go / 472 Go	Génération et compréhension de code

Les estimations de VRAM sont approximatives et varient selon la longueur du contexte et la taille des lots. Utilisez le Calculateur de VRAM pour connaître les besoins précis en fonction de votre configuration, ou consultez Exigences en VRAM selon le modèle pour des spécifications détaillées couvrant plus de 37 modèles.

Exigences matérielles

Les modèles de LLM locaux sont entièrement chargés en mémoire pendant l’inférence. Vous pouvez les exécuter sur la VRAM du GPU, sur la mémoire système ou sur une combinaison des deux :

GPU (le plus rapide)

Les GPU NVIDIA compatibles CUDA offrent les meilleures performances. Les GPU AMD fonctionnent via ROCm, mais bénéficient d’un support logiciel moindre. Les puces Apple Silicon (M1/M2/M3) utilisent une mémoire unifiée et exécutent efficacement les modèles via Metal.

• Niveau entrée : RTX 3060 12 Go ou RTX 4060 Ti 16 Go exécute des modèles de 7 à 8 milliards de paramètres en quantification 4 bits
• Milieu de gamme : La RTX 4090 24 Go gère des modèles de 30 milliards de paramètres quantifiés, ou des modèles de 13 milliards de paramètres en précision pleine
• Haut de gamme : L’A6000 48 Go ou deux GPU grand public permettent d’exécuter des modèles de 70 milliards de paramètres en quantification 4 bits

Consultez le meilleures GPU pour les LLM locaux guide pour les tests de performance et les rapports prix/performance.

CPU (plus lent, mais accessible)

N’importe quel processeur moderne peut exécuter des modèles LLM locaux en utilisant la mémoire vive système, bien que l’inférence soit 10 à 50 fois plus lente qu’avec un GPU. Cette approche reste viable pour les petits modèles (7 à 8 milliards de paramètres) ou lorsque la confidentialité prime sur la vitesse.

• Configuration minimale : 16 Go de RAM pour les modèles de 7 milliards de paramètres en quantification 4 bits
• Configuration recommandée : 32 Go de RAM ou plus pour une utilisation confortable avec des fenêtres de contexte étendues
• Serveur : 128 Go de RAM ou plus permettent d’exécuter des modèles de 70 milliards de paramètres sur des systèmes CPU uniquement

Hybride (GPU + CPU)

La plupart des frameworks prennent en charge le déchargement (offloading) : certaines couches sont chargées sur le GPU, les autres débordent dans la RAM. Un modèle de 70 milliards de paramètres pourrait ainsi utiliser 24 Go de VRAM + 32 Go de RAM, offrant une inférence 3 à 5 fois plus rapide qu’en mode CPU seul.

Exécuter des modèles de LLM locaux

Ollama (le plus simple)

Ollama intègre llama.cpp dans une interface CLI simplifiée et un registre de modèles. C’est la méthode la plus rapide pour commencer :

# Installation sur macOS/Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows : téléchargez l’installateur depuis ollama.ai

# Exécutez un modèle (téléchargement automatique)
ollama run llama3.1

# Liste des modèles disponibles
ollama list

# Téléchargez un modèle spécifique
ollama pull mistral:7b-instruct-q4_0

Ollama sélectionne automatiquement le GPU ou le CPU, gère la quantification et les téléchargements de modèles. Pour une configuration détaillée, consultez la Guide complet d’Ollama documentation officielle comment installer Ollama ou passez directement aux

instructions pas à pas par plateforme. Liste des modèles Ollamaliste complète des modèles disponibles sur le Meilleurs modèles locaux pour Ollama.

LM Studio (interface graphique)

LM Studio fournit une application de bureau pour Windows, macOS et Linux, dotée d’une interface conversationnelle et d’un navigateur de modèles. Téléchargez-la depuis lmstudio.ai, lancez-la, recherchez des modèles dans l’onglet « Découvrir » et cliquez sur « Télécharger ». Les modèles utilisent le format GGUF et se chargent avec une quantification ajustable.

LM Studio affiche en temps réel l’utilisation de la VRAM et la vitesse d’inférence, ce qui facilite le réglage des paramètres. Elle exécute également un serveur API local compatible OpenAI sur http://localhost:1234/v1 http://localhost:1234 Guide complet de LM Studio pour les fonctionnalités avancées.

llama.cpp (avancé)

llama.cpp est le moteur sous-jacent d’Ollama et de LM Studio, offrant un contrôle maximal aux développeurs :

# Cloner et compiler
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make

# Avec support CUDA
make LLAMA_CUDA=1

# Exécuter une inférence
./main -m models/llama-3.1-8b-instruct-q4_0.gguf -p "Expliquez l’informatique quantique" -n 512 --gpu-layers 35

Le --gpu-layers détermine combien de couches du transformeur sont chargées sur le GPU plutôt que dans la RAM. Plus cette valeur est élevée, plus la VRAM est sollicitée, mais plus l’inférence est rapide. Commencez avec la moitié du nombre total de couches du modèle, puis ajustez.

Autres outils

• text-generation-webui : Interface web avec extensions et prise en charge de plusieurs backends
• vLLM : Serveur d’inférence optimisé pour des déploiements de production à haut débit
• LocalAI : Remplacement direct de l’API OpenAI prenant en charge plusieurs formats de modèles
• Jan : Application de bureau similaire à LM Studio, axée sur la confidentialité

Formats de modèles et quantification

La quantification réduit la précision des poids d’un modèle, passant de nombres flottants 16 bits ou 32 bits à 8 bits, 4 bits ou une précision mixte, réduisant ainsi les besoins en mémoire de 50 à 75 %, avec une perte de qualité de 2 à 5 %. Différents formats sont optimisés pour différents types de matériel :

GGUF (Ollama, LM Studio, llama.cpp)

GGUF est le format standard pour le déploiement local. Niveaux courants de quantification :

• Q4_0 : 4 bits, taille minimale, perte de qualité de 5 à 10 %
• Q4_K_M : 4 bits avec précision mixte, bon compromis entre taille et qualité
• Q5_K_M : 5 bits, meilleure qualité que Q4, tout en restant compact
• Q8_0 : 8 bits, perte de qualité minimale, fichiers plus volumineux
• F16 : Précision pleine 16 bits, aucune quantification

Pour la plupart des cas d’usage, Q4_K_M ou Q5_K_M offrent le meilleur rapport qualité/taille. Utilisez Q8_0 ou F16 uniquement si vous disposez de VRAM excédentaire et que vous avez besoin d’une précision maximale.

GPTQ (inférence Python)

GPTQ effectue une quantification en 4 bits ou 3 bits, optimisée pour l’inférence GPU à l’aide de bibliothèques telles qu’AutoGPTQ ou ExLlama. Très répandu dans les workflows Hugging Face Transformers. Les modèles GPTQ se chargent plus rapidement que les modèles GGUF, mais nécessitent un environnement Python.

AWQ (inférence GPU rapide)

AWQ (Activation-aware Weight Quantization) préserve davantage de précision que GPTQ en 4 bits, en protégeant les poids les plus importants. Nécessite des moteurs d’inférence compatibles AWQ, tels que vLLM ou TGI.

Choisir un modèle de LLM local

Adaptez la taille du modèle à votre matériel et à votre cas d’usage :

• Modèles de 7 à 8 milliards de paramètres : S’adaptent aux GPU grand public (12 à 16 Go de VRAM), réponses rapides, idéaux pour les conversations et les tâches simples
• Modèles de 13 à 14 milliards de paramètres : Nécessitent 20 à 24 Go de VRAM, amélioration notable des capacités de raisonnement et de suivi des instructions
• Modèles de 30 à 34 milliards de paramètres : Requièrent 40 Go de VRAM ou plus, ou une configuration hybride GPU+RAM ; leur qualité approche celle de GPT-3.5
• Modèles de 70 milliards de paramètres et plus : Nécessitent du matériel serveur ou une quantification agressive, rivalisant avec GPT-4 sur de nombreuses tâches

Consultez les spécifications et les scores de référence pour 37 modèles dans la Base de données des modèles IA, ou comparez les classements dans la Classement des grands modèles linguistiques (LLM) triée par intelligence, prix et longueur de contexte.

Pour l’analyse des coûts, utilisez le calculateur auto-hébergement vs API afin de déterminer le seuil de rentabilité entre les coûts matériels locaux et ceux des API cloud. Les modèles locaux impliquent un coût initial plus élevé, mais aucun coût marginal par jeton, ce qui les rend moins chers à fort volume.

Questions fréquemment posées

Puis-je exécuter des modèles de LLM locaux sur un ordinateur portable ?

Oui, à condition de disposer d’au moins 16 Go de mémoire unifiée (puces Apple Silicon) ou de 16 Go de RAM associés à une carte graphique dédiée disposant d’au moins 8 Go de VRAM. Les MacBook Pro équipés des puces M1 Max/ Ultra, M2 Pro/ Max ou M3 Max exécutent efficacement des modèles de 7 à 13 milliards de paramètres. Sur les ordinateurs portables Windows ou Linux dotés de cartes graphiques mobiles RTX 4060 à 4090, il est possible d’exécuter des modèles de 7 à 30 milliards de paramètres, selon la quantité de VRAM disponible. L’inférence sur CPU uniquement fonctionne sur n’importe quel ordinateur portable disposant d’au moins 16 Go de RAM, mais elle est 10 à 50 fois plus lente.

À quel point les modèles de LLM locaux sont-ils plus lents que les fournisseurs d’API ?

Cela dépend du matériel utilisé. Un modèle de 7 milliards de paramètres sur une RTX 4090 génère 80 à 120 jetons par seconde, ce qui est comparable à la latence offerte par les API. Le même modèle exécuté sur CPU produit 5 à 15 jetons par seconde. Quant aux modèles plus volumineux (70 milliards de paramètres et plus), même avec accélération GPU sur du matériel grand public, ils ne génèrent que 2 à 10 jetons par seconde. Les fournisseurs cloud utilisent des grappes H100 optimisées pour le débit, mais les modèles locaux éliminent la latence réseau : vous obtenez immédiatement la réponse au premier jeton.

Les modèles de LLM locaux nécessitent-ils une connexion Internet ?

Non, une fois téléchargés. Vous téléchargez une seule fois les poids du modèle (1 à 150 Go selon sa taille), puis l’inférence s’exécute entièrement hors ligne. Ollama, LM Studio et llama.cpp mettent en cache les modèles localement. Cela rend les LLM locaux adaptés aux environnements isolés (« air-gapped »), aux déplacements ou aux travaux sensibles en matière de confidentialité, où aucune donnée ne doit quitter votre réseau.

Quelle est la différence de qualité entre les modèles quantifiés et ceux en précision pleine ?

La quantification sur 4 bits (Q4_K_M) entraîne une perte de qualité de 2 à 5 % sur la plupart des benchmarks comparée à la précision sur 16 bits, affectant principalement le raisonnement complexe et la restitution factuelle. La quantification sur 8 bits entraîne une perte inférieure à 1 %. Pour les usages conversationnels, l’assistance à la programmation et le traitement de documents, la plupart des utilisateurs ne perçoivent pas de différence entre Q4_K_M et F16. Pour les applications critiques exigeant une précision maximale (médicales, juridiques, scientifiques), privilégiez Q8_0 ou F16 si vous disposez de suffisamment de VRAM.

Puis-je affiner (fine-tune) des modèles de LLM locaux ?

Oui, à l’aide de bibliothèques telles qu’Axolotl, Ludwig ou Hugging Face TRL. L’affinage nécessite davantage de VRAM que l’inférence : comptez au moins 24 Go pour un modèle de 7 milliards de paramètres en affinage complet, ou 12 à 16 Go avec des méthodes efficaces en paramètres comme LoRA. Les poids affinés remplacent ou complètent les poids du modèle de base, ce qui vous permet de déployer le modèle affiné à l’aide des mêmes outils (Ollama, LM Studio, llama.cpp), après conversion au format GGUF ou à tout autre format adapté à l’inférence.

Quel modèle de LLM local se rapproche le plus de la qualité de ChatGPT ?

Llama 3.1 70B approche la qualité de GPT-4 en matière de raisonnement et de suivi d’instructions, tandis que Llama 3.1 405B égale ou dépasse celle-ci sur de nombreux benchmarks. Pour une qualité équivalente à celle de GPT-3.5, Llama 3.1 8BPhi-3.5 14B, Mistral 7B ou Qwen 2.5 14B sont suffisants. Aucun modèle local ne reproduit intégralement le comportement de ChatGPT, car ce dernier utilise l’augmentation par récupération (retrieval augmentation), plusieurs modèles et un post-traitement ; toutefois, les capacités brutes des modèles sont désormais comparables à l’échelle 70B et au-delà.