SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor · Mis à jour le 2026-10-26

Quelle RAM pour Muse Glimmer 30B sur un VPS ?

Les tags Linux de Muse Glimmer vont de 18 à 59 Go. Vérifiez la RAM et le disque nécessaires sur votre VPS, puis estimez le coût de l’inférence CPU seule.

Ce dont Muse Glimmer a besoin sur un VPS

Muse Glimmer fonctionne sur un VPS Linux standard sans GPU. Le tag que vous téléchargez détermine s’il tient en mémoire. Meta Superintelligence Labs a publié le modèle le 10 August 2026 sous licence Apache 2.0 : 30 billion paramètres, une fenêtre de contexte de 128K et un encoder de perception dédié de 1.8B paramètres, afin qu’il puisse lire des images en plus du texte. Meta le destine à des agents locaux toujours actifs plutôt qu’au chat, avec un niveau de raisonnement que vous définissez pour chaque requête.

Les tags Ollama publiés qui fonctionnent sous Linux, tels qu’ils étaient disponibles le 25 October 2026, vont de 18 GB à 59 GB. Cette plage constitue tout le problème de dimensionnement. La liste complète des tags commence plus bas et se termine plus haut, à 17 GB et 65 GB, mais ces deux extrêmes correspondent à des tags MLX conçus pour Apple Silicon. Ils ne comptent donc pas sur un serveur Linux. Le tag par défaut est indiqué à environ 18 GB. Le plus petit serveur raisonnable doit donc disposer clairement de plus de 18 GB de RAM libre. Il faut ajouter l’espace disque nécessaire au téléchargement et la mémoire requise par la fenêtre de contexte.

Quel tag muse-glimmer devez-vous télécharger ?

GraphiquePublished muse-glimmer tag sizes on 25 October 2026 (Linux tags only)
Les données de ce graphique
[
  {
    "label": "30b (default)",
    "size_gb": 18
  },
  {
    "label": "30b-q4_K_M",
    "size_gb": 18
  },
  {
    "label": "30b-q4_K_M-dflash",
    "size_gb": 20
  },
  {
    "label": "30b-q8_0",
    "size_gb": 31
  },
  {
    "label": "30b-q8_0-dflash",
    "size_gb": 33
  },
  {
    "label": "30b-bf16",
    "size_gb": 57
  },
  {
    "label": "30b-bf16-dflash",
    "size_gb": 59
  }
]

Ollama répertorie 7 tags pour ce modèle sans le label MLX, sans compter l’alias latest. Les tags simples contiennent les mêmes 30 milliards de poids, stockés avec différentes précisions numériques. Les tags -dflash contiennent ces poids ainsi qu’un second réseau plus petit, présenté ci-dessous. C’est pourquoi chacun est affiché avec une taille supérieure à celle de son équivalent simple. La taille indiquée correspond à ce que vous téléchargez. Elle représente aussi approximativement la quantité de mémoire à prévoir avant l’ajout du contexte.

Le build 4 bits est le plus petit : 30b-q4_K_M à 18 Go. Le tag 30b par défaut désigne le même build sous un autre nom, avec le même digest sur la page du tag. Le build 8 bits est 30b-q8_0, à 31 Go. 30b-bf16 est la release non quantifiée en 16 bits, à 57 Go. Elle nécessite plus de RAM que la plupart des serveurs loués ne peuvent en fournir à un prix acceptable pour un projet personnel. Le tag 30b-nvfp4 de 17 Go, plus petit sur le papier, ainsi que le tag 30b-mxfp8 en 8 bits de 33 Go portent tous deux le label MLX. Ils sont donc exclus du tableau. La section suivante explique pourquoi.

Les tags -dflash ajoutent le drafter DFlash de Meta. La model card le décrit comme « un petit réseau compagnon qui propose des blocs entiers de tokens à la fois » : 5 couches de draft qui prédisent des blocs de 16 tokens. Il s’agit d’une fonction d’accélération du speculative decoding. La page du modèle Ollama présente la prise en charge de DFlash comme une fonction de son moteur MLX sur Apple Silicon. Sur un VPS limité au CPU, elle consomme environ 2 Go de mémoire réelle supplémentaire pour un drafter dont vous n’avez pas mesuré le gain sur votre matériel. Commencez donc avec le tag simple et ne modifiez qu’un seul paramètre à la fois.

Commencez avec le 4 bits, sauf raison précise de faire autrement. Passer de 4 bits à 8 bits double approximativement le nombre d’octets que le CPU doit lire pour chaque token généré. Le débit diminue donc tandis que l’utilisation mémoire augmente. Cette question est abordée dans ce que les quantifications q4, q8 et fp16 vous coûtent réellement. Sur une machine avec CPU, la réponse courte est que le build 4 bits est le seul avec lequel il est utile de commencer.

Pourquoi les tags MLX ne servent à rien sur un serveur Linux

MLX est le framework de tableaux d’Apple. Le moteur MLX d’Ollama est son backend pour Apple Silicon. Lorsqu’Ollama l’a annoncé, la consigne était de « vérifier que vous disposez d’un Mac avec plus de 32GB de mémoire unifiée ». Chaque tag identifié comme MLX sur la page des tags est destiné à ce moteur et à ce matériel. Le label ne figure pas toujours dans le nom : pour ce modèle, il concerne 30b-nvfp4, 30b-mxfp8 et leurs variantes -dflash, ainsi que tous les tags qui contiennent mlx. Sur un VPS Linux x86, chacun représente plusieurs dizaines de gigaoctets à télécharger sans pouvoir être exécuté. Il occupera donc votre disque sans servir. Les performances mesurées sur un Mac correspondent à ces tags et ne décrivent pas non plus votre serveur. Lorsque vous consultez la liste des tags sur la page du modèle, excluez d’abord tous ceux portant le label MLX, puis dimensionnez votre installation à partir des tags restants.

De quelle quantité de RAM et d’espace disque a-t-il réellement besoin ?

Deux éléments consomment de la mémoire, et un seul dépend de la taille du tag. Les poids sont fixés par le tag que vous téléchargez. Le cache KV, c’est-à-dire l’état par token que le modèle conserve pour la conversation, augmente avec la longueur du contexte que vous configurez. La documentation d’Ollama précise que le traitement de requêtes en parallèle multiplie le contexte par le nombre de requêtes en cours. Une machine qui répond à deux agents simultanément a donc besoin de plus de mémoire que la même machine qui n’en gère qu’un.

Ne vous fiez pas à une quantité de RAM indiquée dans un guide, y compris celui-ci. Téléchargez le tag, envoyez-lui un prompt, puis, tant que le modèle est encore résident en mémoire, exécutez ces deux commandes.

ollama ps
free -h

ollama ps indique ce qui est chargé actuellement et la répartition du travail entre le CPU et le GPU. free -h indique ce qui reste disponible. Ces deux sorties obtenues sur votre propre machine sont plus fiables que n’importe quel tableau publié, car elles prennent déjà en compte votre configuration du contexte, votre quantification et tout ce que le serveur exécute par ailleurs.

Le disque est plus simple à évaluer. Sous Linux, Ollama stocke les modèles dans /usr/share/ollama/.ollama/models, qui se trouve sur le système de fichiers racine de la plupart des images VPS. Un volume racine de 40GB ne pourra pas contenir la version bf16 de 57 GB. Il ne pourra pas non plus contenir simultanément les versions 8-bit et 4-bit. Si vous n’avez jamais vérifié ce qu’un pull écrit réellement, où Ollama stocke les modèles et comment déplacer ce stockage décrit ce répertoire. Déplacez le stockage vers un volume monté avant de télécharger quoi que ce soit.

sudo systemctl edit ollama
[Service]
Environment="OLLAMA_MODELS=/mnt/models"
sudo mkdir -p /mnt/models
sudo chown -R ollama:ollama /mnt/models
sudo systemctl daemon-reload
sudo systemctl restart ollama

L’utilisateur ollama doit être propriétaire de ce répertoire, car le service s’exécute sous l’utilisateur ollama et y écrit lui-même ses blobs. Si un pull échoue à cause des permissions, journalctl -u ollama -n 50 en indique la raison.

Pour le swap, retenez ceci : le swap ne permet pas d’exécuter un tag plus volumineux. La génération accède aux poids pour chaque token produit. Les poids présents dans le swap sont donc relus sur le disque en permanence, vmstat 1 affiche des colonnes si et so très sollicitées, et la sortie ralentit jusqu’à plusieurs secondes par token. Conservez un petit fichier swap pour éviter l’intervention de l’out of memory killer. Dimensionnez la RAM en fonction du tag que vous souhaitez réellement utiliser.

Installer Ollama et figer un tag nommé

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

Le script d’installation configure un service systemd. Le serveur redémarre donc automatiquement après un reboot. Si vous préférez ne pas l’exécuter comme service système géré par root, exécuter Ollama sans privilèges root avec Podman présente cette méthode. Effectuez ensuite un pull avec un tag explicite.

ollama pull muse-glimmer:30b
ollama list

Lisez vous-même la colonne de taille dans ollama list et comparez-la à la liste actuelle des tags sur la page du modèle. Des tags publiés sont ajoutés, renommés et supprimés. La taille indiquée dans un guide correspond à un instant donné.

N’écrivez jamais ollama pull muse-glimmer sur un serveur dont vous dépendez. Un nom de modèle sans tag utilise le tag latest, et latest est un pointeur que l’éditeur peut déplacer vers un autre build. Un pull habituel remplace alors le modèle utilisé par votre agent, avec des besoins mémoire et un comportement différents, sans qu’aucun message de vos journaux ne l’indique. Écrivez le tag dans vos scripts, vos unit files et la configuration de votre agent. Auto-héberger un LLM avec Ollama sur un VPS présente le reste de la configuration du serveur.

Pouvez-vous exécuter Muse Glimmer sans GPU ?

Oui, mais il faut être clair sur la limite. Générer un token consiste à lire les poids du modèle depuis la mémoire. La vitesse dépend donc de la bande passante mémoire, et non du nombre de vCPU annoncé par l’offre. Au-delà de quelques cœurs, ajouter des cœurs apporte très peu. Sur un VPS partagé, cette bande passante est partagée avec tous les autres clients de l’hôte. Un modèle de 30B en 4-bit produit donc un petit nombre de tokens par seconde.

Ne prenez le chiffre de personne pour argent comptant, y compris le mien. Mesurez le nombre de tokens par seconde sur votre propre serveur et faites votre choix à partir du résultat.

Le modèle présente alors une différence nette entre ses usages. Le chat interactif est pénible, car vous lisez plus vite que le serveur n’écrit et chaque réponse commence par une longue pause. Les tâches d’agent exécutées en arrière-plan conviennent mieux : une tâche qui s’exécute sans surveillance pendant dix minutes n’est pas gênée par sa lenteur. C’est précisément le type de charge que Meta décrit pour ce modèle.

Si vous avez besoin d’une réponse interactive rapide, les deux solutions honnêtes sont un GPU ou une API hébergée. Calculez le seuil de rentabilité entre un GPU VPS et des tokens d’API avant de louer quoi que ce soit, et ce qu’un GPU VPS vous apporte réellement décrit ce que vous achetez. Pour déterminer ce qu’un serveur donné peut héberger, commencez par les modèles que vous pouvez auto-héberger, puis consultez exécuter un modèle Qwen de taille similaire sur un VPS, qui constitue la comparaison la plus proche dans cette catégorie de taille. Si les mesures obtenues sont trop lentes pour être utilisables, Nemotron 3.5 Lightning sur un VPS pose les mêmes questions de RAM et de tokens par seconde pour un modèle conçu pour la vitesse plutôt que pour la taille.

Pourquoi oublie-t-il des éléments bien avant 128K tokens ?

Sur une machine sans GPU, la fenêtre de contexte par défaut d’Ollama est de 4096 tokens, quelle que soit la capacité prise en charge par le modèle. La FAQ d’Ollama indique cette valeur par défaut de 4096, et sa documentation sur la longueur du contexte, consultée le 25 octobre 2026, adapte cette valeur à la mémoire du GPU : 4k avec moins de 24 GiB de VRAM, 32k de 24 à 48 GiB, et 256k avec au moins 48 GiB. Un VPS limité au CPU se trouve dans la première catégorie. Le tag annonce 128K, mais le serveur fournit au modèle une fenêtre de 4096 jusqu’à ce que vous la configuriez. Une longue transcription d’agent perd donc ses premiers échanges, et le modèle donne l’impression d’avoir des trous de mémoire.

Augmentez cette valeur côté serveur pour chaque requête :

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=32768"

Dans une session interactive, /set parameter num_ctx 32768 modifie cette valeur uniquement pour la session en cours. Avec l’API, envoyez num_ctx dans les options de la requête.

Chaque token de contexte supplémentaire consomme de la mémoire en plus des poids du modèle. Demander les 128K complets sur une machine dimensionnée uniquement pour les poids peut faire échouer le chargement ou provoquer un basculement vers un fonctionnement plus lent. Augmentez la valeur par paliers et exécutez ollama ps après chaque palier. Fonctionnement de num_ctx et de la longueur du contexte dans Ollama présente les calculs en détail.

Niveau de raisonnement : low, medium, high et xhigh

Meta documente quatre niveaux de raisonnement pour Muse Glimmer, de low à xhigh, et recommande les deux niveaux supérieurs pour les tâches complexes de codage et d’agent. Dans Ollama, ce réglage passe par le paramètre think. Utilisez --think= sur la ligne de commande ou envoyez think dans le corps de la requête API.

ollama run muse-glimmer:30b --think=high "Summarise the changes in /tmp/patch.diff"

Dans une session interactive, /set think et /set nothink permettent de l’activer ou de le désactiver. La documentation d’Ollama sur le thinking, consultée le 25 October 2026, indique d’utiliser /api/show pour connaître les valeurs prises en charge par un modèle. Un modèle qui expose des métadonnées de thinking les répertorie sous thinking.values : il peut s’agir de valeurs booléennes pour un contrôle marche/arrêt ou de noms définis par le modèle pour les différents niveaux. La documentation indique d’utiliser exactement la valeur qui y figure. Tous les modèles ne publient pas cette liste : si thinking est absent de la réponse, le modèle ne fournit pas de métadonnées de thinking. La même page précise qu’un nom non pris en charge revient au réglage par défaut du modèle. Une faute de frappe dans le niveau ne génère donc pas d’erreur : le modèle s’exécute simplement et discrètement avec le réglage par défaut. L’aide de la ligne de commande ne mentionne que true, false, high, medium et low, et transmet toute autre chaîne au serveur sans la vérifier. Consultez donc la valeur renvoyée par /api/show pour muse-glimmer:30b au lieu de deviner, puis testez-la manuellement avant de l’intégrer à un agent.

Sur une machine équipée uniquement d’un CPU, ce réglage a un effet direct. Un niveau supérieur entraîne la génération d’un plus grand nombre de tokens de raisonnement avant l’affichage du premier mot de la réponse. Un token de raisonnement demande le même temps d’exécution qu’un token de réponse. Réservez le niveau low aux tâches courantes. La longueur de la réponse demande la même attention. Utilisez donc limiter la réponse avec num_predict au lieu de laisser une réponse trop longue monopoliser une machine lente pendant plusieurs minutes.

Garder le modèle chargé pour un agent toujours actif

Par défaut, Ollama décharge un modèle inactif après cinq minutes. Pour un agent exécuté toutes les dix minutes, cela signifie recharger 18 Go depuis le disque à chaque exécution. Sur un VPS avec un stockage réseau, ce chargement n’est pas rapide. Maintenez plutôt le modèle en mémoire.

[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"

Une valeur négative maintient le modèle en mémoire jusqu’à ce qu’un déchargement soit effectué, et keep_alive dans une requête d’API remplace la valeur par défaut du serveur pour cet appel uniquement. Le coût est réel : la RAM reste occupée lorsqu’aucune tâche ne s’exécute. Ce réglage convient donc à une machine dédiée à l’agent. Garder un modèle Ollama chargé présente les différentes variantes.

Configurer un agent de programmation

Ollama fournit une API compatible avec OpenAI à l’adresse http://127.0.0.1:11434/v1. La plupart des outils d’agent s’y connectent avec une URL de base et une clé API non vide. La page Muse Glimmer d’Ollama documente également un raccourci de lancement qui relie un agent compatible à un modèle local en une seule commande. Vous devez aussi y définir le tag.

ollama launch claude --model muse-glimmer:30b

Les agents envoient des prompts volumineux. Le contenu des fichiers, la sortie des outils et la transcription qui s’allonge sont autant de tokens d’entrée. Sur une machine équipée seulement d’un CPU, le traitement du prompt est la partie la plus coûteuse, avant même le début de la génération. Définissez le contexte à la taille minimale compatible avec la tâche. Configurer un agent de programmation avec Ollama couvre la configuration côté client, exécuter un agent de programmation sur un VPS couvre la machine qui l’héberge, et maîtriser les coûts d’un agent sur un VPS explique ce qui se passe lorsqu’il fonctionne toute la journée.

L’entrée d’images fonctionne de la même manière. L’API Ollama accepte les images dans le champ images d’un message. Un client limité au texte n’en enverra donc jamais, quelle que soit la capacité de l’encodeur de perception.

N’ouvrez pas le port 11434

L’API Ollama ne fournit aucune authentification. Définir OLLAMA_HOST=0.0.0.0:11434 pour y accéder depuis votre ordinateur portable expose un moteur de modèles sans authentification sur Internet. Toute personne qui le trouve peut charger des modèles sur votre disque et lire tout ce que votre agent lui transmet. Laissez-le lié à localhost et utilisez plutôt un tunnel.

ssh -N -L 11434:127.0.0.1:11434 user@your-vps

Sécuriser le point de terminaison de l’API Ollama présente les options appropriées, notamment un reverse proxy qui demande des identifiants.

Ce qui peut échouer et ce que vous verrez

Le téléchargement s’arrête en cours de route. Le disque est plein. Exécutez df -h dans le répertoire du modèle. Un build bf16 de 57 Go ne tient pas sur un volume racine de 40GB. Les builds 8-bit et 4-bit installés côte à côte ne tiennent pas non plus.

Le modèle se charge, puis le processus s’arrête. La mémoire est insuffisante. dmesg -T enregistre le choix d’un processus par l’out of memory killer du kernel, et journalctl -u ollama -n 100 affiche le même événement du côté du service. Utilisez un tag plus petit ou un num_ctx plus petit. Ajouter du swap ne résout pas le problème.

L’exécution prend plusieurs secondes par token. Exécutez vmstat 1 et surveillez les colonnes si et so. Une activité swap continue indique que les poids ne tiennent pas en RAM et que le système les relit depuis le disque pendant l’exécution.

Un tag qui fonctionnait la semaine dernière a disparu. Les listes de tags changent. Consultez à nouveau la page du modèle, utilisez un tag correspondant à la version actuelle et notez son nom à un endroit où vous pourrez le retrouver.

Vérifiez vous-même les tailles avant le téléchargement

Les tailles du tableau ont été relevées sur la page des tags du modèle le 25 octobre 2026. Une liste de tags publiée ne constitue pas une garantie. Consultez la liste actuelle sur la page du modèle, puis vérifiez ce qui a réellement été écrit sur votre disque :

ollama pull muse-glimmer:30b
ollama list
sudo du -sh /usr/share/ollama/.ollama/models

Ollama stocke les layers des modèles sous forme de blobs partagés. Deux tags qui partagent un layer ne consomment donc pas deux fois plus d’espace disque. Comparez le résultat de du avec la taille publiée et prévoyez l’espace disque nécessaire en fonction de la plus grande des deux valeurs.

FAQ

De combien de RAM Muse Glimmer a-t-il besoin sur un VPS ?

Partez de la taille du tag et ajoutez la fenêtre de contexte. Le tag par défaut est indiqué à environ 18 GB au 25 octobre 2026. Une machine de 16GB ne peut donc pas le contenir du tout, tandis qu’une machine de 24GB ne laisse que peu de mémoire pour le contexte. Considérez cette valeur comme un point de départ, pas comme une réponse définitive. Téléchargez le tag, chargez-le une fois, puis exécutez ollama ps et free -h sur votre propre machine pour relever vos propres valeurs. Une fenêtre de contexte plus longue et des requêtes parallèles ajoutent toutes deux de la consommation mémoire en plus des poids du modèle.

Puis-je exécuter Muse Glimmer sans GPU ?

Oui. Le modèle se charge et répond sur un VPS utilisant uniquement le CPU. La vitesse de génération dépend davantage de la bande passante mémoire que du nombre de cœurs. Sur un hébergement partagé, cette bande passante est partagée. Attendez-vous donc à un faible nombre de tokens par seconde en 4-bit. C’est utilisable pour un agent exécuté en arrière-plan sans intervention. C’est en revanche pénible pour une conversation interactive. Exécutez ollama ps pendant une requête et consultez la colonne du processeur pour confirmer où le traitement s’effectue.

Les tags MLX sont-ils utiles sur un VPS Linux ?

Non. Tous les tags que la page des tags identifie comme MLX sont conçus pour le moteur MLX d’Ollama, qui constitue son backend Apple Silicon. Cela inclut 30b-nvfp4 et 30b-mxfp8, même si leur nom ne contient pas mlx. Sur un serveur Linux x86, ces tags représentent un téléchargement volumineux que vous ne pouvez pas exécuter. Utilisez le tag 30b sans suffixe, ou l’un des autres tags qui ne sont pas MLX. Ignorez les benchmarks réalisés sur le matériel Apple qui accompagnent les builds MLX.

Pourquoi le modèle oublie-t-il des éléments bien avant 128K tokens ?

Parce que, sur une machine sans GPU, la fenêtre de contexte par défaut d’Ollama est de 4096 tokens, quelle que soit la valeur prise en charge par le modèle. Le serveur tronque donc les conversations longues avant même que le modèle ne les reçoive. Définissez OLLAMA_CONTEXT_LENGTH sur le serveur, ou /set parameter num_ctx pour une seule session, ou envoyez num_ctx dans les options de la requête API. La consommation mémoire augmente avec cette valeur. Augmentez-la donc progressivement et vérifiez ollama ps à chaque étape.

Dois-je figer le tag ou utiliser simplement latest ?

Figez-le. muse-glimmer sans tag pointe vers latest. Il s’agit d’un pointeur que l’éditeur peut déplacer vers un autre build à tout moment. Un pull ordinaire peut donc modifier le modèle exécuté par votre agent. Écrivez muse-glimmer:30b dans les scripts, les unit files et la configuration de l’agent. Consultez la liste des tags sur la page du modèle avant de le figer, car les tags publiés peuvent changer.

Cet article vous a-t-il été utile ?