Résumé de la configuration d’Ollama et du modèle Gemma 4 26B sur Mac mini (en date d’avril 2026)

(gist.github.com/greenstevester)

33 points par GN⁺ 2026-04-05 | 1 commentaires | Partager sur WhatsApp

Récapitulatif de la procédure pour configurer Ollama et les modèles Gemma 4 sur un Mac mini basé sur Apple Silicon, avec exécution automatique et maintien en mémoire
À l’aide de Homebrew, d’un Launch Agent et de variables d’environnement, le modèle est automatiquement chargé même après redémarrage, et le modèle 8B fonctionne de manière stable avec environ 9,6 Go de mémoire
Ollama v0.19 et plus prend en charge le backend MLX et le format NVFP4, améliorant les performances d’inférence sur les environnements Apple et NVIDIA
Le modèle 26B n’est pas recommandé en raison de son occupation mémoire élevée, tandis que le modèle 8B convient mieux à un usage réel
Via l’API locale, il est possible d’envoyer des requêtes Chat Completion compatibles OpenAI, ce qui est utile pour mettre en place un environnement de service LLM persistant sur Mac mini

Préparation

Un Mac mini basé sur Apple Silicon (M1 à M5) est nécessaire
Pour exécuter le modèle Gemma 4 (8B), il est recommandé d’avoir au minimum 16 Go de mémoire unifiée
Un environnement macOS avec Homebrew installé est requis

Étape 1 — Installer Ollama

Installer l’application macOS Ollama via le cask Homebrew
```
brew install --cask ollama-app
```
Après l’installation, Ollama.app est placé dans /Applications/ et la CLI dans /opt/homebrew/bin/ollama
Les mises à jour automatiques et le backend MLX sont inclus

Étape 2 — Lancer Ollama et vérifier

Lancer l’application Ollama
```
open -a Ollama
```
Attendre l’initialisation du serveur après l’apparition de l’icône dans la barre des menus
Vérifier l’état d’exécution
```
ollama list
```

Étape 3 — Télécharger le modèle Gemma 4

Télécharger le modèle
```
ollama pull gemma4
```
Vérifier avec ollama list après le téléchargement d’environ 9,6 Go
Le modèle 26B occupe la majeure partie des 24 Go de mémoire, ce qui entraîne une baisse de réactivité du système
- Il est recommandé d’utiliser le modèle 8B (quantification Q4_K_M) par défaut

Étape 4 — Tester le modèle et vérifier l’accélération GPU

Tester le modèle

ollama run gemma4:latest "Hello, what model are you?"

Vérifier l’état de l’accélération GPU
```
ollama ps
```
- Exemple : ratio CPU/GPU de 14 % / 86 %

Étape 5 — Configurer le lancement automatique et le maintien du modèle

5a. Lancement automatique de l’application Ollama
- Cliquer sur l’icône dans la barre des menus → activer Launch at Login
- Ou l’ajouter manuellement dans System Settings > General > Login Items
5b. Préchargement automatique de Gemma 4
- Créer un Launch Agent pour charger automatiquement le modèle après le démarrage d’Ollama et le maintenir actif toutes les 5 minutes
```
cat << 'EOF' > ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
...
EOF
```
- Charger l’agent
```
launchctl load ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
```
- Un prompt vide est envoyé toutes les 5 minutes pour garder le modèle en mémoire
5c. Maintenir le modèle indéfiniment
- Par défaut, le modèle est déchargé après 5 minutes d’inactivité
- Configuration pour le maintenir indéfiniment
```
launchctl setenv OLLAMA_KEEP_ALIVE "-1"
```
- Pour conserver ce réglage après redémarrage, l’ajouter à ~/.zshrc

Étape 6 — Vérifier la configuration

Vérifier que le serveur Ollama est en cours d’exécution
```
ollama list
```
Vérifier que le modèle est chargé en mémoire
```
ollama ps
```
Vérifier l’enregistrement du Launch Agent
```
launchctl list | grep ollama
```

Exemple de sortie attendue

gemma4:latest ... 9.6 GB 14%/86% CPU/GPU 4096 Forever

Accès API

Point d’accès de l’API locale : http://localhost:11434

Exemple de Chat Completion compatible OpenAI

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:latest",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Commandes utiles

Commande	Description
`ollama list`	Liste des modèles téléchargés
`ollama ps`	Modèles en cours d’exécution et utilisation mémoire
`ollama run gemma4:latest`	Exécution interactive
`ollama stop gemma4:latest`	Décharger le modèle
`ollama pull gemma4:latest`	Mettre à jour vers la dernière version
`ollama rm gemma4:latest`	Supprimer le modèle

Désinstaller Ollama et désactiver le lancement automatique

launchctl unload ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
rm ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
brew uninstall --cask ollama-app

Principales améliorations d’Ollama v0.19+ (31 mars 2026)

Backend MLX (Apple Silicon)
- Utilisation automatique du framework Apple MLX pour améliorer la vitesse d’inférence
- Les puces de la série M5 prennent en charge une accélération supplémentaire via le GPU Neural Accelerator
- Les puces M4 et antérieures bénéficient également d’une amélioration générale des performances grâce à MLX
Format NVFP4 (NVIDIA)
- Le format NVFP4 permet de réduire la bande passante mémoire et l’espace de stockage tout en conservant la précision
- Compatible avec les modèles générés par les outils d’optimisation de modèles NVIDIA
Améliorations du cache (codage et tâches d’agent)
- Réduction de l’utilisation mémoire : amélioration de l’efficacité grâce à la réutilisation du cache entre les conversations
- Checkpoints intelligents : réduction du traitement des prompts et amélioration de la vitesse de réponse
- Suppression intelligente du cache : meilleure efficacité pour les tâches branchées en conservant les préfixes communs

Notes complémentaires

Le modèle Gemma 4 (8B) utilise environ 9,6 Go de mémoire
- Sur un Mac mini 24 Go, il reste environ 14 Go disponibles
Le modèle 26B utilise environ 17 Go, ce qui provoque du swap système et une baisse de réactivité
- Le modèle 8B offre des performances stables

Liens de référence

1 commentaires

GN⁺ 2026-04-05

Commentaires sur Hacker News

Si c’est la première fois que vous utilisez un modèle open weight juste après sa sortie, il faut savoir qu’il y a toujours des bugs dans les premières implémentations et dans la quantification (quantization)
Comme chaque projet se dépêche d’ajouter le support pour le jour du lancement, les résultats peuvent être incorrects
Plusieurs problèmes ont déjà été repérés dans l’implémentation du tokenizer, et la quantification utilisant imatrix peut aussi poser problème
Au cours des prochaines semaines, on verra beaucoup de messages du genre « l’appel d’outils ne marche pas donc le modèle est nul ». En réalité, ce seront surtout des gens qui utilisent des implémentations cassées
Si vous voulez utiliser des modèles cutting-edge, il faut être prêt à mettre à jour souvent le moteur d’inférence et à retélécharger les versions quantifiées à chaque changement
La concurrence pour sortir le support dès le jour J fait qu’on est souvent sur une logique de « on déploie dès que les tokens sortent », et la validation de l’exactitude vient après
- Je me demande quel inference engine il faut utiliser sur Linux avec une 4090
  Je rencontre souvent des problèmes d’appel d’outils, mais je ne sais pas si ça vient du modèle ou d’ollama
J’hésite à acheter un Mac mini pour faire tourner des modèles en local
J’utilise surtout Claude pour le développement et des projets homelab, et j’aimerais savoir si les modèles ouverts sont vraiment utilisables à ce niveau, ou s’il vaut mieux garder l’abonnement à 20 dollars par mois
- Pour de petites tâches, ça va, mais si vous voulez l’utiliser comme Claude, vous risquez d’être déçu
  Avant d’acheter du matériel et d’héberger vous-même, je recommande d’essayer d’abord via un service hébergé. Ça permet de sentir les limites du modèle à l’avance
- J’utilise des modèles ouverts depuis la fuite de llama. Ça s’améliore progressivement, et c’est génial de pouvoir faire tourner en local, sans Internet, un gros bloc de connaissances
  Mais il faut garder des attentes modestes. Peu importe ce que disent les benchmarks, ça ne se compare pas à Sonnet ou Opus
- Le mieux est de tester directement avec seulement 10 dollars de crédits OpenRouter. D’après mon expérience, c’est encore très en dessous, mais c’est amusant d’aller voir de temps en temps
- gpt-oss-20B avait des performances d’agent plutôt correctes, mais ça reste incomparable avec les modèles payants de Claude Code. J’ai entendu dire que la version 120B est bien meilleure
J’ai testé avec un MacBook Pro M4 (36GB) dans LM Studio avec le frontend open code, mais l’appel d’outils échouait en permanence, donc je suis revenu à qwen
Je me demande si quelqu’un a réussi dans une configuration similaire
- Les échecs d’appel d’outils viennent de l’implémentation du moteur d’inférence ou de la quantification. Je recommande de réessayer dans quelques jours après les mises à jour. C’est le genre de chose qui arrive à chaque sortie de modèle ouvert
- Sur un M5 (32GB), LM Studio faisait carrément planter mon ordinateur et j’ai dû redémarrer
  En revanche, gemma-4-26B-A4B-it-GGUF:Q4_K_M tournait bien dans llama.cpp. La vitesse (38 tokens par seconde) et la qualité étaient toutes deux impressionnantes
- J’ai eu le même problème. Dans la version Q_8 de LM Studio, il entrait dans un mode boucle où il répétait les commandes sans fin
- D’après d’autres personnes, il faut mettre à jour à la fois la version principale et la version runtime
- J’ai aussi constaté l’échec de l’appel d’outils sur un serveur Ubuntu (charmbracelet/crush)
Je cherche un modèle ouvert capable de remplacer Claude Sonnet 4.5
Je me demande s’il existe un remplaçant valable parmi les modèles de Ollama Cloud ou OpenRouter.ai
J’aimerais entendre des retours d’usage réels de développeurs plutôt que des benchmarks
- En pratique, il n’existe aucun modèle qui remplace vraiment Sonnet et Opus. La famille GPT Codex reste excellente elle aussi
  J’ai essayé MiniMax, GLM, Qwen, Kimi, etc., mais sur les tâches complexes, ils montrent tous de grosses limites
- J’ai l’impression que GLM5 et KimiK2.5 sont des alternatives assez proches de Sonnet
Je me demande si quelqu’un l’a fait tourner sur un M5 Air (32GB, 10 cœurs) avec un build oMLX, et si l’appel d’outils fonctionne aussi
- La release v0.3.2 est en support partiel. La génération de texte fonctionne, mais le traitement des tokens spéciaux n’est pas terminé
  De mon côté, je suis en train de tester l’ajout de l’appel d’outils et du support du thinking <|channel>
- J’ai entendu dire que quelqu’un avait lancé Gemma 4 E4B sur MLX (lien)
C’est étrange que les étapes pour « Gemma 4 12B » passent au milieu à 26B
Et dans ollama ps, l’affichage « 14%/86% CPU/GPU » ne veut-il pas dire que les performances GPU sont mauvaises ?
- Le Mac mini a une mémoire partagée entre CPU et GPU, donc ce ratio peut sans doute être ignoré
Faire tourner un modèle 26B en local est impressionnant, mais la latence est élevée, ce qui le rend difficile à utiliser pour autre chose que du chat
Nous avons remplacé des tâches de génération d’images en inférence locale par des appels API. Le cold start et le temps de génération étaient trop longs
Le local est bien pour expérimenter, mais pour des workloads de production nécessitant une exécution à heure fixe, les API gardent l’avantage
En revanche, pour des données sensibles sur le plan de la confidentialité, un setup local est très utile
Je me demande pourquoi autant de gens utilisent Ollama. Je l’ai essayé et j’ai trouvé que c’était trop simplifié
En ce moment, Unsloth Studio me semble être un meilleur choix par défaut pour les débutants
- Ollama est accessible parce qu’une simple commande ollama pull suffit pour récupérer un modèle
  Il n’y a pas toute la complexité de devoir chercher soi-même le nom exact du modèle et sa version sur Hugging Face
  Mais dès qu’on veut aller plus loin, il faut quand même apprendre l’architecture serveur
- Ollama a eu un first-mover advantage au début. À l’époque, compiler llama.cpp soi-même était une barrière
  Aujourd’hui, je recommande plutôt LM Studio. Je suis curieux de savoir ce qu’Unsloth Studio fait différemment
- Je ne sais pas pourquoi les gens mentionnent moins LMStudio. J’ai migré il y a quelques mois et je trouve ça bien meilleur
- La popularité d’Ollama vient de l’effet pub. Ils en ont fait la promotion sur Reddit, Discord et ailleurs comme étant « le frontend facile de llama.cpp »
  Pour vraiment gagner, il faut supprimer Ollama et passer directement à llama.cpp
- Moi, je poserais plutôt la question inverse — qu’est-ce qui ne va pas avec Ollama ?
  Ça tourne très bien même avec un GPU de 16GB, et c’est largement suffisant comme backend pour expérimenter avec d’autres frontends
Je me demande si ce modèle peut être utilisé pour coder en local, et quels IDE ou harness sont compatibles
- La plupart des harness permettent de coder en local à partir du moment où l’on indique un endpoint API compatible OpenAI
  En revanche, la dernière version de Codex a des problèmes de compatibilité API avec llama.cpp
  Moi, je préfère Pi. C’est minimaliste et extensible. Claude Code ou OpenCode sont aussi beaucoup utilisés
- Il faut que l’appel d’outils soit pris en charge, et beaucoup de quantifications gguf ne le prennent pas en charge
  Pour contourner ça, j’ai créé un proxy appelé Petsitter, qui émule ces fonctionnalités entre le moteur d’inférence et le harness
  Lien GitHub
  Il suffit de mettre Petsitter au-dessus d’Ollama, puis de brancher le harness d’agent au-dessus
  La dernière version d’Ollama prend déjà en charge "completion", "vision", "audio", "tools", "thinking"
La nuit dernière, il fallait installer la préversion Ollama v0.20 pour pouvoir utiliser ce modèle. Du coup, je me demande si le guide actuel est vraiment exact