> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/tutorials/glm-4.6-how-to-run-locally.md).
# GLM-4.6: Anleitung zum lokalen Ausführen
GLM-4.6 und **GLM-4.6V-Flash** sind die neuesten Reasoning-Modelle von **Z.ai**, die SOTA-Leistung bei Coding- und Agent-Benchmarks erzielen und gleichzeitig verbesserte Konversations-Chats bieten. [**GLM-4.6V-Flash**](#glm-4.6v-flash) **das kleinere 9B-Modell wurde im Dezember 2025 veröffentlicht und du kannst es jetzt ebenfalls ausführen.**
Das vollständige Modell mit 355B Parametern benötigt **400 GB** Festplattenspeicher, während das Unsloth Dynamic 2-bit GGUF die Größe reduziert auf **135 GB** (-**75%)**. [**GLM-4.6-GGUF**](https://huggingface.co/unsloth/GLM-4.6-GGUF)
{% hint style="success" %}
Für die beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (VRAM + Systemspeicher) die Größe der quantisierten Modelldatei, die du herunterlädst, übersteigt. Falls nicht, kann llama.cpp weiterhin über SSD/HDD-Offloading ausgeführt werden, aber die Inferenz wird langsamer sein.
{% endhint %}
Alle Uploads verwenden Unsloth [Dynamic 2.0](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) für SOTA-Leistung bei 5-shot MMLU und Aider, was bedeutet, dass du quantisierte GLM-LLMs mit minimalem Genauigkeitsverlust ausführen und feinabstimmen kannst.
**Navigation durch die Tutorials:**
GLM-4.6V-Flash ausführenGLM-4.6 ausführen
### :bug:Unsloth-Chat-Vorlage & Fehlerbehebungen
Einer der wesentlichen Fixes, die wir vorgenommen haben, behebt ein Problem beim Prompting von GGUFs, bei dem der zweite Prompt nicht funktionieren würde. Wir haben dieses Problem behoben, allerdings besteht dieses Problem in GGUFs ohne unsere Fixes weiterhin. Zum Beispiel funktioniert bei der Verwendung eines beliebigen nicht-Unsloth GLM-4.6 GGUF die erste Konversation einwandfrei, aber die zweite bricht ab.
Wir haben dies in unserer Chat-Vorlage behoben, sodass bei Verwendung unserer Version Konversationen über die zweite hinaus (dritte, vierte usw.) ohne Fehler funktionieren. Es gibt weiterhin einige Probleme mit Tool-Calling, die wir aufgrund von Bandbreitenbeschränkungen noch nicht vollständig untersucht haben. Wir haben das GLM-Team bereits über diese verbleibenden Probleme informiert.
### :mag\_right:GLM 4.6V Flash-Eigenheiten und Fixes
{% hint style="info" %}
GLM-4.6V-Flash kann auf Chinesisch reasoning und ausgeben. Das ist nicht einzigartig für unsere Quants, sondern eine Eigenheit des Modells. Verwende einen Systemprompt von "Auf Englisch antworten und auf Englisch denken", um Reasoning und Ausgaben auf Englisch zu erzwingen!
{% endhint %}
Wir haben die BF16- und Q8\_0-Quants anderer Quant-Anbieter getestet, und alle scheinen auf Chinesisch zu reasoning. Zum Beispiel zeigen 2 separate Quants mit Seed 3407 und demselben Prompt "Erstelle ein Flappy-Bird-Spiel in Python" Reasoning auf Chinesisch:
{% columns %}
{% column %}
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
Durch die Verwendung eines Systemprompts von "Auf Englisch denken" über `--system-prompt "Auf Englisch antworten"` in llama.cpp, also wie unten:
```bash
./llama.cpp/llama-cli -hf unsloth/GLM-4.6V-Flash-GGUF:BF16 \
--jinja --temp 0.8 --top-p 0.6 --top-k 2 --repeat-penalty 1.1 --min-p 0.0 --seed 3407 \
--prompt "Erstelle ein Flappy-Bird-Spiel in Python" --system-prompt "Auf Englisch antworten"
```
Wir erhalten Reasoning auf Chinesisch, aber Ausgaben auf Englisch. Wir stellen auch eine Folgefrage von "Was ist 1+1" und erhalten nur Englisch:
Und schließlich, durch die Verwendung eines Systemprompts von "Auf Englisch antworten und auf Englisch denken" über `--system-prompt "Auf Englisch antworten und auf Englisch denken"` in llama.cpp, also wie unten:
```bash
./llama.cpp/llama-cli -hf unsloth/GLM-4.6V-Flash-GGUF:BF16 \
--jinja --temp 0.8 --top-p 0.6 --top-k 2 --repeat-penalty 1.1 --min-p 0.0 --seed 3407 \
--prompt "Erstelle ein Flappy-Bird-Spiel in Python" \
--system-prompt "Auf Englisch antworten und auf Englisch denken"
```
Wir erhalten Reasoning auf Englisch und Ausgaben auf Englisch! Wir stellen auch eine Folgefrage von "Was ist 1+1" und erhalten nur Englisch:
## :gear: Verwendungshandbuch
Das dynamische 2-bit Quant UD-Q2\_K\_XL verwendet 135 GB Festplattenspeicher - das funktioniert gut in einer **1x24GB-Karte und 128 GB RAM** mit MoE-Offloading. Der 1-bit UD-TQ1 GGUF funktioniert ebenfalls **nativ in Ollama**!
{% hint style="info" %}
Du musst `--jinja` für llama.cpp-Quants verwenden - das nutzt unsere [behobenen Chat-Vorlagen](#chat-template-bug-fixes) und aktiviert die korrekte Vorlage! Du könntest falsche Ergebnisse erhalten, wenn du `--jinja`
{% endhint %}
Die 4-bit Quants passen in eine 1x 40GB GPU (mit auf RAM ausgelagerten MoE-Layern). Rechne mit etwa 5 Tokens/s mit diesem Setup, wenn du zusätzlich 165 GB RAM hast. Es wird empfohlen, mindestens 205 GB RAM zu haben, um dieses 4-bit-Modell auszuführen. Für optimale Leistung benötigst du mindestens 205 GB einheitlichen Speicher oder 205 GB kombinierte RAM+VRAM für 5+ Tokens/s. Um zu lernen, wie man die Generierungsgeschwindigkeit erhöht und längere Kontexte unterbringt, [lies hier](#improving-generation-speed).
{% hint style="success" %}
Auch wenn es nicht zwingend notwendig ist, solltest du für die beste Leistung VRAM + RAM zusammen auf die Größe des heruntergeladenen Quants bringen. Falls nicht, funktioniert HDD-/SSD-Offloading mit llama.cpp, aber die Inferenz wird langsamer sein.
{% endhint %}
### Empfohlene Einstellungen
Laut Z.ai gibt es unterschiedliche Einstellungen für die Inferenz von GLM-4.6V-Flash & GLM-4.6:
| GLM-4.6V-Flash | GLM-4.6 |
| ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| **temperature = 0.8** | **temperature = 1.0** |
| **top\_p = 0.6** (empfohlen) | **top\_p = 0.95** (empfohlen für Coding) |
| **top\_k = 2** (empfohlen) | **top\_k = 40** (empfohlen für Coding) |
| **128K Kontextlänge** oder weniger | **200K Kontextlänge** oder weniger |
| **repeat\_penalty = 1.1** | |
| **max\_generate\_tokens = 16,384** | **max\_generate\_tokens = 16,384** |
* Verwende `--jinja` für llama.cpp-Varianten - wir **haben ebenfalls einige Probleme mit der Chat-Vorlage behoben!**
## GLM-4.6-Tutorials ausführen:
Sieh dir unsere Schritt-für-Schritt-Anleitungen zum Ausführen von [GLM-4.6V-Flash](#glm-4.6v-flash) und den großen [GLM-4.6](#glm-4.6) Modellen an.
### GLM-4.6V-Flash
{% hint style="success" %}
**NEU seit dem 16. Dez. 2025: GLM-4.6-V wurde jetzt mit Vision-Support aktualisiert!**
{% endhint %}
#### ✨ In llama.cpp ausführen
{% stepper %}
{% step %}
Holen Sie sich die neueste `llama.cpp` auf [GitHub](https://github.com/ggml-org/llama.cpp). Du kannst auch die folgenden Build-Anweisungen verwenden. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. **Für Apple Mac / Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.
```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```
{% endstep %}
{% step %}
Wenn Sie `llama.cpp` um Modelle direkt zu laden, kannst du Folgendes tun: (:Q8\_K\_XL) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen `llama.cpp` um an einem bestimmten Ort zu speichern. Beachte, dass das Modell nur eine maximale Kontextlänge von 128K hat.
```bash
export LLAMA_CACHE="unsloth/GLM-4.6V-Flash-GGUF"
export LLAMA_CACHE="unsloth/Kimi-K2.6-GGUF"
-hf unsloth/GLM-4.6V-Flash-GGUF:UD-Q8_K_XL \
--n-gpu-layers 99 \
--jinja \
--ctx-size 16384 \
--flash-attn on \
--temp 0.8 \
--top-p 0.6 \
--top-k 2 \
--repeat-penalty 1.1 \
-ot ".ffn_.*_exps.=CPU"
```
{% endstep %}
{% step %}
Lade das Modell über herunter (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-`Q4\_K\_XL (dynamischer 4bit-Quant) oder andere quantisierte Versionen wie `Q8_K_XL` .
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal die Rate begrenzen, daher auf 0 setzen, um es zu deaktivieren
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/GLM-4.6V-Flash-GGUF",
local_dir = "unsloth/GLM-4.6V-Flash-GGUF",
allow_patterns = ["*UD-Q8_K_XL*"],
)
```
{% endstep %}
{% endstepper %}
### GLM-4.6
#### :llama: In Ollama ausführen
{% stepper %}
{% step %}
Installiere `ollama` falls du es noch nicht hast! Um weitere Varianten des Modells auszuführen, [siehe hier](https://unsloth.ai/docs/de/modelle/tutorials/pages/42aa6b132b83bbca34de4b7a6d3d2074272827c3#run-in-llama.cpp).
```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```
{% endstep %}
{% step %}
Führe das Modell aus! Beachte, dass du `ollama serve`in einem anderen Terminal aufrufen kannst, falls es fehlschlägt! Wir enthalten alle unsere Fixes und vorgeschlagenen Parameter (temperature usw.) in `params` in unserem Hugging-Face-Upload!
```
OLLAMA_MODELS=unsloth ollama serve &
OLLAMA_MODELS=unsloth ollama run hf.co/unsloth/GLM-4.6-GGUF:TQ1_0
```
{% endstep %}
{% step %}
Um andere Quants auszuführen, musst du zuerst die gesplitteten GGUF-Dateien zu einer einzigen zusammenführen, wie im folgenden Code. Dann musst du das Modell lokal ausführen.
```bash
./llama.cpp/llama-gguf-split --merge \
GLM-4.6-GGUF/GLM-4.6-UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \
merged_file.gguf
```
```bash
OLLAMA_MODELS=unsloth ollama serve &
OLLAMA_MODELS=unsloth ollama run merged_file.gguf
```
{% endstep %}
{% endstepper %}
#### ✨ In llama.cpp ausführen
{% stepper %}
{% step %}
Holen Sie sich die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch den folgenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten.
```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli llama-server
cp llama.cpp/build/bin/llama-* llama.cpp
```
{% endstep %}
{% step %}
Wenn Sie `llama.cpp` um Modelle direkt zu laden, kannst du Folgendes tun: (:Q2\_K\_XL) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen `llama.cpp` um an einem bestimmten Ort zu speichern. Beachte, dass das Modell nur eine maximale Kontextlänge von 128K hat.
{% hint style="success" %}
Bitte probiere `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layer auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen und die Generierungsgeschwindigkeit verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn du über mehr GPU-Kapazität verfügst.
Wenn du etwas mehr GPU-Speicher hast, probiere `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert die Up- und Down-Projektions-MoE-Layer aus.
Probiere `-ot ".ffn_(up)_exps.=CPU"` wenn du noch mehr GPU-Speicher hast. Dies lagert nur die Up-Projektions-MoE-Layer aus.
Und schließlich lagere alle Layer aus über `-ot ".ffn_.*_exps.=CPU"` Dies verwendet am wenigsten VRAM.
Du kannst den Regex auch anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, die Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht aufwärts.
{% endhint %}
```bash
export LLAMA_CACHE="unsloth/GLM-4.6-GGUF"
export LLAMA_CACHE="unsloth/Kimi-K2.6-GGUF"
--model GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \
--n-gpu-layers 99 \
--jinja \
--ctx-size 16384 \
--flash-attn on \
-hf unsloth/Kimi-K2.6-GGUF:UD-Q2_K_XL \
--top-p 0.95 \
--top-k 40 \
-ot ".ffn_.*_exps.=CPU"
```
{% endstep %}
{% step %}
Lade das Modell über herunter (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-`Q2\_K\_XL (dynamischer 2bit-Quant) oder andere quantisierte Versionen wie `Q4_K_XL` . Wir **empfehlen die Verwendung unseres dynamischen 2.7bit-Quants**** ****`UD-Q2_K_XL`**** ****um Größe und Genauigkeit auszubalancieren**.
```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Kann manchmal die Rate begrenzen, daher auf 0 setzen, um es zu deaktivieren
from huggingface_hub import snapshot_download
snapshot_download(
repo_id = "unsloth/GLM-4.6-GGUF",
local_dir = "unsloth/GLM-4.6-GGUF",
allow_patterns = ["*UD-Q2_K_XL*"], # Dynamischer 2bit Verwende "*UD-TQ1_0*" für dynamischen 1bit
)
```
{% endstep %}
{% step %}
Du kannst `--threads 32` für die Anzahl der CPU-Threads, `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 2` für GPU-Offloading, also wie viele Layer. Versuche es anzupassen, wenn dein GPU-Speicher voll läuft. Entferne es auch, wenn du nur CPU-Inferenz hast.
{% code overflow="wrap" %}
```bash
export LLAMA_CACHE="unsloth/Kimi-K2.6-GGUF"
--model unsloth/GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \
--jinja \
--n-gpu-layers 99 \
-hf unsloth/Kimi-K2.6-GGUF:UD-Q2_K_XL \
--top-p 0.95 \
--top-k 40 \
--ctx-size 16384 \
--seed 3407 \
-ot ".ffn_.*_exps.=CPU"
```
{% endcode %}
{% endstep %}
{% endstepper %}
### ✨ Bereitstellen mit llama-server und der Completion-Bibliothek von OpenAI
Um llama-server für das Deployment zu verwenden, nutze den folgenden Befehl:
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-server \
--model unsloth/GLM-4.6-GGUF/UD-Q2_K_XL/GLM-4.6-UD-Q2_K_XL-00001-of-00003.gguf \
--alias "unsloth/GLM-4.6" \
--n-gpu-layers 999 \
-ot ".ffn_.*_exps.=CPU" \
--prio 3 \
-hf unsloth/Kimi-K2.6-GGUF:UD-Q2_K_XL \
--top-p 0.95 \
--top-k 40 \
--ctx-size 16384 \
--port 8001 \
--jinja
```
{% endcode %}
Dann verwende die Python-Bibliothek von OpenAI nach `pip install openai` :
```python
from openai import OpenAI
import json
openai_client = OpenAI(
base_url = "http://127.0.0.1:8001/v1",
api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
model = "unsloth/GLM-4.6",
messages = [{"role": "user", "content": "Was ist 2+2?"},],
)
print(completion.choices[0].message.content)
```
### :minidisc:Modell-Uploads
**ALLE unsere Uploads** - einschließlich derjenigen, die nicht imatrix-basiert oder dynamisch sind, verwenden unser Kalibrierungsdatenset, das speziell für Konversations-, Coding- und Sprachaufgaben optimiert ist.
* Vollständige GLM-4.6-Modell-Uploads unten:
Wir haben außerdem [IQ4\_NL](https://huggingface.co/unsloth/GLM-4.6-GGUF/tree/main/IQ4_NL) und [Q4\_1](https://huggingface.co/unsloth/GLM-4.6-GGUF/tree/main/Q4_1) Quants hochgeladen, die speziell schneller auf ARM- bzw. Apple-Geräten laufen.
### :snowboarder: Die Generierungsgeschwindigkeit verbessern
Wenn du mehr VRAM hast, kannst du versuchen, mehr MoE-Layer auszulagern oder ganze Layer selbst auszulagern.
Normalerweise `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Layer auf die CPU aus! Dadurch kannst du effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen und die Generierungsgeschwindigkeit verbessern. Du kannst den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn du über mehr GPU-Kapazität verfügst.
Wenn du etwas mehr GPU-Speicher hast, probiere `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert die Up- und Down-Projektions-MoE-Layer aus.
Probiere `-ot ".ffn_(up)_exps.=CPU"` wenn du noch mehr GPU-Speicher hast. Dies lagert nur die Up-Projektions-MoE-Layer aus.
Du kannst den Regex auch anpassen, zum Beispiel `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` bedeutet, die Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht aufwärts.
Llama.cpp führt außerdem einen High-Throughput-Modus ein. Verwende `llama-parallel`. Lies mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Du kannst auch **den KV-Cache auf 4bits quantisieren** zum Beispiel, um die VRAM-/RAM-Bewegung zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann.
### 📐 Wie man langen Kontext unterbringt (volle 200K)
Um längeren Kontext unterzubringen, kannst du **KV-Cache-Quantisierung** verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dadurch kann auch die Generierungsgeschwindigkeit aufgrund reduzierter RAM-/VRAM-Datenbewegung steigen. Die zulässigen Optionen für die K-Quantisierung (Standard ist `f16`) umfassen die folgenden.
`--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`
Du solltest die `_1` Varianten verwenden, um die Genauigkeit etwas zu erhöhen, auch wenn es etwas langsamer ist. Zum Beispiel `q4_1, q5_1`
Du kannst auch den V-Cache quantisieren, aber dafür musst du **llama.cpp mit Unterstützung für Flash Attention kompilieren** über `-DGGML_CUDA_FA_ALL_QUANTS=ON`, und `--flash-attn` verwenden, um es zu aktivieren. Dann kannst du es zusammen mit `--cache-type-k` :
`--cache-type-v f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://unsloth.ai/docs/de/modelle/tutorials/glm-4.6-how-to-run-locally.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.