Meta Muse Glimmer 30B draaien op een Linux VPS

Wat Muse Glimmer vereist op een VPS

Muse Glimmer draait op een standaard Linux VPS zonder GPU, en de tag die u ophaalt bepaalt of het model in het geheugen past. Meta Superintelligence Labs heeft het model op 10 augustus 2026 gepubliceerd onder de Apache 2.0-licentie: 30 miljard parameters, een contextvenster van 128K en een toegewezen 1.8B parameter perceptie-encoder zodat het naast tekst ook afbeeldingen kan lezen. Meta positioneert het model voor altijd actieve lokale agents in plaats van voor chat, met een redeneerkracht die u per verzoek instelt.

De gepubliceerde Ollama-tags, gelezen op 16 augustus 2026, variëren van 17 GB tot 59 GB. Dat bereik vormt het volledige vraagstuk rondom de dimensionering. De standaardtag staat genoteerd op ongeveer 18 GB, dus de kleinste verstandige server heeft duidelijk meer dan 18 GB aan vrij RAM-geheugen nodig. Schijfruimte voor de download en geheugen voor het contextvenster komen daar nog bovenop.

Welke muse-glimmer-tag moet u ophalen?

[
  {
    "label": "30b-nvfp4",
    "size_gb": 17
  },
  {
    "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-nvfp4-dflash",
    "size_gb": 21
  },
  {
    "label": "30b-q8_0",
    "size_gb": 31
  },
  {
    "label": "30b-mxfp8",
    "size_gb": 33
  },
  {
    "label": "30b-q8_0-dflash",
    "size_gb": 33
  },
  {
    "label": "30b-mxfp8-dflash",
    "size_gb": 35
  },
  {
    "label": "30b-bf16",
    "size_gb": 57
  },
  {
    "label": "30b-bf16-dflash",
    "size_gb": 59
  }
]

Ollama vermeldt 11 tags voor dit model die geen Apple-builds zijn. Deze bevatten dezelfde 30 miljard gewichten, opgeslagen in verschillende numerieke precisies. De grootte die u ziet is wat u downloadt, en dit is tevens ongeveer wat u in het geheugen moet hebben voordat er context wordt toegevoegd.

De twee 4-bit builds zijn de kleine varianten: 30b-nvfp4 met 17 GB en 30b-q4_K_M met 18 GB. De standaard 30b-tag wordt vermeld met dezelfde grootte als de q4_K_M-build. De 8-bit builds, 30b-q8_0 en 30b-mxfp8, bevinden zich rond de 31 GB. 30b-bf16 is de ongekwantiseerde 16-bit release van 57 GB; dit vereist meer RAM dan de meeste gehuurde servers bieden tegen een prijs die voor een zijproject acceptabel is.

De -dflash-tags zijn dezelfde builds met DFlash-ondersteuning, en elk daarvan wordt groter vermeld dan de standaardversie. Ollama beschrijft DFlash als een snelheidsfunctie en demonstreert dit op Apple Silicon en desktop-GPU's. Op een VPS die alleen over een CPU beschikt, betaalt u voor die extra grootte in werkelijk geheugen voor een functie die op andere hardware wordt gemeten. Begin daarom met de standaardtag en wijzig één ding tegelijk.

Begin bij 4-bit, tenzij u een specifieke reden heeft om dat niet te doen. De overstap van 4-bit naar 8-bit verdubbelt ruwweg het aantal bytes dat de CPU moet lezen voor elk gegenereerd token, waardoor de doorvoer daalt terwijl het geheugengebruik stijgt. Die afweging is het onderwerp van wat q4, q8 en fp16-kwantisatie u werkelijk kosten, en op een CPU-server is het korte antwoord dat de 4-bit build de enige is waarmee het de moeite waard is om te beginnen.

Waarom de MLX-tags niets doen op een Linux-server

MLX is het array-framework van Apple en de MLX-engine van Ollama is de backend voor Apple Silicon. Elke tag met mlx in de naam is gebouwd voor die engine en die hardware. Op een x86 Linux VPS is dit een download van tientallen gigabytes die u niet kunt uitvoeren; deze neemt alleen schijfruimte in beslag zonder functie. De snelheidsgegevens in de aankondiging die op een Mac zijn gemeten, horen bij die tags en beschrijven dus ook uw server niet. Wanneer u de taglijst op de modelpagina bekijkt, filter dan eerst alle namen met mlx weg en bepaal daarna de grootte op basis van wat er overblijft.

Hoeveel RAM en schijfruimte is er werkelijk nodig?

Twee zaken leggen beslag op het geheugen, waarvan er slechts één de grootte van de tag is. De gewichten staan vast op basis van de tag die u ophaalt. De KV-cache, de status per token die het model bijhoudt voor het gesprek, groeit naarmate de contextlengte die u configureert toeneemt. De documentatie van Ollama vermeldt dat het bedienen van parallelle verzoeken de context vermenigvuldigt met het aantal actieve verzoeken; een server die twee agents tegelijk beantwoordt, heeft dus meer geheugen nodig dan dezelfde server die er één beantwoordt.

Vertrouw niet blindelings op een RAM-cijfer uit een handleiding, inclusief deze. Haal de tag op, stuur één prompt en voer de volgende twee commando's uit terwijl het model nog in het geheugen geladen is.

ollama ps
free -h

ollama ps toont wat er op dit moment geladen is en hoe het werk verdeeld is tussen de CPU en GPU. free -h toont wat er nog beschikbaar is. Deze twee uitvoerwaarden op uw eigen systeem zijn betrouwbaarder dan welke gepubliceerde tabel dan ook, omdat ze al rekening houden met uw contextinstelling, uw kwantisatie en alle andere processen die op de server draaien.

Schijfruimte is het eenvoudigere deel. Ollama slaat modellen op onder /usr/share/ollama/.ollama/models op Linux, wat op de meeste VPS-images op het root-bestandssysteem staat. Een root-volume van 40GB biedt onvoldoende ruimte voor de bf16-build van 57 GB, en het kan ook geen twee 8-bit tags naast elkaar opslaan. Verplaats de opslaglocatie naar een aangekoppeld volume voordat u iets ophaalt.

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

De gebruiker ollama moet eigenaar zijn van die map, omdat de service draait als ollama en de blobs als zichzelf naar die locatie schrijft. Als het ophalen mislukt door toegangsrechten, is journalctl -u ollama -n 50 de plek waar de reden hiervoor verschijnt.

Over swap moet één ding duidelijk zijn: swap stelt u niet in staat om een grotere tag te draaien. Bij het genereren worden de gewichten voor elk geproduceerd token geraadpleegd; gewichten die in swap staan, worden dus telkens opnieuw vanaf de schijf gelezen. vmstat 1 laat dan zien dat de kolommen si en so actief zijn, en de uitvoersnelheid vertraagt tot seconden per token. Houd een klein swap-bestand aan als verzekering tegen de out-of-memory killer. Stem de hoeveelheid RAM af op de tag die u daadwerkelijk wilt gebruiken.

Ollama installeren en een specifieke tag vastzetten

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

Het installatiescript configureert een systemd-service, zodat de server na een herstart weer opkomt. Als u de service liever niet als root beheert, beschrijft Ollama rootless draaien onder Podman die methode. Haal daarna een expliciete tag op.

ollama pull muse-glimmer:30b
ollama list

Lees zelf de kolom met de grootte in ollama list en vergelijk deze met de huidige lijst met tags op de modelpagina. Gepubliceerde tags worden toegevoegd, hernoemd en verwijderd; een grootte in een handleiding is slechts een momentopname.

Gebruik nooit ollama pull muse-glimmer op een server waar u afhankelijk van bent. Een kale modelnaam verwijst naar de latest-tag, en latest is een verwijzing die de uitgever naar een andere build kan verplaatsen. Een routine-pull vervangt dan het model onder uw agent, met andere geheugenvereisten en ander gedrag, zonder dat dit in uw logs wordt vermeld. Noteer de tag in uw scripts, in uw unit-bestanden en in de configuratie van uw agent. Een LLM zelf hosten met Ollama op een VPS behandelt de rest van de serverconfiguratie.

Kunt u Muse Glimmer uitvoeren zonder GPU?

Ja, en het is belangrijk om eerlijk te zijn over de beperkingen. Het genereren van één token betekent dat de modelgewichten uit het geheugen moeten worden gelezen; de snelheid wordt dus bepaald door de geheugenbandbreedte en niet door het aantal vCPU's dat in het abonnement wordt geadverteerd. Voorbij een handvol cores leveren extra cores nauwelijks winst op. Op een gedeelde VPS wordt die bandbreedte gedeeld met alle andere huurders op de host, waardoor een 30B-model in 4-bit slechts een klein aantal tokens per seconde produceert.

Neem de cijfers van niemand zomaar aan, ook die van mij niet. Meet het aantal tokens per seconde op uw eigen systeem en beslis op basis van wat u ziet.

Het resultaat is een duidelijk onderscheid in waar het model geschikt voor is. Interactieve chat is traag, omdat u sneller leest dan de server schrijft en elk antwoord begint met een lange pauze. Achtergrondtaken voor agents werken prima, omdat het voor een taak die tien minuten onbeheerd draait niet uitmaakt dat deze langzaam is. Dat tweede type werklast is precies waar Meta dit model voor beschrijft.

Als u interactieve snelheid nodig heeft, zijn de twee eerlijke antwoorden een GPU of een gehoste API. Bereken het omslagpunt tussen een GPU VPS en API-tokens voordat u iets huurt, en wat een GPU VPS u daadwerkelijk biedt beschrijft wat u precies aanschaft. Voor de bredere vraag over wat een bepaalde machine kan draaien, begint u bij welke modellen u zelf kunt hosten, en het draaien van een vergelijkbaar Qwen-model op een VPS is de meest nauwkeurige vergelijking in deze grootteklasse.

Waarom vergeet het dingen lang voordat de 128K tokens zijn bereikt?

Omdat het standaard contextvenster van Ollama 4096 tokens is, ongeacht wat het model ondersteunt. Deze standaardwaarde staat sinds augustus 2026 in de eigen FAQ van Ollama. De tag adverteert 128K, maar de server geeft het model 4096 tokens totdat u anders aangeeft. Hierdoor verliest een lang agent-transcript de eerste interacties en lijkt het alsof het model aan geheugenverlies lijdt.

Verhoog dit op de server voor elk verzoek:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=32768"

Binnen een interactieve sessie wijzigt /set parameter num_ctx 32768 dit alleen voor die sessie. Via de API stuurt u num_ctx mee in de verzoekopties.

Elke extra token aan context kost geheugen bovenop de gewichten. Vraagt u de volledige 128K aan op een systeem dat enkel voor de gewichten is gedimensioneerd, dan zal het laden mislukken of terugvallen op een tragere methode. Verhoog het in stappen en voer na elke stap ollama ps uit. Hoe num_ctx en contextlengte werken in Ollama behandelt de berekeningen hiervan.

Redeneerkracht: low, medium, high en xhigh

Meta documenteert vier redeneerkrachten voor Muse Glimmer, van low tot xhigh, en adviseert de twee hoogste niveaus voor complexe programmeertaken en agent-taken. In Ollama wordt dit aangestuurd via de parameter think. Gebruik --think= op de opdrachtregel, of stuur think mee in de API-body.

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

Binnen een interactieve sessie kunt u dit aanpassen met /set think en /set nothink. De documentatie van Ollama stelt dat de meeste modellen een boolean of een niveau zoals low, medium of high accepteren, en dat sommige max accepteren voor het hoogst beschikbare niveau. Welke exacte strings dit model accepteert, staat op de bijbehorende modelpagina; raadpleeg deze in plaats van te gokken en test het handmatig voordat u het integreert in een agent.

Op een systeem dat enkel op CPU draait, heeft deze instelling aanzienlijke impact. Een hogere kracht betekent dat er meer denktokens worden gegenereerd voordat het eerste woord van het antwoord verschijnt, en een denktoken kost evenveel verwerkingstijd als een antwoordtoken. Gebruik de instelling low voor routinewerkzaamheden.

Houd het model geladen voor een altijd actieve agent

Ollama ontlaadt een inactief model standaard na vijf minuten. Voor een agent die elke tien minuten wordt uitgevoerd, betekent dit dat bij elke run een volledige 18 GB vanaf de schijf moet worden geladen. Op een VPS met netwerkopslag is dit laadproces niet snel. Houd het model daarom vast in het geheugen.

[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"

Een negatieve waarde zorgt ervoor dat het model in het geheugen blijft totdat het expliciet wordt ontladen. De parameter keep_alive in een API-verzoek overschrijft de standaardinstelling van de server voor die specifieke aanroep. De kosten zijn transparant: het RAM-geheugen blijft bezet terwijl er niets gebeurt. Gebruik deze instelling daarom alleen op een server die specifiek voor de agent is gereserveerd. Een Ollama-model geladen houden behandelt de verschillende variaties.

Een coding agent koppelen

Ollama biedt een OpenAI-compatibele API aan op http://127.0.0.1:11434/v1, waardoor de meeste agent-tools verbinding maken met een basis-URL en een willekeurige, niet-lege API-sleutel. De Muse Glimmer-pagina van Ollama documenteert ook een opstart-shortcut die een ondersteunde agent in één commando aan een lokaal model koppelt; het is raadzaam om daar ook de tag vast te pinnen.

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

Agents versturen grote prompts. Bestandsinhoud, tool-output en een groeiend transcript komen allemaal binnen als input-tokens. Op een systeem dat enkel op de CPU draait, is de verwerking van de prompt het onderdeel dat de meeste vertraging veroorzaakt, nog voordat de generatie is begonnen. Houd de context-instelling zo klein als de taak toelaat. Een coding agent koppelen aan Ollama behandelt de client-zijde, een coding agent draaien op een VPS behandelt de server waarop deze actief is, en kosten van agents op een VPS beheersen behandelt wat er gebeurt wanneer deze de hele dag draait.

Image-input werkt op dezelfde manier. De Ollama API accepteert afbeeldingen via het images-veld van een bericht. Een client die alleen tekst ondersteunt, zal er dus nooit een versturen, ongeacht hoe capabel de perception encoder is.

Open poort 11434 niet

De Ollama API bevat geen authenticatie. Als u OLLAMA_HOST=0.0.0.0:11434 instelt zodat u deze vanaf uw laptop kunt bereiken, plaatst u een niet-geauthenticeerde model-runner op het openbare internet. Iedereen die de service vindt, kan modellen op uw schijf laden en alles lezen wat uw agent erdoorheen stuurt. Laat de service gebonden aan localhost en gebruik in plaats daarvan een tunnel.

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

Het beveiligen van het Ollama API-eindpunt behandelt de juiste opties, waaronder een reverse proxy die om inloggegevens vraagt.

Wat er misgaat en wat u zult zien

De pull stopt halverwege. Schijfruimte. Voer df -h uit in de modelmap. Een 57 GB bf16-build past niet op een 40GB root-volume, en twee 8-bit tags naast elkaar evenmin.

Het model laadt en het proces stopt vervolgens. Onvoldoende geheugen. dmesg -T registreert dat de kernel out-of-memory killer een proces beëindigt, en journalctl -u ollama -n 100 toont de service-kant van dezelfde gebeurtenis. De oplossing is een kleinere tag of een kleinere num_ctx. Meer swap is niet de oplossing.

Het draait met seconden per token. Voer vmstat 1 uit en observeer de kolommen si en so. Constante swap-activiteit betekent dat de gewichten niet in het RAM passen en dat de server deze tijdens het werk terugleest van de schijf.

Een tag die vorige week werkte, is verdwenen. Taglijsten veranderen. Lees de modelpagina opnieuw, pin de huidige versie vast en noteer de tagnaam op een plek waar u deze later weer kunt terugvinden.

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

FAQ

Hoeveel RAM heeft Muse Glimmer nodig op een VPS?

Begin bij de grootte van de tag en tel daar het contextvenster bij op. De standaard-tag is op 16 augustus 2026 ongeveer 18 GB groot. Een server met 16 GB RAM kan deze tag dus helemaal niet laden, en een server met 24 GB RAM heeft nauwelijks ruimte over voor de context. Beschouw dit als uitgangspunt, niet als definitief antwoord. Haal de tag op, laad deze eenmaal, voer daarna ollama ps en free -h uit op uw eigen systeem en lees de waarden af. Een langere context en gelijktijdige verzoeken verhogen het geheugengebruik bovenop de gewichten van het model.

Kan ik Muse Glimmer draaien zonder GPU?

Ja. Het model laadt en antwoordt op een VPS die alleen over een CPU beschikt. De generatiesnelheid wordt beperkt door de geheugenbandbreedte in plaats van het aantal cores. Op een gedeelde host wordt deze bandbreedte gedeeld, dus verwacht een laag aantal tokens per seconde bij 4-bit. Dit is bruikbaar voor achtergrondtaken die onbeheerd draaien, maar traag voor interactieve chats. Voer ollama ps uit tijdens een verzoek en controleer de processor-kolom om te bevestigen waar de berekeningen plaatsvinden.

Heb ik iets aan de MLX-tags op een Linux VPS?

Nee. Elke tag met mlx in de naam is gebouwd voor de MLX-engine van Ollama, de backend voor Apple Silicon. Op een x86 Linux-server zijn deze tags een grote download die u niet kunt uitvoeren. Gebruik de standaard 30b-tag of een van de andere niet-MLX-tags, en negeer de benchmarks voor Apple-hardware die bij de MLX-builds horen.

Waarom vergeet het model dingen lang voordat de 128K tokens zijn bereikt?

Omdat het standaard contextvenster van Ollama 4096 tokens is, ongeacht wat het model ondersteunt. De server kort lange gesprekken in voordat het model ze kan verwerken. Stel OLLAMA_CONTEXT_LENGTH in op de server, of /set parameter num_ctx voor één sessie, of stuur num_ctx mee in de opties van het API-verzoek. Het geheugengebruik stijgt naarmate dit getal toeneemt; verhoog het daarom in stappen en controleer telkens ollama ps.

Moet ik de tag vastzetten (pinnen) of gewoon 'latest' gebruiken?

Zet de tag vast. muse-glimmer zonder tag verwijst naar latest. Dit is een pointer die de uitgever op elk moment naar een andere build kan verplaatsen, waardoor een routine-update het model van uw agent onverwacht kan wijzigen. Gebruik muse-glimmer:30b in scripts, unit-bestanden en agent-configuraties. Controleer de taglijst op de modelpagina voordat u een tag vastzet, aangezien gepubliceerde tags kunnen veranderen.