Leerpad
AI-ingenieur voor datawetenschappers
40 Hr
GLM-5 is Z.ai’s nieuwste open-reasoningmodel en het kreeg snel aandacht dankzij de sterke prestaties bij coderen, agent-workflows en chat met lange context.
Veel developers gebruiken het al om in één keer websites te genereren, kleine apps te bouwen en te experimenteren met lokale AI-agents.
De uitdaging is dat GLM-5 een heel groot model is en lokaal draaien op consumentenhardware niet realistisch is. Zelfs gequantiseerde versies vereisen honderden gigabytes aan geheugen en een capabele GPU-setup.
In deze tutorial laten we een praktische manier zien om GLM-5 lokaal te draaien met een 2-bit GGUF-quant op een NVIDIA H200-pod, het te serven via llama.cpp en het te koppelen aan Aider zodat je GLM-5 als echte code-agent in je eigen projecten kunt gebruiken.
Ik raad ook aan om onze gids te bekijken over GLM 4.7 Flash lokaal draaien.
Vereisten: wat je nodig hebt om GLM-5 te draaien
Voordat je GLM-5 lokaal draait, heb je de juiste modelvariant nodig, genoeg geheugen om het te laden en een werkende GPU-softwarestack.
Hardwarevereisten hangen af van de quant-grootte:
- 2-bit (281GB): past op een systeem met ~300GB verenigd geheugen, of werkt goed met 1×24GB GPU + ~300GB RAM met MoE-offloading
- 1-bit: past op ~180GB RAM
- 8-bit: vereist ~805GB RAM
Voor de beste performance moet je VRAM + systeem-RAM samen in de buurt komen van de quant-grootte. Zo niet, dan kan llama.cpp offloaden naar SSD, maar inferentie wordt trager. Gebruik --fit in llama.cpp om het GPU-gebruik te maximaliseren.
In onze setup draaien we GLM-5-UD-Q2_K_XL op een NVIDIA H200, met genoeg VRAM en systeem-RAM om het model efficiënt te passen.
Softwarevereisten:
- Geïnstalleerde GPU-drivers
- CUDA Toolkit
- Een werkende Python-omgeving
GLM-5 lokaal draaien
Hieronder vind je de stapsgewijze instructies om GLM-5 lokaal te draaien:
1. Richt je lokale omgeving in
Zelfs de 1-bitversie van GLM-5 is te groot voor de meeste consumentenlaptops, dus voor deze tutorial gebruik ik Runpod met een NVIDIA H200 GPU.
Begin met het aanmaken van een nieuwe pod en kies de nieuwste PyTorch-template.
Klik daarna op Edit om de pod-instellingen aan te passen:
- Vergroot de volumedisksize naar 500GB, want ons 2-bitmodel is ~280GB en we hebben extra ruimte nodig voor builds en experimenten.
- Open poort 8080 zodat je de llama.cpp Chat UI direct in je browser kunt openen.
- Voeg je Hugging Face-token toe als omgevingsvariabele om modeldownloads te versnellen (je kunt een token genereren in je Hugging Face-account).
Als alles klopt, bekijk je de pod-samenvatting en klik je op Deploy On-Demand.
Als de pod klaar is, open je JupyterLab, start je een Terminal en werk je vanaf daar. De Jupyter-terminal is handig omdat je soepel meerdere sessies kunt draaien zonder SSH.
Controleer eerst of de GPU beschikbaar is:
nvidia-smi Je zou de H200 in de output moeten zien.
Installeer vervolgens de vereiste Linux-pakketten om llama.cpp te clonen en te bouwen:
sudo apt update
sudo apt install -y git cmake build-essential curl jq2. Compileer llama.cpp met CUDA-ondersteuning
Nu je Runpod-omgeving klaar is en de GPU werkt, is de volgende stap om llama.cpp te installeren en te compileren met CUDA-versnelling, zodat GLM-5 efficiënt kan draaien op de H200.
Ga eerst naar de workspace-map en clone de officiële llama.cpp-repository:
cd /workspace
git clone https://github.com/ggml-org/llama.cpp
cd llama.cppHet is belangrijk om te weten dat de nieuwste stabiele release van llama.cpp GLM-5 nog niet volledig out-of-the-box ondersteunt. Je moet een specifieke upstream pull request binnenhalen met recente changes die nodig zijn voor goede compatibiliteit.
Fetch en checkout de bijgewerkte branch:
git fetch origin pull/19460/head:MASTER && git checkout MASTER && cd ..Configureer vervolgens het build-systeem zodat llama.cpp wordt gecompileerd met CUDA ingeschakeld, waardoor het model GPU-versnelling gebruikt in plaats van volledig op de CPU te draaien.
Draai CMake met de CUDA-vlag aan:
cmake llama.cpp -B llama.cpp/build \
-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
Dit maakt een aparte map build/ aan en zorgt ervoor dat de serverbinaries van llama.cpp NVIDIA GPU-executie ondersteunen.
Als de configuratie klaar is, build je het doel llama-server:
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-server
Deze stap kan enkele minuten duren afhankelijk van de pod, maar daarna heb je een CUDA-ingeschakelde serverbinary klaar om GLM-5 te draaien.
Kopieer tot slot de gecompileerde uitvoerbare bestanden naar de hoofdmap voor makkelijker gebruik:
cp llama.cpp/build/bin/llama-* llama.cpp3. Download het GLM-5-model van Hugging Face
Met llama.cpp gecompileerd en klaar, is de volgende stap het downloaden van de GLM-5 GGUF-modelbestanden van Hugging Face.
Omdat deze modelcheckpoints extreem groot zijn, is het belangrijk om de snelste beschikbare downloadmethoden te gebruiken.
Hugging Face biedt optionele tools zoals hf_xet en hf_transfer, die de downloadsnelheid aanzienlijk verbeteren, vooral op cloudmachines zoals Runpod.
Installeer eerst de vereiste Hugging Face-downloadhulpprogramma’s:
pip -q install -U "huggingface_hub[hf_xet]" hf-xet
pip -q install -U hf_transferMet deze packages kun je sneller parallel downloaden en krijg je betere performance bij het binnenhalen van honderden gigabytes aan modelshards.
Download nu de specifieke gequantiseerde modelvariant die in deze tutorial wordt gebruikt. We willen alleen de UD-Q2_K_XL-bestanden, niet de volledige set uploads:
hf download unsloth/GLM-5-GGUF \
--local-dir models/GLM-5-GGUF \
--include "*UD-Q2_K_XL*"Dit slaat het model direct op in de map models/GLM-5-GGUF.
In onze setup halen downloads snelheden van ongeveer 1,2 GB/s, omdat we hf_xet hebben ingeschakeld en eerder een Hugging Face-token hebben toegevoegd. Anonieme downloads zijn meestal veel trager, dus authenticatie en transferacceleratie instellen maakt een groot verschil bij modellen op deze schaal.
4. Start het GLM-5-model op de enkele GPU
Nu het model gedownload is en llama.cpp met CUDA-ondersteuning is gecompileerd, kunnen we GLM-5 starten met de ingebouwde llama-server.
Voer de volgende opdracht uit om de server te starten:
./llama.cpp/llama-server \
--model models/GLM-5-GGUF/UD-Q2_K_XL/GLM-5-UD-Q2_K_XL-00001-of-00007.gguf \
--alias "GLM-5" \
--host 0.0.0.0 \
--port 8080 \
--jinja \
--fit on \
--threads 32 \
--ctx-size 16384 \
--batch-size 512 \
--ubatch-size 128 \
--flash-attn auto \
--temp 0.7 \
--top-p 0.95Een paar belangrijke argumenten om te begrijpen:
--host 0.0.0.0stelt de server open zodat je er via je browser bij kunt--port 8080komt overeen met de poort die we eerder in Runpod hebben geopend--fit onzorgt voor maximaal GPU-gebruik voordat er naar RAM wordt overgelopen--ctx-size 16384stelt het contextvenster voor inferentie in--flash-attn autoschakelt snellere attention-kernels in wanneer ondersteund
Wanneer je de server start, zie je dat llama.cpp bijna al het beschikbare GPU-geheugen gebruikt, met de resterende modellagen offloaded naar systeem-RAM. Dit is verwacht en werkt goed op H200-setups.
Het model zou binnen een minuut moeten laden en gaan serven. Als je pod aanzienlijk langer nodig heeft, kan er een probleem zijn met de instance. In dat geval is het meestal sneller om de pod te beëindigen en een nieuwe te starten.
Als de server draait, controleer je of GLM-5 beschikbaar is door de OpenAI-compatibele endpoint te bevragen:
curl -s http://127.0.0.1:8080/v1/models | jqJe zou "GLM-5" in de response moeten zien, wat bevestigt dat het model is geladen en klaar is voor gebruik.
{
"models": [
{
"name": "GLM-5",
"model": "GLM-5",
"modified_at": "",
"size": "",
"digest": "",
"type": "model",
"description": "",
"tags": [
""
],
"capabilities": [
"completion"
],
"parameters": "",
"details": {
"parent_model": "",
"format": "gguf",
"family": "",
"families": [
""
],
"parameter_size": "",
"quantization_level": ""
}
}
],
"object": "list",
"data": [
{
"id": "GLM-5",
"object": "model",
"created": 1770900487,
"owned_by": "llamacpp",
"meta": {
"vocab_type": 2,
"n_vocab": 154880,
"n_ctx_train": 202752,
"n_embd": 6144,
"n_params": 753864139008,
"size": 281373251584
}
}
]
}5. Test het GLM-5-model met de chat-UI
Als de server draait, kun je GLM-5 direct testen via de ingebouwde llama.cpp Chat UI.
Normaal is de WebUI lokaal beschikbaar op: http://127.0.0.1:8080
Omdat we echter op Runpod in de cloud draaien, werkt deze localhost-link niet vanaf jouw machine.
Ga in plaats daarvan naar je Runpod-dashboard en klik op de link HTTP Service voor poort 8080. Dit is de publieke URL die verkeer doorstuurt naar je draaiende llama-server.
Die link opent de Chat UI, met het GLM-5-model al geladen en klaar.
Stuur om te bevestigen dat alles werkt een simpel bericht zoals “Hey!!”. Je zou het model direct moeten zien reageren.
In ons geval draait inferentie met ongeveer 8,7 tokens per seconde, wat uitstekend is gezien de grootte van GLM-5 en het gequantiseerde checkpoint van 281GB.
6. Installeer en koppel aan Aider
Aider is een terminalgebaseerde AI-pairprogrammingtool die direct in je projectmap werkt.
Je chat ermee als met een codepartner, en het kan bestanden in je repo aanmaken, bewerken en refactoren, terwijl alles gegrond blijft in je daadwerkelijke codebase en git-workflow.
Het ondersteunt ook koppelen aan elke OpenAI-compatibele API-endpoint, wat het een goede match maakt om tegen onze lokale llama.cpp-server te draaien.
Installeer eerst Aider:
pip install -U aider-chatWijs Aider vervolgens naar je lokale, OpenAI-compatibele llama.cpp-server. We stellen een dummy key in omdat llama.cpp geen echte OpenAI-sleutel vereist:
export OPENAI_API_BASE=http://127.0.0.1:8080/v1
export OPENAI_API_KEY=local
export OPENAI_BASE_URL=$OPENAI_API_BASEMaak nu een nieuwe demoprojectmap aan (zodat Aider een schone repo heeft om in te werken):
mkdir -p glm5-demo-app
cd glm5-demo-appStart ten slotte Aider en koppel het aan GLM-5 met de modelalias die we eerder hebben blootgesteld:
aider --model openai/GLM-5 --no-show-model-warningsVanaf nu gaat alles wat je in Aider vraagt via je lokale GLM-5-server, en Aider past wijzigingen direct toe op bestanden in glm5-demo-app.
Gebruik GLM-5 als je code-agent
Als Aider is gekoppeld aan GLM-5, kun je het gebruiken als code-agent in je repo. Begin met een simpele begroeting om te bevestigen dat het snel reageert.
Geef het daarna een duidelijke taakprompt zoals deze:
Create a simple Python FastAPI project with one /health endpoint, a README, and instructions to run it locally.
Aider stelt eerst een plan voor en vraagt dan om toestemming om wijzigingen toe te passen.
Accepteer de wijzigingen en het genereert de bestanden automatisch.
Bij een 2-bitquant zoals GLM-5-UD-Q2_K_XL kun je kleine foutjes zien, bijvoorbeeld het aanmaken van een bestand als pip install -r requirements.txt, wat een vergissing is. Het volledige model maakt deze fouten minder snel, maar het 2-bitmodel is nog steeds prima bruikbaar met een snelle menselijke review.
Wanneer Aider klaar is met het schrijven van het project, ga je de map in, installeer je de afhankelijkheden en start je de server:
cd glm5-demo-app/pip install -r requirements.txtStart de FastAPI-app met Uvicorn:
uvicorn main:app --reloadDe server draait op poort 8000.
Test de health-endpoint:
curl -s http://127.0.0.1:8000/healthJe zou dit moeten krijgen:
{"status":"ok"}Tot slot
GLM-5 wordt snel een van de meest besproken open-weightmodellen in de AI-community, vooral omdat het open-sourceprestaties dichter bij die van propriëtaire modellen brengt en is ontworpen voor deep reasoning, agent-workflows en codetaken.
Ondanks alle hype is het lokaal draaien van fullscalemodellen nog steeds een uitdaging voor gewone gebruikers.
Zelfs met quantization vereisen modellen zoals GLM-5 honderden gigabytes geheugen en snelle GPU’s, iets wat veel mensen thuis niet hebben.
Dit betekent dat de meesten vertrouwen op cloud-GPU-pods (zoals de H200-setup in deze tutorial) of gehoste API-services.
Het open-weightkarakter van GLM-5 is krachtig omdat je je eigen instance kunt hosten en beheren zonder afhankelijk te zijn van propriëtaire API-providers, maar het benadrukt ook waarom open source in AI niet magisch betekent dat het voor iedereen “op een laptop draait”.
In deze tutorial zagen we hoe je die hardwarebarrières omzeilt met een 2-bit gequantiseerde versie van GLM-5 op een Runpod H200 GPU. We hebben het inrichten van de omgeving doorgenomen, llama.cpp met CUDA-ondersteuning gecompileerd, het model efficiënt gedownload, de inferenceserver gestart, deze via een browser-UI getest en tot slot een codingtool zoals Aider gekoppeld om GLM-5 als agent voor echte ontwikkelingstaken te gebruiken.
