Ollama GPT OSS : exécuter localement des LLM open source (guide)

Si vous avez recherché « ollama gpt oss », vous souhaitez probablement exécuter localement des grands modèles linguistiques open source à l’aide d’Ollama — or OpenAI n’a pas publié de famille de modèles à poids ouverts baptisée « GPT-OSS ». OpenAI a certes rendu GPT-2 à poids ouverts en 2019, mais ses modèles récents (GPT-4, GPT-4o, GPT-4.1) restent des produits propriétaires accessibles uniquement via API. En revanche, ce qui ne existe bel et bien : des centaines de modèles à poids ouverts provenant de Meta (Llama), Mistral AI, Alibaba (Qwen) et d’autres éditeurs, que vous pouvez télécharger et exécuter via Ollama sur votre propre matériel. Ce guide présente les modèles compatibles, les besoins en VRAM selon leur taille, l’impact de la quantification sur la qualité, ainsi que leurs comparatifs respectifs.

Ce qu’Ollama exécute réellement

Ollama est un moteur d’inférence local qui télécharge, quantifie et exécute des LLM à poids ouverts sur macOS, Linux et Windows. Il ne prend pas en charge les modèles d’OpenAI. Le Liste des modèles Ollama inclut notamment Llama 3.1, Mistral 7BMistral, Qwen 2.5, Gemma 2, Phi-3 et des dizaines d’autres modèles. Chacun est disponible dans plusieurs niveaux de quantification (Q4_K_M, Q5_K_M, FP16) afin de faire un compromis entre consommation de VRAM et qualité.

Étapes complètes d’installation : comment installer Ollama.

Familles de modèles open source disponibles dans Ollama

Le Base de données des modèles IA répertorie les caractéristiques techniques, les besoins en VRAM et les tarifs de 37 modèles, y compris tous ceux cités ci-dessus.

Téléchargement et exécution d’un modèle

Une fois Ollama installé, téléchargez un modèle à l’aide de la commande ollama pull <modèle>:<étiquette>. L’étiquette précise le nombre de paramètres et le niveau de quantification. Exemples :

ollama pull llama3.1:8b
ollama pull mistral:7b-instruct-q4_K_M
ollama pull qwen2.5:7b
ollama pull gemma2:9b

Exécutez ensuite le modèle :

ollama run llama3.1:8b

Cela ouvre une session de discussion interactive. Saisissez votre demande, appuyez sur Entrée, et le modèle génère une réponse localement. Pour quitter, saisissez /bye.

Pour utiliser le modèle par programmation via l’API :

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Expliquez la récursion en une phrase."
}'

Ollama expose un point de terminaison /v1/chat/completions compatible avec l’API OpenAI, ce qui vous permet de rediriger facilement un code existant utilisant les SDK OpenAI vers http://localhost:11434 et d’y substituer un modèle local.

Taille des paramètres et besoins en VRAM

La taille du modèle (7B, 13B, 70B) détermine à la fois sa qualité et son empreinte mémoire en VRAM. Les modèles plus volumineux offrent de meilleures capacités de raisonnement, mais exigent davantage de mémoire GPU. La quantification (Q4, Q5, FP16) compresse les poids afin de réduire la consommation de VRAM, avec une légère perte de qualité.

Utilisez le Calculateur de VRAM pour estimer les besoins en mémoire pour n'importe quel modèle et niveau de quantification. Le Guide des exigences en VRAM répertorie des valeurs précises pour tous les modèles majeurs.

Pour les décisions d'achat de GPU, consultez meilleurs GPU pour exécuter localement des LLM.

Quantification : compromis entre qualité et VRAM

La quantification réduit la précision des poids d’un modèle, passant des flottants 16 bits (FP16) à des entiers 4 ou 5 bits (Q4, Q5). Cela permet de réduire la consommation de VRAM de 60 à 75 %, avec une perte de qualité minimale pour la plupart des tâches.

• Q4_K_M: Quantification sur 4 bits. Consommation minimale de VRAM, légère dégradation de la qualité sur les tâches complexes de raisonnement. Idéal pour les chatbots, la synthèse ou la complétion de code.
• Q5_K_M: Quantification sur 5 bits. Environ 20 % de VRAM supplémentaire par rapport à Q4, qualité proche de celle de FP16. Meilleur compromis pour la plupart des utilisateurs.
• Q8_0: Quantification sur 8 bits. Qualité quasi identique à celle de FP16, réduction de 50 % de la VRAM. À utiliser uniquement si vous disposez d’une marge suffisante de VRAM.
• FP16: Précision intégrale. Qualité optimale, mais consommation de VRAM doublée par rapport à Q4. Réservé à la recherche ou lorsque toute régression de qualité est inacceptable.

Exemple : Llama 3.1 8B à la quantification Q4_K_M utilise 4,5 Go de VRAM et obtient un score de 67,2 sur MMLU. En FP16, il utilise 14 Go et obtient un score de 68,1 sur MMLU. Pour la plupart des tâches, cette différence de 0,9 point est imperceptible.

Pour télécharger une quantification spécifique :

ollama pull llama3.1:8b-instruct-q4_K_M
ollama pull llama3.1:8b-instruct-fp16

Si vous omettez l’indicateur de quantification, Ollama utilise par défaut Q4_K_M.

Comparatif de performances pour les modèles de classe 7B

La classe de taille 7B–8B est la plus populaire pour une utilisation locale. Elle s’adapte aux GPU grand public et fournit d’excellents résultats en programmation, raisonnement et conversation.

Qwen 2.5 7B et Gemma 2 9B obtiennent les meilleurs scores sur MMLU (connaissances générales). Llama 3.1 8B domine sur HumanEval (programmation). Mistral 7B offre les performances d’inférence les plus rapides et la licence la plus permissive (Apache 2.0). Le Classement des grands modèles linguistiques (LLM) classe tous les modèles selon leur intelligence, leur coût et leur longueur de contexte.

Quel modèle choisir ?

• Meilleure qualité globale (classe 7B): ollama pull qwen2.5:7b ou ollama pull llama3.1:8b
• Meilleur pour la programmation: ollama pull llama3.1:8b ou ollama pull qwen2.5-coder:7b
• Inférence la plus rapide: ollama pull mistral:7b ou ollama pull gemma2:2b (pour CPU/faible VRAM)
• Multilingue: ollama pull qwen2.5:7b (prend en charge 29 langues)
• Documents longs (contexte ≥ 128 k): ollama pull llama3.1:8b ou ollama pull qwen2.5:7b
• Raisonnement le plus puissant (si vous disposez de 40 Go de VRAM ou plus): ollama pull llama3.1:70b ou ollama pull qwen2.5:72b

Le les meilleurs LLM locaux pour Ollama guide évalue systématiquement tous les modèles et recommande des indicateurs spécifiques selon les cas d’usage.

Quand héberger soi-même plutôt que recourir à une API ?

Exécuter Ollama localement est pertinent si :

• Vous possédez déjà un GPU doté d’au moins 12 Go de VRAM (RTX 3060, 4060 Ti ou supérieur)
• Vous traitez des données sensibles qui ne doivent pas quitter votre réseau
• Vous générez plus de 5 millions de jetons par mois (les coûts liés aux API dépassent le coût total de possession d’une solution auto-hébergée)
• Vous exigez une disponibilité garantie et aucune limitation de débit

Utilisez une API hébergée (OpenAI, Anthropic, Groq) si :

• Vous générez moins de 1 million de jetons par mois (l’amortissement d’un GPU auto-hébergé prend plusieurs années)
• Vous avez besoin de la qualité absolue (Claude 3.5 Sonnet et GPT-4o surpassent tous les modèles open source)
• Vous ne souhaitez pas gérer l’infrastructure d’inférence

Le calculateur auto-hébergement vs API estime le seuil de rentabilité en fonction de votre volume de jetons, du coût du GPU et du tarif de l’électricité. Le Calculateur de coûts d’API projette la dépense mensuelle par modèle.

Remarques spécifiques aux plateformes

macOS

Ollama utilise Metal pour l’accélération GPU sur les Mac équipés de puces M1/M2/M3. La mémoire unifiée signifie que la VRAM équivaut à la mémoire système. Un Mac M2 Max doté de 64 Go peut exécuter Llama 3.1 70B en quantification Q4 (40 Go) tout en laissant suffisamment de mémoire pour le système d’exploitation. Installez-le via Homebrew :

brew install ollama

Démarrez le service :

ollama serve

Linux

Ollama nécessite des GPU NVIDIA compatibles CUDA 11.8+ ou des GPU AMD compatibles ROCm 5.7+. Installez-le avec :

curl -fsSL https://ollama.com/install.sh | sh

Cette commande installe le binaire dans , puis supprimez et crée un service systemd. Démarrez-le avec :

sudo systemctl start ollama

Les modèles sont téléchargés dans ~/.ollama/models. Pour modifier cet emplacement, définissez la variable d’environnement OLLAMA_MODELS=/chemin/vers/les/modeles le fichier , puis d’exécuter.

Windows

La version Windows d’Ollama requiert des GPU NVIDIA compatibles CUDA 11.8+ et un pilote version 520 ou supérieure. Téléchargez l’installateur depuis ollama.com et exécutez-le. Le service démarre automatiquement. Les modèles sont téléchargés dans C:Utilisateurs<VotreNom>.ollamamodels.

Pour l’exécuter depuis PowerShell :

ollama run llama3.1:8b

Questions fréquemment posées

OpenAI propose-t-il un modèle open source que je peux exécuter dans Ollama ?

Non. OpenAI a publié GPT-2 (2019) en tant que modèle à poids ouverts, mais tous ses modèles récents (GPT-3.5, GPT-4, GPT-4o, o1) sont propriétaires et accessibles uniquement via leur API. Si vous recherchez une capacité de raisonnement locale comparable à celle d’OpenAI, essayez Llama 3.1 70B ou Qwen 2.5 72B — ces deux modèles surpassent GPT-3.5 sur la plupart des benchmarks et s’exécutent dans Ollama avec 40 Go de VRAM en quantification Q4.

Puis-je exécuter Ollama sur un processeur (CPU) sans GPU ?

Oui, mais l’inférence est 10 à 50 fois plus lente. De petits modèles (Gemma 2 2B, Qwen 2.5 0.5B, Phi-3.5 mini 3.8B) restent utilisables sur des processeurs modernes (16 cœurs ou plus). Les modèles plus volumineux (7 milliards de paramètres ou plus) génèrent seulement 1 à 3 jetons par seconde sur CPU, ce qui est trop lent pour une utilisation interactive. Si vous ne disposez pas de GPU, envisagez plutôt d’utiliser une API hébergée — consultez la section calculateur auto-hébergement vs API.

Quel est le coût d’exécution d’Ollama comparé à celui de l’API OpenAI ?

OpenAI facture 0,15 $ par million de jetons d’entrée et 0,60 $ par million de jetons de sortie pour GPT-4o mini. Un GPU de 12 Go (RTX 4060 Ti, 400 $) exécutant Llama 3.1 8B coûte environ 0,05 $/heure en électricité (avec un tarif de 0,12 $/kWh et une consommation système de 400 W). Le seuil de rentabilité se situe autour de 3 à 5 millions de jetons par mois. La Calculateur de coûts d’API et calculatrice d’auto-hébergement affiche le coût total de possession (TCO) exact pour votre cas d’usage.

Quelle est la différence entre Q4_K_M, Q5_K_M et FP16 ?

Q4_K_M utilise une quantification 4 bits (consommation minimale de VRAM, légère perte de qualité). Q5_K_M utilise une quantification 5 bits (20 % de VRAM supplémentaire, qualité proche de la précision complète). FP16 correspond à une précision pleine sur 16 bits (qualité optimale, mais consommation de VRAM doublée par rapport à Q4). Pour la plupart des tâches, Q5_K_M offre le meilleur compromis. N’utilisez FP16 que si vous disposez de VRAM excédentaire et que vous avez besoin des derniers 1 à 2 % de qualité, par exemple pour la recherche ou des applications critiques.

Puis-je affiner (fine-tune) des modèles dans Ollama ?

Non. Ollama est un moteur d’inférence, pas un cadre d’entraînement. Pour affiner un modèle open source, utilisez Hugging Face Transformers avec PEFT/LoRA, Axolotl ou LLaMA Factory. Exportez ensuite les poids affinés au format GGUF et importez-les dans Ollama à l’aide de la commande ollama create. Le bloc Guide complet d’Ollama détaille ce flux de travail.

Quel GPU devrais-je acheter pour exécuter localement des modèles de 7 milliards de paramètres ?

Pour une quantification Q4 (4,5 Go de VRAM) : RTX 3060 12 Go (250 $ d’occasion) ou RTX 4060 Ti 16 Go (450 $ neuf). Pour une précision FP16 (14 Go de VRAM) : RTX 4060 Ti 16 Go ou RTX 4070 (550–600 $). Pour des modèles de 70 milliards de paramètres en Q4 (40 Go) : deux RTX 3090 24 Go (1 800 $ d’occasion) ou une A100 40 Go (6 000 $ ou plus, d’occasion). Le guide des meilleurs GPU présente des benchmarks comparatifs prix/performance pour chaque catégorie de taille.