Sådan kører du GLM-5.3-Flash lokalt

TL;DR

Du kan køre GLM-5.3-Flash lokalt, fordi Z.ai har frigivet modelvægtene under MIT-licens. Udfordringen er hukommelse: modellen har cirka 320B totale parametre, selvom kun 18B er aktive pr. token. Native FP8-vægte er cirka 306 GiB før runtime- og KV-cache-overhead, mens almindelige GGUF-kvantiseringer spænder fra cirka 93 GB ved 1-bit til 200 GB ved Q4 og 341 GB ved Q8.

Til produktion på GPU er vLLM eller SGLang den mest direkte vej. Til en arbejdsstation med stor RAM og en eller flere forbruger-GPU'er er KTransformers designet til heterogen CPU-GPU-inferens. Til den nemmeste lokale test, brug en GGUF-build med llama.cpp eller Ollama. En normal 24 GB eller 32 GB GPU kan ikke rumme hele modellen alene; lokal brug med én GPU afhænger af system-RAM, offloading og/eller kvantisering.

What Is GLM-5.3-Flash?

For en fuld modeloversigt og fortolkning af benchmarks, se CometAPIs What Is GLM-5.3-Flash?. Denne udrulningsguide bevarer kun størrelsesfakta, der er nødvendige her: GLM-5.3-Flash er en 320B / 18B multimodal MoE trænet på et 30T-token korpus.

Det officielle repository angiver et 1,048,576-token kontekstvindue, MIT-licenserede vægte og understøttede lokale serving-vej. Tabellen nedenfor er udrulningsreferencen; resten af artiklen fokuserer på installation, hukommelse, verifikation og fejlfinding.

Why GLM-5.3-Flash Is More Efficient Than Its Size Suggests

En 320B model lyder som en konventionel 320B tæt model, men det er ikke sådan GLM-5.3-Flash bruger compute. MoE-routeren aktiverer kun en del af eksperternes kapacitet for hvert token, mens redesign af opmærksomhed reducerer omkostningen ved at bevare og hente lang-kontekst tilstand.

Z.ai rapporterer reduktioner i opmærksomhedscompute og KV-cache-brug sammenlignet med GLM-5.3. Det er vigtigt, fordi KV-cache vokser med kontekstlængde og samtidighed; en model, der indlæses ved 8K kontekst, kan stadig løbe tør for hukommelse, når du beder den om at håndtere meget længere samtaler.

Kilde: Z.ai official announcement

How Good Is GLM-5.3-Flash?

Tabellen nedenfor bevarer de førstegenerations-score, der er mest relevante for udrulning. Z.ai rapporterer højere benchmarkresultater for GLM-5.3-Flash versus GLM-5.2; se CometAPIs modeloversigt for en mere fuldstændig benchmark-fortolkning. Her er den praktiske konklusion, om gevinsterne retfærdiggør lokal hardware og driftsomkostning.

Mønsteret er især relevant for selvhosting: modellens stærkeste anvendelser er ikke afslappet chat, men kode-agenter, værktøjsdrevet automatisering, lang-kontekst dokumentarbejde og multimodale arbejdsflows, hvor dataresidens eller kontrol over infrastrukturen kan retfærdiggøre udrulningsindsatsen.

How Much RAM or VRAM Does GLM-5.3-Flash Need?

Hukommelsesplanlægning er den vigtigste del af denne guide. Den officielle vLLM-opskrift angiver, at det native FP8-checkpoint er cirka 306 GiB FP8-vægte. KTransformers anbefaler derfor at reservere mindst 350 GB tilgængelig systemhukommelse til dens native-FP8 CPU-GPU-vej.

Hvis du bruger GGUF, udgiver Unsloth kvantiseringer fra 1-bit til BF16. Filstørrelsen er ikke det samme som den samlede runtime-hukommelse: du har stadig brug for luft til runtime, modelmetadata, compute-buffere, multimodale komponenter og KV-cache.

Den tredje kolonne er vejledning til udrulningsplanlægning, ikke en officiel minimumsspecifikation. Faktisk pasform afhænger af kontekstlængde, batchstørrelse, runtime, GPU-offload og kvantiseringsimplementering.

Which Local Runtime Should You Use?

Vælg vLLM, når throughput og økosystemkompatibilitet er vigtigst. Vælg SGLang, når du vil benchmarke agentiske, strukturerede output eller multimodal servering. Vælg KTransformers, når modellen ikke kan være i GPU-hukommelsen, men du har hundredvis af gigabytes system-RAM. Vælg llama.cpp eller Ollama, når GGUF-kvantisering og nem lokal eksperimentering er vigtigere end at matche det native checkpoint.

How to Run GLM-5.3-Flash with Native Weights

Run with vLLM

vLLM er den klare produktionsorienterede mulighed, hvis du har serverklasse-acceleratorer. Den aktuelle officielle opskrift understøtter flere paralleliseringsstrategier og dokumenterer native FP8-serving. Behandl de publicerede konfigurationer som referenceopsætninger, ikke som et løfte om, at enhver GPU-kombination vil virke med de samme flag.

Trin 1: Forbered miljøet

Brug Linux med en understøttet NVIDIA-stack, tilstrækkelig samlet GPU-hukommelse til checkpointet plus runtime-overhead, og en nyere vLLM-build eller den container, som den aktuelle opskrift anbefaler. Start med et mindre kontekstvindue under validering fremfor at allokere det fulde vindue på en million tokens med det samme.

Trin 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

Til avancerede udrulninger dokumenterer den officielle vLLM-opskrift FP8 KV-cache på understøttede Blackwell-systemer, MTP spekulativ dekodning, tool-call-parsing, reasoning-parsing og adskillelse af prefill/decode. Tjek den aktuelle vLLM-opskrift før du kopierer flag til produktion, da support kan ændre sig hurtigt.

Trin 3: Test den OpenAI-kompatible endpoint

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"}
    ]
  }'

Run with SGLang

SGLang er en anden førsteklasses serving-rute, der er angivet i den officielle modelkort. Det er særligt værd at teste for høj-samtidighed agenter, struktureret generering, multimodale forespørgsler og værktøjstunge applikationer.

Trin 1: Installer SGLang

pip install sglang

Trin 2: Start modelserveren

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

Trin 3: Verificér endpointet

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 officielle Hugging Face modelkort giver også multimodale forespørgselseksempler til SGLang. Hvis du har brug for værktøjskald, brug de parser-flag, der anbefales af den aktuelle SGLang-opskrift i stedet for at antage, at flag fra en ældre GLM-udgivelse forbliver uændrede.

Run with KTransformers

KTransformers er den vigtigste mulighed for brugere, der fortolker »lokal« som en arbejdsstation snarere end en otte-GPU server. Dens GLM-5.3-Flash-implementering læser de officielle FP8-vægte direkte og udfører heterogen CPU-GPU ekspertinferens.

Den aktuelle tutorial siger, at FP8-modellen optager cirka 306 GiB og anbefaler 350 GB systemhukommelse. Den understøtter NVIDIA SM89 og SM120 GPU'er, inklusive RTX 40- og 50-serien, plus AVX-512 FP8 CPU-ekspertkerner. Tutorialen inkluderer både fire-GPU og enkelt-GPU startkonfigurationer.

En enkelt RTX 4090 eller RTX 5090 kan deltage i inferens, men det gør ikke GLM-5.3-Flash til en 24–32 GB model. Det meste af modellen lever stadig uden for GPU-VRAM, så systemhukommelseskapacitet og -båndbredde bliver centrale for ydeevnen.

Trin 1: Opret et rent Python-miljø

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

Trin 2: Installer KTransformers

pip install "ktransformers[sglang]"

Trin 3: Download de officielle vægte

Download zai-org/GLM-5.3-Flash fra Hugging Face til lokal lagring. Sørg for nok diskplads til checkpointet og nok RAM til den aktive serverkonfiguration.

Trin 4: Start single-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

Tutorialen bruger en valideret 501,025-token konfiguration, selvom modellen understøtter op til 1M kontekst. Det er en nyttig påmindelse: konfigurer den kontekst, du faktisk har brug for, ikke det markedsførte maksimum, fordi kontekst-luft har en direkte hukommelsesomkostning.

Trin 5: Tjek serveren

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

Den OpenAI-kompatible chat-endpoint er ren tekst: http://localhost:30000/v1/chat/completions.

How to Run a Quantized GLM-5.3-Flash GGUF Model

Run GLM-5.3-Flash with llama.cpp

Hvis du ikke vil køre det native FP8-checkpoint, gør GGUF hukommelsesmålet mere fleksibelt. Unsloth udgiver flere GLM-5.3-Flash GGUF-kvantiseringer og giver direkte llama.cpp-kommandoer. Q4_K_XL-builden er cirka 200 GB, så selv denne “forbruger-venlige” rute antager stadig et system med stor hukommelse.

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

Kør direkte i terminalen

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

Hvis din maskine ikke kan rumme Q4_K_XL, findes mindre 3-bit, 2-bit og 1-bit filer. Vælg ikke den laveste bitbredde blot fordi den passer: aggressiv kvantisering kan ændre reasoning-pålidelighed, værktøjskaldsformattering, kodekvalitet og multimodal adfærd. Validér den præcise build på din egen testpakke.

Run GLM-5.3-Flash with Ollama

Ollama er den korteste kommandolinjevej, hvis du allerede bruger den til lokale modeller. Unsloth dokumenterer direkte Hugging Face-loading for sine GLM-5.3-Flash GGUF-builds.

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

Bekvemmeligheden ved Ollama ændrer ikke den underliggende modelstørrelse. Q4_K_XL er stadig cirka 200 GB, og lavere-bit versioner bytter hukommelse for kvalitet. Hvis du kun har 32–64 GB system-RAM, er GLM-5.3-Flash ikke et fornuftigt lokalt mål; brug en mindre model eller et hostet API i stedet.

Choose a GGUF Quantization

Vælg den højest mulige kvalitetskvantisering, der passer med tilstrækkelig luft til runtime og KV-cache. Start med Q4_K_XL, når du har cirka 256 GB eller mere systemhukommelse; overvej lavere-bit builds kun når hardware begrænser, og validér reasoning, kodegenerering, værktøjskald og multimodal adfærd mod et native eller hostet referencepunkt før udrulning.

How to verify Your Local Deployment

En vellykket opstartslog er ikke nok. Test de adfærd, din applikation faktisk afhænger af. En nyttig acceptsekvens er: grundlæggende tekstgenerering, din reelle kontekstlængde, værktøjskald med dine skemaer, multimodal input om nødvendigt og throughput under realistisk samtidighed.

Basic smoke test

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-niveauer og standarden er max. Til benchmark-reproduktion, behold max; til en langsom arbejdsstation kan low eller high gøre iterativ test langt mere praktisk.

Tilføj derefter arbejdsbelastningsspecifikke checks:

• Lang kontekst: send et dokument eller prompt i repository-størrelse tæt på din tiltænkte produktionslængde, ikke 1M som standard.
• Værktøjskald: verificér argument-JSON, værktøjsvalg, recovery efter værktøjsfejl og gentagne kald.
• Multimodal: test de billede- eller videoformater og opløsningsområder, du vil bruge i praksis.
• Samtidighed: mål latens og hukommelse, mens flere forespørgsler er aktive.
• Kvantisering: sammenlign samme prompt-sæt mod et native eller hostet referencepunkt før godkendelse af en lav-bit GGUF-build.

How to Reduce GLM-5.3-Flash Memory Use

Use a smaller context window

Modellen understøtter op til 1M tokens, men de fleste lokale arbejdsflows har ikke brug for så meget kontekst ved hver forespørgsel. Reducér den konfigurerede maksimum, så den matcher din applikation. Dette sænker KV-cache-presset og kan gøre en ustabil udrulning brugbar.

Quantize the weights

At gå fra BF16 til Q8, Q6, Q4 eller lavere-bit GGUF kan reducere vægthukommelse markant. Trade-off'et er outputkvalitet og nogle gange runtime-kompatibilitet, så behandl kvantiseringsniveau som et modelvalg, ikke kun en lagringsmulighed.

Use CPU offload

KTransformers og llama.cpp kan flytte en betydelig del af modeltilstanden til system-RAM. Dette er hovedårsagen til, at enkelt-GPU GLM-5.3-Flash-inferens overhovedet er plausibel, men det flytter også performanceflaskehalsen mod CPU-kapacitet og hukommelsesbåndbredde.

Reduce concurrency

Hver samtidig lang-kontekst forespørgsel forbruger ekstra cache og runtime-buffere. En arbejdsstationsudrulning præsterer ofte bedre med et lille samtidighedsmål og en eksplicit kø end med server-stil parallelisering.

How to Improve Interactive Latency

Til interaktiv lokal brug kan sænkning af reasoning_effort reducere genereret reasoning-længde, responstid og tokenforbrug. Det reducerer ikke den hukommelse, der kræves for at indlæse modelvægtene; det kan kun indirekte reducere cache-brug ved forespørgselstid ved at forkorte den genererede sekvens. Brug low til hurtig iteration, og skift til high eller max, når en opgave kræver dybere reasoning eller benchmark-sammenlignelig adfærd.

Should You Run GLM-5.3-Flash Locally or Use an API?

Selvhosting er attraktivt, når privatliv, dataresidens, offline drift, tilpassede inferensindstillinger eller ejede, ledige hardware-ressourcer betyder noget. Det er mindre attraktivt, når du kun har brug for sporadisk adgang til modellen uden at vedligeholde hundredvis af gigabytes hukommelse og en kompleks serving-stack.

Hvis lokal udrulning ikke er et krav, kan du få adgang til GLM-5.3-Flash via en OpenAI-kompatibel chat-completions-arbejdsgang med model-ID glm-5.3-flash. Dette er nyttigt som et reference-endpoint til at sammenligne din lokale kvantiserede build med en hostet implementering eller som produktionsfallback, 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)

Common Problems When Running GLM-5.3-Flash Locally

The model loads, then crashes on a long prompt

Dette betyder typisk, at du har dimensioneret til vægtene, men ikke til KV-cachen. Reducér kontekstlængde og samtidighed, og øg gradvist, mens du overvåger GPU- og systemhukommelse.

A Q4 file fits on disk but not in RAM

GGUF-filstørrelsen er ikke det fulde runtime-fodaftryk. Efterlad betydelig luft til runtime-buffere, cache og operativsystemet.

Single-GPU KTransformers is extremely slow

Det kan forventes, når det meste ekspertarbejde betjenes fra CPU-hukommelse. Tjek NUMA-placering, hukommelsesbåndbredde, CPU-instruktionssupport, lageradfærd under load, og om din arbejdsbelastning ville være bedre tjent med en mindre kvantiseret model.

Tool calling returns malformed JSON

Bekræft, at dit runtime bruger den parser, der anbefales til den aktuelle GLM-5.3-Flash-integration. Parser-flag kan ændre sig mellem framework-versioner, så genbrug ikke blindt en startkommando skrevet til en ældre GLM-model.

Ollama or llama.cpp starts downloading hundreds of gigabytes

Det er normalt for denne modelfamilie. Verificér kvantiseringstagen før download, bekræft fri diskplads, og tjek den tilsvarende filstørrelse i GGUF-repositoriet først.

FAQ

Can I run GLM-5.3-Flash on an RTX 4090?

Ja, en RTX 4090 kan deltage i KTransformers CPU-GPU heterogen inferens, men 24 GB VRAM er langt fra nok til at rumme hele checkpointet. Den officielle KTransformers FP8-vej kræver stadig cirka 350 GB tilgængelig systemhukommelse.

Can I run GLM-5.3-Flash on an RTX 5090?

Ja, RTX 50-serie GPU'er er eksplicit inkluderet i den aktuelle KTransformers-supportliste. Ligesom med en 4090 er nøglebegrænsningen resten af systemet: RAM-kapacitet, hukommelsesbåndbredde, CPU-support og den mængde kontekst, du allokerer.

Can I run GLM-5.3-Flash with 128 GB RAM?

Kun de mest aggressive GGUF-kvantiseringer nærmer sig det område: Q2_K_XL er cirka 109 GB og IQ2_XXS cirka 102 GB. Når runtime-overhead og KV-cache inkluderes, er 128 GB et meget stramt mål. Det er ikke konfigurationen at vælge, hvis du vil have forudsigelig kvalitet eller lang kontekst.

Can GLM-5.3-Flash run in Ollama?

Ja. Unsloth dokumenterer direkte Ollama-loading for sine GGUF-builds, inklusive UD-Q4_K_XL.

How much VRAM does GLM-5.3-Flash need?

Der er ikke ét korrekt VRAM-tal. Native serverudrulning distribuerer checkpointet på tværs af acceleratorer; KTransformers kombinerer GPU-VRAM med hundredvis af gigabytes system-RAM; llama.cpp kan offloade en kvantiseret GGUF mellem CPU og GPU. Planlæg ud fra det runtime og den kvantisering, du har tænkt at bruge.

Is GLM-5.3-Flash open source?

Den sikreste formulering er åbne vægte under MIT-licens. Det officielle Hugging Face-repository angiver eksplicit MIT-licensen og leverer downloadbare checkpoints.

Is local GLM-5.3-Flash cheaper than the API?

Ikke automatisk. Lokal hosting kan give mening, når du allerede ejer passende hardware, opretholder konsekvent høj udnyttelse, eller skal holde data i din infrastruktur. For intermitterende workloads undgår hostet adgang normalt en stor fast hardware- og driftsbyrde.

Conclusion

GLM-5.3-Flash er usædvanligt effektiv for en model med cirka 320B totale parametre, men “Flash” skal ikke forveksles med “lille.” Dens 18B aktive-parameter MoE-design reducerer compute, mens hybrid lineær og sparsom opmærksomhed gør lang kontekst væsentligt billigere, men vægtene kræver stadig hundredvis af gigabytes, medmindre du bruger aggressiv kvantisering.

Den praktiske udrulningsbeslutning er derfor ligetil: brug vLLM eller SGLang til serverklasse GPU-infrastruktur; brug KTransformers, når du har en meget stor system-RAM arbejdsstation og vil have native FP8 CPU-GPU inferens; brug llama.cpp eller Ollama, når GGUF-kvantisering og nem eksperimentering betyder mest. Hvis ingen af disse hardwareprofiler matcher din maskine, brug et hostet GLM-5.3-Flash-endpoint i stedet for at tvinge en 320B model ind i en uegnet lokal opsætning.