Slik kjører du GLM-5.3-Flash lokalt

TL;DR

Du kan kjøre GLM-5.3-Flash lokalt fordi Z.ai har gitt ut modellvektene under MIT-lisens. Begrensningen er minne: modellen har omtrent 320B totale parametere, selv om bare 18B er aktive per token. Native FP8-vekter er om lag 306 GiB før runtime- og KV-cache-overhead, mens vanlige GGUF-kvantiseringer spenner fra cirka 93 GB ved 1-bit til 200 GB ved Q4 og 341 GB ved Q8.

For produksjonsbetjening på GPU er vLLM eller SGLang den mest direkte veien. For en arbeidsstasjon med mye RAM og én eller flere forbruker-GPU-er er KTransformers laget for heterogen CPU–GPU-inferens. For enkleste lokale eksperiment, bruk en GGUF-build med llama.cpp eller Ollama. En vanlig 24 GB- eller 32 GB-GPU kan ikke holde hele modellen alene; lokal bruk på én GPU avhenger av system-RAM, offloading og/eller kvantisering.

Hva er GLM-5.3-Flash?

For en fullstendig modelloversikt og tolkning av benchmarker, se CometAPIs What Is GLM-5.3-Flash?. Denne utrullingsveiledningen beholder kun størrelsesfakta som trengs her: GLM-5.3-Flash er en 320B / 18B multimodal MoE trent på et korpus med 30T token.

Det offisielle repositoriet lister et 1,048,576-token kontekstvindu, MIT-lisensierte vekter og støttede lokale betjeningsveier. Tabellene nedenfor er utrullingsreferansen; resten av artikkelen fokuserer på installasjon, minne, verifisering og feilsøking.

Hvorfor GLM-5.3-Flash er mer effektiv enn størrelsen tilsier

En 320B-modell høres ut som en konvensjonell tett 320B-modell, men det er ikke slik GLM-5.3-Flash bruker beregning. MoE-routeren aktiverer bare en brøkdel av ekspertkapasiteten for hvert token, mens oppmerksomhetsdesignet reduserer kostnaden for å beholde og hente long-context-tilstand.

Z.ai rapporterer reduksjoner i oppmerksomhetsberegning og KV-cache-bruk sammenlignet med GLM-5.3. Det er viktig fordi KV-cache vokser med kontektslengde og samtidighet; en modell som lastes inn ved 8K kontekst kan fortsatt gå tom for minne når du ber den betjene langt lengre samtaler.

Kilde: Z.ai official announcement

Hvor god er GLM-5.3-Flash?

Tabellen nedenfor beholder førstegenererte resultater mest relevante for utrulling. Z.ai rapporterer høyere benchmark-resultater for GLM-5.3-Flash versus GLM-5.2; se CometAPIs model overview for fyldigere tolkning av benchmarker. Her er det praktiske poenget om gevinstene rettferdiggjør lokal maskinvare og driftskostnad.

Mønsteret er spesielt relevant for selvhosting: modellens sterkeste bruksområder er ikke uformell chat, men kodeagenter, verktøydrevet automatisering, long-context dokumentarbeid og multimodale arbeidsflyter der dataresidens eller kontroll over infrastrukturen kan rettferdiggjøre utrullingsinnsatsen.

Hvor mye RAM eller VRAM trenger GLM-5.3-Flash?

Minneplanlegging er den viktigste delen av denne veiledningen. Den offisielle vLLM-oppskriften sier at den native FP8-sjekkpunktet er omtrent 306 GiB FP8-vekter. KTransformers anbefaler derfor å reservere minst 350 GB tilgjengelig systemminne for sin native-FP8 CPU–GPU-vei.

Hvis du bruker GGUF, publiserer Unsloth kvantiseringer fra 1-bit til BF16. Filstørrelsen er ikke det samme som samlet runtime-minne: du trenger fortsatt margin for runtime, modellmetadata, beregningsbuffere, multimodale komponenter og KV-cache.

Den tredje kolonnen er veiledning for utrullingsplanlegging, ikke en offisiell minimumsspesifikasjon for maskinvare. Faktisk passform avhenger av kontektslengde, batchstørrelse, runtime, GPU-offload og kvantiseringsimplementering.

Hvilken lokal runtime bør du bruke?

Velg vLLM når gjennomstrømning og økosystemkompatibilitet betyr mest. Velg SGLang når du vil benchmarke agentisk, strukturert output eller multimodal betjening. Velg KTransformers når modellen ikke får plass i GPU-minnet, men du har hundrevis av gigabyte system-RAM. Velg llama.cpp eller Ollama når lokal eksperimentering er viktigere enn å matche det native sjekkpunktet.

Slik kjører du GLM-5.3-Flash med native vekter

Kjør med vLLM

vLLM er det tydeligste produksjonsorienterte alternativet hvis du har akseleratorer i serverklassen. Den nåværende offisielle oppskriften støtter flere paralleliseringsstrategier og dokumenterer native FP8-betjening. Behandle publiserte konfigurasjoner som referanseoppsett, ikke som et løfte om at alle GPU-kombinasjoner vil fungere med de samme flaggene.

Trinn 1: Forbered miljøet

Bruk Linux med en støttet NVIDIA-stakk, nok samlet GPU-minne for sjekkpunktet pluss runtime-overhead, og en nyere vLLM-build eller containeren anbefalt av den gjeldende oppskriften. Start med et mindre kontekstvindu mens du validerer utrullingen, i stedet for å allokere hele vinduet på én million token umiddelbart.

Trinn 2: Start serveren

pip install vllm

vllm serve "zai-org/GLM-5.3-Flash" \
  --tensor-parallel-size 8 \
  --served-model-name zai-org/GLM-5.3-Flash

For avanserte utrullinger dokumenterer den offisielle vLLM-oppskriften FP8 KV-cache på støttede Blackwell-systemer, MTP spekulativ dekoding, verktøykall-parsing, resonnerings-parsing og separering av prefill/decode. Sjekk den gjeldende vLLM-oppskriften før du kopierer flagg til produksjon fordi støtte kan endre seg raskt.

Trinn 3: Test OpenAI-kompatibelt endepunkt

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3-Flash",
    "messages": [
      {"role": "user", "content": "Reply with OK"}
    ]
  }'

Kjør med SGLang

SGLang er en annen førsteklasses betjeningsvei listet i det offisielle modelkortet. Det er spesielt verdt å teste for høysamtidige agenter, strukturert generering, multimodale forespørsler og applikasjoner med mye verktøybruk.

Trinn 1: Installer SGLang

pip install sglang

Trinn 2: Start modellserveren

python3 -m sglang.launch_server \
  --model-path "zai-org/GLM-5.3-Flash" \
  --host 0.0.0.0 \
  --port 30000

Trinn 3: Verifiser endepunktet

curl -X POST "http://localhost:30000/v1/chat/completions" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "zai-org/GLM-5.3-Flash",
    "messages": [{"role": "user", "content": "Give me three local deployment checks."}]
  }'

Det offisielle Hugging Face modelkortet gir også multimodale forespørseleksempler for SGLang. Hvis du trenger verktøykall, bruk parserflaggene anbefalt av den gjeldende SGLang-oppskriften i stedet for å anta at flagg fra en eldre GLM-utgave forblir uendret.

Kjør med KTransformers

KTransformers er det viktigste alternativet for brukere som tolker «lokalt» som en arbeidsstasjon heller enn en server med åtte GPU-er. Dets GLM-5.3-Flash-implementering leser de offisielle FP8-vektene direkte og utfører heterogen CPU–GPU-ekspertinferens.

Den gjeldende veiledningen sier at FP8-modellen opptar omtrent 306 GiB og anbefaler 350 GB systemminne. Den støtter NVIDIA SM89 og SM120 GPU-er, inkludert RTX 40- og 50-serie, pluss AVX-512 FP8 CPU-ekspertkjerner. Veiledningen inkluderer både fire-GPU- og én-GPU-oppsett.

En enkelt RTX 4090 eller RTX 5090 kan delta i inferens, men det gjør ikke GLM-5.3-Flash til en 24–32 GB-modell. Mesteparten av modellen ligger fortsatt utenfor GPU-VRAM, så systemminnekapasitet og -båndbredde blir sentralt for ytelse.

Trinn 1: Opprett et rent Python-miljø

conda create -n glm53flash python=3.11 -y
conda activate glm53flash

Trinn 2: Installer KTransformers

pip install "ktransformers[sglang]"

Trinn 3: Last ned de offisielle vektene

Last ned zai-org/GLM-5.3-Flash fra Hugging Face til lokal lagring. Sørg for nok diskplass til sjekkpunktet og nok RAM til den aktive serverkonfigurasjonen.

Trinn 4: Start én-GPU-serveren

MODEL_PATH=/path/to/GLM-5.3-Flash

CUDA_VISIBLE_DEVICES=0 python -m sglang.launch_server \
  --model-path "$MODEL_PATH" \
  --kt-weight-path "$MODEL_PATH" \
  --served-model-name GLM-5.3-flash \
  --host 0.0.0.0 \
  --tp-size 1 \
  --context-length 501025 \
  --mem-fraction-static 0.65 \
  --chunked-prefill-size 2048 \
  --kt-method FP8 \
  --kt-cpuinfer 64 \
  --kt-threadpool-count 2 \
  --kt-num-gpu-experts 0 \
  --kt-gpu-prefill-token-threshold 2048 \
  --cuda-graph-bs 1 2 4 \
  --limit-mm-data-per-request '{"image":8,"video":1}' \
  --mm-process-config '{"image":{"max_pixels":1254400}}' \
  --tool-call-parser glm47 \
  --reasoning-parser glm45

Veiledningen bruker en validert 501,025-token-konfigurasjon selv om modellen støtter opptil 1M kontekst. Det er en nyttig påminnelse: konfigurer konteksten du faktisk trenger, ikke markedsføringsmaksimumet, fordi kontekstmargin har en direkte minnekostnad.

Trinn 5: Sjekk serveren

curl http://localhost:30000/v1/models

Det OpenAI-kompatible chat-endepunktet er ren tekst: http://localhost:30000/v1/chat/completions.

Slik kjører du en kvantisert GLM-5.3-Flash GGUF-modell

Kjør GLM-5.3-Flash med llama.cpp

Hvis du ikke vil kjøre det native FP8-sjekkpunktet, gjør GGUF minnemålet mer fleksibelt. Unsloth publiserer flere GLM-5.3-Flash GGUF-kvantiseringer og gir direkte llama.cpp-kommandoer. Q4_K_XL-bygget er rundt 200 GB, så selv denne «forbrukervennlige» veien forutsetter et system med mye minne.

Installer på macOS eller Linux

curl -LsSf https://llama.app/install.sh | sh

Installer på Windows

winget install llama.cpp

Start en lokal server med Q4_K_XL

llama serve -hf unsloth/GLM-5.3-Flash-GGUF:UD-Q4_K_XL

Kjør direkte i terminalen

llama cli -hf unsloth/GLM-5.3-Flash-GGUF:UD-Q4_K_XL

Hvis maskinen din ikke får plass til Q4_K_XL, finnes mindre 3-bit-, 2-bit- og 1-bit-filer. Ikke velg laveste bit-bredde bare fordi det passer: aggressiv kvantisering kan endre resonneringspålitelighet, verktøykall-formattering, kodekvalitet og multimodal oppførsel. Valider den eksakte builden på ditt eget testsett.

Kjør GLM-5.3-Flash med Ollama

Ollama er den korteste kommandolinjeveien hvis du allerede bruker det for lokale modeller. Unsloth dokumenterer direkte Hugging Face-innlasting for sine GLM-5.3-Flash GGUF-builds.

ollama run hf.co/unsloth/GLM-5.3-Flash-GGUF:UD-Q4_K_XL

Bekvemmeligheten med Ollama endrer ikke den underliggende modellstørrelsen. Q4_K_XL er fortsatt rundt 200 GB, og lavere bit-versjoner bytter minne mot kvalitet. Hvis du bare har 32–64 GB system-RAM, er ikke GLM-5.3-Flash et fornuftig lokalt mål; bruk en mindre modell eller en hostet API i stedet.

Velg en GGUF-kvantisering

Velg kvantiseringen med høyest kvalitet som passer med tilstrekkelig margin til runtime og KV-cache. Start med Q4_K_XL når du har omtrent 256 GB eller mer systemminne; vurder lavere bit-builds bare når maskinvaregrenser krever det, og valider resonnering, kodegenerering, verktøykall og multimodal oppførsel mot et native eller hostet referansepunkt før utrulling.

Slik verifiserer du lokal utrulling

En vellykket oppstartslogg er ikke nok. Test atferden applikasjonen din faktisk vil avhenge av. En nyttig akseptsekvens er: grunnleggende tekstgenerering, din reelle kontektslengde, verktøykall med dine skjemaer, multimodal input ved behov, og gjennomstrømning under realistisk samtidighet.

Grunnleggende røyktest

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3-Flash",
    "messages": [
      {"role": "user", "content": "Return exactly: LOCAL_OK"}
    ],
    "reasoning_effort": "low"
  }'

Modelkortet definerer reasoning_effort-nivåer og standarden er maks. For reproduksjon av benchmarker, behold maks; for en treg arbeidsstasjon kan low eller high gjøre iterativ testing langt mer praktisk.

Legg deretter til arbeidslastspesifikke kontroller:

• Lang kontekst: send et dokument eller et repositorium-stort prompt nær din tiltenkte produksjonslengde, ikke 1M maksimum som standard.
• Verktøykall: verifiser JSON-argumenter, verktøyvalg, gjenoppretting etter verktøyfeil og gjentatte kall.
• Multimodal: test bilde- eller videoformater og oppløsningsintervaller du vil bruke i praksis.
• Samtidighet: mål latens og minne mens flere forespørsler er aktive.
• Kvantisering: sammenlign samme promptsett mot et native eller hostet referansepunkt før du godkjenner en lav-bit GGUF-build.

Slik reduserer du minnebruk for GLM-5.3-Flash

Bruk et mindre kontekstvindu

Modellen støtter opptil 1M token, men de fleste lokale arbeidsflyter trenger ikke så mye kontekst på hver forespørsel. Reduser konfigurert maksimum til det som matcher applikasjonen din. Dette senker KV-cache-trykket og kan gjøre en ustabil utrulling brukbar.

Kvantiser vektene

Overgang fra BF16 til Q8, Q6, Q4 eller lavere bit-GGUF kan kutte vektminne dramatisk. Trade-off er output-kvalitet og av og til runtime-kompatibilitet, så behandle kvantisering som et modellvalg, ikke bare en lagringsmulighet.

Bruk CPU-offload

KTransformers og llama.cpp kan flytte betydelig modelltilstand til system-RAM. Dette er hovedgrunnen til at én-GPU GLM-5.3-Flash inferens i det hele tatt er plausibel, men det flytter også ytelsesflaskehalsen mot CPU-kapasitet og minnebåndbredde.

Reduser samtidighet

Hver samtidig long-context-forespørsel konsumerer ekstra cache og runtime-buffere. En arbeidsstasjonutrulling yter ofte bedre med et lite samtidighetsmål og en eksplisitt kø enn med server-stil parallellitet.

Slik forbedrer du interaktiv latens

For interaktiv lokal bruk kan senket reasoning_effort redusere generert resonneringslengde, responslatens og tokenforbruk. Det reduserer ikke minnet som kreves for å laste modellvektene; det kan bare redusere cache-bruk ved forespørsel indirekte ved å korte ned den genererte sekvensen. Bruk low for rask iterasjon, og bytt til high eller max når en oppgave trenger dypere resonnering eller benchmark-sammenlignbar atferd.

Bør du kjøre GLM-5.3-Flash lokalt eller bruke en API?

Selvhosting er attraktivt når personvern, dataresidens, frakoblet drift, tilpassede inferensinnstillinger eller eid uvirksom maskinvare betyr noe. Det er mindre attraktivt når du trenger sporadisk tilgang til modellen uten å opprettholde hundrevis av gigabyte med minne og en kompleks betjeningsstakk.

Hvis lokal utrulling ikke er et krav, kan du få tilgang til GLM-5.3-Flash via en OpenAI-kompatibel chat-completions-arbeidsflyt med model ID glm-5.3-flash. Dette er nyttig som referanseendepunkt for å sammenligne din lokale kvantiserte build med en hostet implementering eller som produksjonsreserve mens du tester selvhosting.

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[{"role": "user", "content": "Reply with OK"}],
)

print(response.choices[0].message.content)

Vanlige problemer ved lokal kjøring av GLM-5.3-Flash

Modellen lastes, og krasjer deretter på et langt prompt

Dette betyr vanligvis at du dimensjonerte for vektene, men ikke KV-cache. Reduser kontektslengde og samtidighet, og øk gradvis mens du overvåker GPU- og systemminne.

En Q4-fil passer på disk, men ikke i RAM

GGUF-filstørrelsen er ikke hele runtime-fotavtrykket. La betydelig margin for runtime-buffere, cache og operativsystemet.

Én-GPU KTransformers er ekstremt treg

Det kan forventes når mest ekspertarbeid betjenes fra CPU-minne. Sjekk NUMA-plassering, minnebåndbredde, CPU-instruksjonsstøtte, lagringsatferd under last, og om arbeidslasten din ville vært bedre tjent av en mindre kvantisert modell.

Verktøykall returnerer feilformet JSON

Bekreft at din runtime bruker parseren som anbefales for den gjeldende GLM-5.3-Flash-integrasjonen. Parserflagg kan endre seg mellom rammeverksversjoner, så ikke gjenbruk blindt en launch-kommando skrevet for en eldre GLM-modell.

Ollama eller llama.cpp begynner å laste ned hundrevis av gigabyte

Det er normalt for denne modellfamilien. Verifiser kvantiseringstagg før du starter nedlasting, bekreft ledig diskplass, og sjekk tilsvarende filstørrelse i GGUF-repositoriet først.

FAQ

Kan jeg kjøre GLM-5.3-Flash på en RTX 4090?

Ja, en RTX 4090 kan delta i KTransformers heterogen CPU–GPU-inferens, men 24 GB VRAM er langt fra nok til å holde hele sjekkpunktet. Den offisielle KTransformers FP8-veien krever fortsatt omtrent 350 GB tilgjengelig systemminne.

Kan jeg kjøre GLM-5.3-Flash på en RTX 5090?

Ja, RTX 50-serie GPU-er er eksplisitt inkludert i den gjeldende KTransformers-støttelisten. Som med en 4090 er nøkkelbegrensningen resten av systemet: RAM-kapasitet, minnebåndbredde, CPU-støtte og mengden kontekst du allokerer.

Kan jeg kjøre GLM-5.3-Flash med 128 GB RAM?

Bare de mest aggressive GGUF-kvantiseringene nærmer seg det området: Q2_K_XL er omtrent 109 GB og IQ2_XXS omtrent 102 GB. Når runtime-overhead og KV-cache inkluderes, er 128 GB et svært stramt mål. Det er ikke konfigurasjonen du velger hvis du vil ha forutsigbar kvalitet eller lang kontekst.

Kan GLM-5.3-Flash kjøres i Ollama?

Ja. Unsloth dokumenterer direkte Ollama-innlasting for sine GGUF-builds, inkludert UD-Q4_K_XL.

Hvor mye VRAM trenger GLM-5.3-Flash?

Det finnes ikke ett korrekt VRAM-tall. Native serverutrulling distribuerer sjekkpunktet over akseleratorer; KTransformers kombinerer GPU-VRAM med hundrevis av gigabyte system-RAM; llama.cpp kan offloade en kvantisert GGUF mellom CPU og GPU. Planlegg rundt runtime og kvantisering du har tenkt å bruke.

Er GLM-5.3-Flash open source?

Den tryggeste formuleringen er åpne vekter under MIT-lisens. Det offisielle Hugging Face-repositoriet lister eksplisitt MIT-lisensen og tilbyr nedlastbare sjekkpunkter.

Er lokal GLM-5.3-Flash billigere enn API?

Ikke automatisk. Lokal hosting kan gi mening når du allerede eier passende maskinvare, opprettholder konsekvent høy utnyttelse, eller må holde data i din egen infrastruktur. For sporadiske arbeidslaster unngår hostet tilgang vanligvis stor fast maskinvare- og driftsbyrde.

Konklusjon

GLM-5.3-Flash er uvanlig effektiv for en modell med omtrent 320B totale parametere, men «Flash» må ikke forveksles med «liten». Dets 18B aktive-parameter MoE-design reduserer beregning, mens hybrid lineær og sparsom oppmerksomhet gjør lang kontekst vesentlig billigere, men vektene krever fortsatt hundrevis av gigabyte med mindre du bruker aggressiv kvantisering.

Den praktiske utrullingsbeslutningen er derfor enkel: bruk vLLM eller SGLang for GPU-infrastruktur i serverklassen; bruk KTransformers når du har en svært stor systemminne-arbeidsstasjon og vil ha native FP8 CPU–GPU-inferens; bruk llama.cpp eller Ollama når GGUF-kvantisering og enkel eksperimentering betyr mest. Hvis ingen av disse maskinvareprofilene matcher maskinen din, bruk et hostet GLM-5.3-Flash endepunkt i stedet for å presse en 320B-modell inn i et uegnet lokalt oppsett.