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 perceptie-encoder van 1,8B parameters voor het verwerken van afbeeldingen naast tekst. Meta positioneert het model voor continu actieve lokale agents in plaats van voor chattoepassingen, waarbij u de redeneerkracht per verzoek instelt.

De gepubliceerde Ollama-tags, geraadpleegd op 16 augustus 2026, variëren van 17 GB tot 59 GB. Dat bereik vormt de kern van het capaciteitsvraagstuk. De standaardtag wordt vermeld op ongeveer 18 GB, dus de kleinste verstandige serverconfiguratie beschikt duidelijk over meer dan 18 GB vrij RAM-geheugen. 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 met verschillende numerieke precisies. De grootte die u ziet is wat u downloadt, en dit is tevens ongeveer de hoeveelheid die 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 redelijk is.

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

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 doorvoersnelheid 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; het zal ongebruikt op uw schijf blijven staan. De snelheidscijfers in de aankondiging die op een Mac zijn gemeten, horen bij die tags en beschrijven dus ook niet uw server. 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 factoren bepalen het geheugengebruik, 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 tegelijkertijd beantwoordt, heeft dus meer geheugen nodig dan dezelfde server voor één agent.

Vertrouw niet blindelings op een RAM-cijfer uit een handleiding, inclusief deze. Haal de tag op, stuur één prompt en voer deze twee commando's uit terwijl het model 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 CPU en GPU. free -h toont wat er nog beschikbaar is. Deze twee outputs op uw eigen systeem zijn betrouwbaarder dan elke gepubliceerde tabel, 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. Als u nog nooit heeft gecontroleerd wat een pull daadwerkelijk wegschrijft, legt waar Ollama modellen opslaat en hoe u deze verplaatst uit hoe die directory in elkaar zit. Verplaats de opslag 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 directory, omdat de service draait als ollama en de blobs als zichzelf wegschrijft. Als een pull mislukt vanwege rechten, vindt u de reden in journalctl -u ollama -n 50.

Over swap is één ding duidelijk: swap stelt u niet in staat om een grotere tag te draaien. Bij generatie worden de gewichten voor elk geproduceerd token geraadpleegd. Gewichten die in swap staan, worden dus telkens opnieuw vanaf de schijf gelezen. vmstat 1 laat zien dat de kolommen si en so actief zijn, en de output vertraagt tot seconden per token. Houd een klein swap-bestand aan als verzekering tegen de out-of-memory killer. Stem de RAM-capaciteit 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 het liever niet als een door root beheerde systeemservice uitvoert, behandelt Ollama rootless uitvoeren onder Podman dat alternatief. 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 van één dag.

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 aangekondigd. Noteer de tag in uw scripts, in uw unit-bestanden en in uw agent-configuratie. Een LLM zelf hosten met Ollama op een VPS behandelt de rest van de serverconfiguratie.

Kan Muse Glimmer zonder GPU worden uitgevoerd?

Ja, al moet men realistisch zijn over de beperkingen. Het genereren van één token vereist het inlezen van de modelgewichten uit het geheugen; de snelheid wordt daarom bepaald door de geheugenbandbreedte en niet door het aantal vCPU's in uw abonnement. Boven een handvol cores levert extra rekenkracht nauwelijks winst op. Op een gedeelde VPS wordt deze bandbreedte gedeeld met alle andere huurders op de host, waardoor een 30B-model op 4-bit slechts een klein aantal tokens per seconde genereert.

Neem de cijfers van anderen, inclusief de mijne, niet zomaar aan. Meet het aantal tokens per seconde op uw eigen systeem en trek uw eigen conclusies op basis van de resultaten.

Dit leidt tot een duidelijk onderscheid in de toepasbaarheid van het model. Interactieve chat is moeizaam, omdat u sneller leest dan de server schrijft en elk antwoord begint met een lange pauze. Achtergrondtaken voor agents werken prima, omdat het bij een taak die tien minuten onbeheerd draait niet uitmaakt of deze traag is. Dat tweede type werklast is precies waar Meta dit model voor bedoeld heeft.

Als u interactieve snelheid nodig heeft, zijn er twee eerlijke opties: 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 server aankan, 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. Als de gemeten snelheid te laag is voor uw behoeften, stelt Nemotron 3.5 Lightning op een VPS dezelfde vragen over RAM en tokens per seconde voor een model dat is geoptimaliseerd voor snelheid in plaats van omvang.

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. Als u de volledige 128K aanvraagt op een systeem dat enkel voor de gewichten is gedimensioneerd, zal de belasting falen of terugvallen op een tragere verwerking. 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 raadt de twee hoogste aan voor complexe programmeertaken en agent-taken. In Ollama verloopt dit via de parameter think. Gebruik --think= op de opdrachtregel, of stuur think in de API-body.

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

Binnen een interactieve sessie schakelen /set think en /set nothink dit in of uit. 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; lees deze dus in plaats van te gokken, en probeer er handmatig een uit voordat u deze in een agent verwerkt.

Op een systeem dat alleen op een 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 tijd als een antwoordtoken. Laat routinewerk op de instelling low staan. De lengte van het antwoord vereist dezelfde zorg, dus begrens het antwoord met num_predict in plaats van één langdradig antwoord een traag systeem minutenlang te laten bezetten.

Houd het model geladen voor een agent die altijd actief is

Ollama verwijdert een inactief model standaard na vijf minuten uit het geheugen. Voor een agent die elke tien minuten wordt uitgevoerd, betekent dit dat u bij elke uitvoering een volledige 18 GB vanaf de schijf moet laden. Op een VPS met netwerkopslag is dit laden 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 verwijderd. De parameter keep_alive in een API-verzoek overschrijft de serverinstelling voor die specifieke aanroep. De kosten zijn duidelijk: 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 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 CPU draait, is de verwerking van de prompt het onderdeel dat 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 in 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.

Stel poort 11434 niet open

De Ollama API beschikt niet over authenticatie. Door OLLAMA_HOST=0.0.0.0:11434 zo in te stellen dat u deze vanaf uw laptop kunt bereiken, plaatst u een niet-geauthenticeerde model-runner op het openbare internet. Iedereen die de server 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 modeldirectory. 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 kiest, 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 si- en so-kolommen. Constante swap-activiteit betekent dat de gewichten niet in het RAM passen en dat de server ze tijdens het werken 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?

Ga uit van 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 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 één keer, voer vervolgens ollama ps en free -h uit op uw eigen systeem en lees uw eigen waarden af. Een langere context en gelijktijdige verzoeken verhogen het geheugengebruik bovenop de gewichten.

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 die 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 verwerking plaatsvindt.

Heb ik iets aan 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 kapt lange gesprekken af 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 API-verzoekopties. Het geheugengebruik stijgt naarmate dit getal toeneemt; verhoog het daarom in stappen en controleer telkens ollama ps.

Moet ik de tag vastzetten (pin) 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.