GLM-5 Lokal Kostenlos Ausführen

Sie möchten auf eines der leistungsfähigsten offenen Modelle von 2026 zugreifen – GLM-5 von Z.ai – ohne einen einzigen Cent für API-Aufrufe oder Cloud-Computing zu bezahlen. Ingenieure und Entwickler erreichen dies heute, indem sie GLM-5 lokal auf Consumer- und Prosumer-Hardware ausführen. Die aggressive Quantisierung von Unsloth schrumpft das 744B-Parameter (40B aktiv) Mixture-of-Experts-Modell von 1,65 TB auf nur 241 GB, und Sie können es über llama.cpp, Ollama oder vLLM bereitstellen.

Sie führen GLM-5 lokal aus! Der Prozess erfordert Aufmerksamkeit für die Hardware, präzise Build-Schritte und intelligente Offloading-Strategien. Dieser Leitfaden führt Sie durch jede Methode, erklärt, warum jeder Befehl wichtig ist, und zeigt Ihnen, wie Sie die maximale Leistung aus Ihrem Setup herausholen. Sie erhalten volle Datenhoheit, keine Latenz für Agenten-Workflows und unbegrenzte Inferenz.

Was macht GLM-5 zu einem Game Changer für die lokale Bereitstellung?

Z.ai hat GLM-5 als Nachfolger von GLM-4.7 veröffentlicht. Das Modell skaliert auf 744 Milliarden Gesamtparameter mit 40 Milliarden aktiven Parametern pro Token und wurde auf 28,5 Billionen Token trainiert. Es liefert modernste Ergebnisse bei Agenten-Benchmarks: 77,8 % auf SWE-bench Verified, 89,7 % auf τ²-Bench und 61,1 % auf Terminal-Bench 2.0 mit Tools.

Sie profitieren von einem 200K Kontextfenster dank DeepSeek Sparse Attention. Das Modell zeichnet sich durch Langzeit-Denken, mehrstufiges Tool-Calling und komplexe Code-Generierung aus. Darüber hinaus ermöglicht Ihnen die offene MIT-Lizenz, es ohne Einschränkungen auszuführen, zu modifizieren und sogar kommerziell zu nutzen.

Das Rohmodell erfordert jedoch 1,65 TB Speicher und massiven VRAM. Unsloth hat das Spiel verändert, indem es Dynamic 2.0 GGUF-Quantisierungen veröffentlichte – UD-IQ2_XXS mit 241 GB (-85 %) und 1-Bit mit 176 GB (-89 %). Diese Versionen bewahren die Denkqualität durch intelligentes Layer-Upcasting und passen gleichzeitig auf einen Mac mit 256 GB Unified Memory oder eine einzelne 24-GB-GPU gepaart mit 256 GB System-RAM.

Sie führen GLM-5 lokal mit diesen Quantisierungen aus, da sie Größe, Geschwindigkeit und Leistungsfähigkeit ausbalancieren. Benchmarks zeigen eine minimale Verschlechterung bei Codierungs- und Agentenaufgaben im Vergleich zur vollen Präzision.

Warum GLM-5 lokal ausführen anstatt Cloud-APIs zu nutzen?

Sie eliminieren wiederkehrende Kosten. Cloud-Anbieter berechnen pro Token, und die Fähigkeiten von GLM-5 machen eine intensive Nutzung schnell teuer. Lokale Inferenz kostet außer Strom nichts.

Sie schützen sensible Daten. Unternehmen und Forscher bewahren proprietären Code, medizinische Aufzeichnungen oder Kundenanfragen vollständig offline auf.

Sie erreichen geringere Latenz. Lokale Modelle antworten in Millisekunden für Chat- und Tool-Aufruf-Loops. Sie können Agenten ohne Netzwerk-Hops verketten.

Sie passen frei an. Sie können mit Unsloth feinabstimmen, Modelfiles in Ollama erstellen oder benutzerdefinierte Tools in vLLM entwickeln.

Darüber hinaus experimentieren Sie ohne Ratenbegrenzungen. Sie können 200K Kontexte testen, 1000-Runden-Gespräche führen oder die Genauigkeit des Tool-Aufrufs über Nacht benchmarken.

Hardware-Anforderungen: Was Sie wirklich brauchen

Sie passen Ihr Setup an die Quantisierungsstufe an.

• 2-Bit UD-IQ2_XXS (241GB): Läuft auf Apple M-Serie mit 256 GB Unified Memory oder NVIDIA 24 GB GPU + 256 GB RAM mit MoE Offloading.
• 1-Bit (176GB): Passt in 180 GB RAM.
• FP8 (vLLM): Erfordert 8×H200 oder Äquivalent – über 800 GB VRAM insgesamt.
• Mindestanforderung: 64 GB RAM + moderne CPU für sehr kleine Kontexte; 128 GB+ empfohlen für praktische Arbeit.

Sie überwachen die Nutzung mit nvidia-smi unter Linux oder dem Aktivitätsmonitor unter macOS. SSD-Speicher beschleunigt das Offloading. Sie reservieren mindestens 50 GB freien Speicherplatz für die Modelldateien und den Cache.

Methode 1: GLM-5 lokal mit Unsloth GGUF in llama.cpp ausführen (Am zugänglichsten)

Sie wählen diesen Weg für maximale Flexibilität und Effizienz auf gemischter Hardware.

Schritt 1: llama.cpp mit GLM-5-Unterstützung erstellen

Sie benötigen das neueste llama.cpp mit zusammengeführtem PR 19460.

apt-get update && apt-get install -y build-essential cmake curl libcurl4-openssl-dev pciutils
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch origin pull/19460/head:MASTER
git checkout MASTER
mkdir build && cd build
cmake .. -DGGML_CUDA=ON  # Use -DGGML_CUDA=OFF for CPU-only
cmake --build . --config Release -j
cd ..
cp build/bin/llama-* .

Sie führen dies einmal aus. Der Build dauert je nach Maschine 10–20 Minuten.

Schritt 2: Das quantisierte Modell herunterladen

Sie verwenden huggingface_hub für schnelle Übertragungen.

pip install -U huggingface_hub hf_transfer
export HF_HUB_ENABLE_HF_TRANSFER=1
hf download unsloth/GLM-5-GGUF --local-dir GLM-5-GGUF --include "*UD-IQ2_XXS*"

Sie haben nun das 241 GB große Modell, aufgeteilt in Shards.

Schritt 3: Inferenz starten

Sie starten die CLI für die interaktive Nutzung.

export LLAMA_CACHE="GLM-5-GGUF"
./llama-cli \
  -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \
  --jinja \
  --ctx-size 32768 \
  --flash-attn on \
  --temp 0.7 \
  --top-p 1.0 \
  --fit on

Sie fügen --threads 32 für CPU-intensive Setups oder -ot ".ffn_.*_exps.=CPU" hinzu, um MoE-Experten auszulagern.

Schritt 4: Als OpenAI API bereitstellen

Sie stellen das Modell für Anwendungen bereit.

./llama-server \
  --model GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \
  --alias "glm-5" \
  --fit on \
  --ctx-size 32768 \
  --port 8000 \
  --jinja

Sie verweisen nun jeden OpenAI-Client auf http://localhost:8000/v1.

Mit diesem Setup erreichen Sie 3–8 Token/Sekunde auf einer 24-GB-GPU. Sie können den Kontext auf 128K skalieren, ohne Abstürze zu verursachen, wenn Sie --fit on verwenden.

Methode 2: GLM-5 lokal mit Ollama ausführen (Am einfachsten für Anfänger)

Sie bevorzugen Einfachheit. Ollama übernimmt Downloads, Quantisierung und Bereitstellung automatisch.

Installation

Sie laden von ollama.com herunter und führen den Installer aus. Unter Linux:

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

GLM-5 herunterladen und ausführen

Sie verwenden den von der Community optimierten Tag.

ollama pull glm-5:cloud
ollama run glm-5:cloud

Sie interagieren direkt im Terminal oder über die API unter http://localhost:11434/v1.

Eine benutzerdefinierte Modelfile erstellen

Sie passen den System-Prompt und die Parameter an.

FROM glm-5:cloud
SYSTEM Sie sind ein erfahrener Softwarearchitekt mit fundierten Kenntnissen verteilter Systeme.
PARAMETER temperature 0.6
PARAMETER num_ctx 131072

Sie erstellen und führen aus:

ollama create my-glm5 -f Modelfile
ollama run my-glm5

Sie integrieren mit Claude Code, Cursor oder Continue.dev, indem Sie den Ollama-Endpunkt einstellen. Sie erhalten eine ausgefeilte lokale Alternative zu Cloud-Codierungsagenten.

Methode 3: Erweiterte Bereitstellung mit vLLM (Maximale Leistung)

Sie benötigen den höchsten Durchsatz für Produktionsagenten.

Sie installieren den Nightly Build:

uv pip install --upgrade vllm --extra-index-url https://wheels.vllm.ai/nightly/cu130

Sie starten den Server (FP8-Version erfordert 8×H200):

vllm serve unsloth/GLM-5-FP8 \
  --served-model-name glm-5 \
  --tensor-parallel-size 8 \
  --kv-cache-dtype fp8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --max-model-len 200000 \
  --gpu-memory-utilization 0.93

Sie aktivieren spekulatives Dekodieren und Tool-Calling. Sie bedienen Tausende von Anfragen pro Minute auf einem Multi-GPU-Cluster.

Ihren lokalen GLM-5 mit Apidog testen und debuggen

Sie verbinden Apidog mit Ihrem Endpunkt und überprüfen, ob alles funktioniert.

Sie erstellen ein neues Projekt, setzen die Basis-URL auf http://localhost:8000/v1 (oder 11434 für Ollama) und definieren den Endpunkt /chat/completions.

Sie erstellen Anfragen visuell:

• Modell: glm-5
• Nachrichten: System + Benutzer
• Temperatur: 0.7
• Tools: JSON-Schemas für den Funktionsaufruf definieren

Sie senden Anfragen, überprüfen Streaming-Antworten und speichern Sammlungen für Regressionstests. Sie generieren sofort Python- oder JavaScript-SDKs. Sie simulieren Antworten für Frontend-Teams.

Apidog verwandelt Ihren lokalen GLM-5 in eine erstklassige Entwicklungsplattform. Sie iterieren an Agenten, validieren Tool-Outputs und messen die Latenz – all das, ohne die Oberfläche zu verlassen.

Leistungsoptimierungstechniken

Sie holen mehr Geschwindigkeit aus Ihrer Hardware heraus.

• Sie aktivieren Flash Attention und --fit on in llama.cpp.
• Sie laden nur MoE-Experten auf die CPU aus, wenn der VRAM knapp ist.
• Sie verwenden 4-Bit für Chats und 2-Bit für Agenten-Codierung.
• Sie setzen --prio 3 im Server für eine höhere Prozesspriorität.
• Sie überwachen mit nvtop oder htop und passen --n-gpu-layers an.

Mit diesen Optimierungen erreichen Sie 15–25 Token/Sekunde auf einem Dual-RTX-4090-Setup.

Häufige Probleme und wie Sie sie beheben

Sie stoßen auf Speicherfehler. Sie reduzieren den Kontext auf 16K oder lagern mehr Schichten aus.

Sie stellen schlechte Tool-Aufrufe fest. Sie setzen die Temperatur auf 1.0 und top-p auf 0.95 und verwenden dann das Flag --tool-call-parser glm47.

Sie erleben langsame Downloads. Sie aktivieren hf_transfer und verwenden einen schnellen Mirror.

Sie erhalten eine CUDA-Speicherfehlermeldung. Sie fügen --gpu-memory-utilization 0.85 hinzu und schließen Hintergrundprozesse.

Sie überprüfen immer die Unsloth-Dokumentation und das GLM-5 GGUF-Repo für die neuesten Shards.

Der Weg nach vorn: Lokales GLM-5 und darüber hinaus

Sie erleben den Übergang zu souveräner KI. Modelle wie GLM-5 beweisen, dass bahnbrechende Fähigkeiten auf Hardware laufen, die Sie bereits besitzen. Sie kombinieren es mit lokalen Vektordatenbanken, Tool-Servern und Agenten-Frameworks, um private, hochleistungsfähige Systeme aufzubauen.

Sie treten der Community auf Hugging Face, Reddit’s r/LocalLLaMA und Unsloth’s Discord bei. Sie teilen Modelfiles, Benchmark-Ergebnisse und benutzerdefinierte Quantisierungen.

Sie führen GLM-5 heute lokal aus. Sie kontrollieren die Rechenleistung, die Daten und die Zukunft Ihres KI-Stacks.

Beginnen Sie mit dem 2-Bit GGUF in llama.cpp. Laden Sie Apidog herunter. Starten Sie den Server. Sie werden erstaunt sein, was Sie alles bauen können, wenn das Modell auf Ihrem Rechner läuft.

Die Ära der wirklich lokalen Frontier-Modelle ist angebrochen. Machen Sie das Beste daraus.