# GLM-4.6: Leitfaden zum lokalen Ausführen
GLM-4.6 und **GLM-4.6V-Flash** sind die neuesten Reasoning-Modelle von **Z.ai**, die eine SOTA-Performance bei Coding- und Agent-Benchmarks erzielen und gleichzeitig verbesserte Konversationschats bieten. [**GLM-4.6V-Flash**](#glm-4.6v-flash) **das kleinere 9B-Modell wurde im Dezember 2025 veröffentlicht und du kannst es jetzt auch ausführen.**
Das vollständige Modell mit 355B Parametern benötigt **400 GB** Festplattenspeicher, während 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" %}
Wir haben mehrere [**Korrekturen am Chat-Template**](#unsloth-chat-template-fixes) für GLM-4.6 durchgeführt, um `llama.cpp/llama-cli --jinja` zum Laufen zu bringen – bitte verwende nur `--jinja` ansonsten wird die Ausgabe falsch sein!
Ihr habt nach Benchmarks für unsere Quants gefragt, also zeigen wir Aider-Polyglot-Ergebnisse! Unser Dynamic-3-Bit-DeepSeek-V3.1-GGUF erreicht **75.6%**, und übertrifft damit viele SOTA-LLMs in Vollpräzision. [Mehr lesen.](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs/unsloth-dynamic-ggufs-on-aider-polyglot.md)
{% endhint %}
Alle Uploads verwenden Unsloth [Dynamic 2.0](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) für SOTA-5-Shot-MMLU- und Aider-Performance, was bedeutet, dass Sie quantisierte GLM-LLMs mit minimalem Genauigkeitsverlust ausführen und feinabstimmen können.
**Tutorial-Navigation:**
GLM-4.6V-Flash ausführenGLM-4.6 ausführen
### :bug:Unsloth-Chatvorlage & Fehlerbehebungen
Eine der wichtigen Korrekturen, die wir vorgenommen haben, betrifft ein Problem mit dem Prompting von GGUFs, bei dem der zweite Prompt nicht funktionieren wollte. Wir haben dieses Problem behoben, allerdings besteht es in GGUFs ohne unsere Korrekturen weiterhin. Wenn man zum Beispiel irgendein nicht von Unsloth stammendes GLM-4.6-GGUF verwendet, funktioniert die erste Konversation einwandfrei, aber die zweite bricht ab.
Wir haben dies in unserer Chatvorlage behoben, sodass bei Verwendung unserer Version Konversationen über die zweite hinaus (dritte, vierte usw.) ohne Fehler funktionieren. Es gibt weiterhin einige Probleme mit dem Tool-Calling, die wir aufgrund begrenzter Kapazitäten noch nicht vollständig untersucht haben. Wir haben das GLM-Team bereits über diese verbleibenden Probleme informiert.
### :mag\_right:Eigenheiten und Korrekturen von GLM 4.6V Flash
{% hint style="info" %}
GLM-4.6V-Flash kann auf Chinesisch reasoning und ausgeben. Das ist nicht auf unsere Quants beschränkt, sondern eine Eigenart des Modells. Verwende einen System-Prompt von "Auf Englisch antworten und auf Englisch reasoning", um das Reasoning und die Ausgaben auf Englisch zu erzwingen!
{% endhint %}
Wir haben die BF16- und Q8\_0-Quants anderer Anbieter getestet, und alle scheinen auf Chinesisch zu reasoning. Zum Beispiel zeigen zwei getrennte Quants mit Seed 3407 und mit demselben Prompt "Erstelle ein Flappy-Bird-Spiel in Python" das Reasoning auf Chinesisch:
{% columns %}
{% column %}
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
Durch die Verwendung eines System-Prompts von "Auf Englisch reasoning" ü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 Anschlussfrage von "Was ist 1+1" und erhalten nur Englisch:
Und schließlich erhalten wir durch die Verwendung eines System-Prompts von "Auf Englisch antworten und auf Englisch reasoning" über `--system-prompt "Auf Englisch antworten und auf Englisch reasoning"` 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 reasoning"
```
Wir erhalten Reasoning auf Englisch und Ausgaben auf Englisch! Wir stellen auch eine Anschlussfrage von "Was ist 1+1" und erhalten nur Englisch:
## :gear: Verwendungsleitfaden
Das dynamische 2-Bit-Quant UD-Q2\_K\_XL belegt 135 GB Festplattenspeicher – das funktioniert gut auf einer **1x24GB-Karte und 128GB RAM** mit MoE-Offloading. Das 1-Bit-UD-TQ1-GGUF **funktioniert auch nativ in Ollama**!
{% hint style="info" %}
Sie müssen `--jinja` für llama.cpp-Quants verwenden – das nutzt unsere [festen Chat-Vorlagen](#chat-template-bug-fixes) und aktiviert die korrekte Vorlage! Sie können falsche Ergebnisse erhalten, wenn Sie `--jinja`
{% endhint %}
Die 4-Bit-Quants passen in eine 1x40GB-GPU (mit auf RAM ausgelagerten MoE-Layern). Rechnen Sie mit etwa 5 Tokens/s mit diesem Setup, wenn Sie zusätzlich 165 GB RAM zur Verfügung haben. Es wird empfohlen, mindestens 205 GB RAM zu haben, um dieses 4-Bit-Modell auszuführen. Für optimale Leistung benötigen Sie mindestens 205 GB einheitlichen Speicher oder 205 GB kombinierten RAM+VRAM für 5+ Tokens/s. Um zu erfahren, wie Sie die Generierungsgeschwindigkeit erhöhen und längere Kontexte unterbringen können, [lesen Sie hier](#improving-generation-speed).
{% hint style="success" %}
Obwohl nicht zwingend erforderlich, sollte für beste Leistung VRAM + RAM zusammen der Größe der Quants entsprechen, die Sie herunterladen. Wenn nicht, funktioniert Auslagerung auf Festplatte/SSD mit llama.cpp, nur die Inferenz wird langsamer sein.
{% endhint %}
### Empfohlene Einstellungen
Laut Z.ai gibt es für die Inferenz von GLM-4.6V-Flash und GLM-4.6 unterschiedliche Einstellungen:
| GLM-4.6V-Flash | GLM-4.6 |
| ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| **temperature = 0.8** | **temperature = 1.0** |
| **top\_p = 0.6** (empfohlen) | **top\_p = 0.95** (empfohlen fürs Coding) |
| **top\_k = 2** (empfohlen) | **top\_k = 40** (empfohlen fürs 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 auch einige Probleme mit Chat-Vorlagen 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 des großen [GLM-4.6](#glm-4.6) Modelle.
### GLM-4.6V-Flash
{% hint style="success" %}
**NEU seit dem 16. Dez. 2025: GLM-4.6-V wurde jetzt mit Vision-Unterstützung aktualisiert!**
{% endhint %}
#### ✨ In llama.cpp ausführen
{% stepper %}
{% step %}
Hole dir die neueste `llama.cpp` auf [GitHub](https://github.com/ggml-org/llama.cpp). Du kannst auch die Build-Anweisungen unten verwenden. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest. **Für Apple Mac / Metal-Geräte**, setze `-DGGML_CUDA=OFF` und fahre 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 du `llama.cpp` direkt, um Modelle 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, dass `llama.cpp` an einem bestimmten Ort gespeichert wird. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 128K hat.
```bash
export LLAMA_CACHE="unsloth/GLM-4.6V-Flash-GGUF"
./llama.cpp/llama-cli \
-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 herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-`Q4\_K\_XL (dynamisches 4-Bit-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 eine Ratenbegrenzung auslösen, daher auf 0 setzen, um 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 %}
Installieren Sie `ollama` falls Sie es noch nicht getan haben! Um weitere Varianten des Modells auszuführen, [sehen Sie 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ühren Sie das Modell aus! Beachten Sie, dass Sie `ollama serve`in einem anderen Terminal aufrufen können, falls es fehlschlägt! Wir enthalten alle unsere Korrekturen 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, müssen Sie zuerst die geteilten GGUF-Dateien zu einer einzigen zusammenführen, wie im folgenden Code. Danach müssen Sie 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 %}
Hole dir die neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Du kannst auch den untenstehenden Build-Anweisungen folgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn du keine GPU hast oder nur CPU-Inferenz möchtest.
```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 du `llama.cpp` direkt zum Laden von Modellen verwenden möchten, können Sie Folgendes tun: (:Q2\_K\_XL) ist der Quantisierungstyp. Sie können auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich wie `ollama run` . Verwenden Sie `export LLAMA_CACHE="folder"` um zu erzwingen, dass `llama.cpp` an einem bestimmten Ort gespeichert wird. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 128K hat.
{% hint style="success" %}
Bitte probieren Sie `-ot ".ffn_.*_exps.=CPU"` verwenden, um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.
Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.
Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.
Und schließlich lagern Sie alle Layer aus via `-ot ".ffn_.*_exps.=CPU"` Dies verwendet am wenigsten VRAM.
Sie können 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, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht.
{% endhint %}
```bash
export LLAMA_CACHE="unsloth/GLM-4.6-GGUF"
./llama.cpp/llama-cli \
--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 \
--temp 1.0 \
--top-p 0.95 \
--top-k 40 \\
-ot ".ffn_.*_exps.=CPU"
```
{% endstep %}
{% step %}
Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-`Q2\_K\_XL (dynamisches 2-Bit-Quant) oder andere quantisierte Versionen wie `Q4_K_XL` . Wir **empfehlen unser dynamisches 2,7-Bit-Quant**** ****`UD-Q2_K_XL`**** ****zu verwenden, 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 eine Ratenbegrenzung auslösen, daher auf 0 setzen, um 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*"], # Dynamisches 2-Bit Verwenden Sie "*UD-TQ1_0*" für dynamisches 1-Bit
)
```
{% endstep %}
{% step %}
Sie können `--threads 32` für die Anzahl der CPU-Threads bearbeiten, `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 2` für GPU-Offloading, also für wie viele Layer. Versuchen Sie, dies anzupassen, wenn Ihrem GPU-Speicher der Platz ausgeht. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--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 \
--temp 1.0 \
--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 die Bereitstellung zu verwenden, nutzen Sie 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 \
--temp 1.0 \
--top-p 0.95 \
--top-k 40 \\
--ctx-size 16384 \
--port 8001 \
--jinja
```
{% endcode %}
Verwenden Sie anschließend 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 auf imatrix-basiert oder dynamisch sind, verwenden unseren Kalibrierungsdatensatz, der speziell für Konversations-, Coding- und Sprachaufgaben optimiert ist.
* Die vollständigen Uploads des GLM-4.6-Modells unten:
Wir haben auch [IQ4\_NL](https://huggingface.co/unsloth/DeepSeek-V3.1-GGUF/tree/main/IQ4_NL) und [Q4\_1](https://huggingface.co/unsloth/DeepSeek-V3.1-GGUF/tree/main/Q4_1) Quants hochgeladen, die speziell auf ARM- bzw. Apple-Geräten schneller laufen.
### :snowboarder: Die Generierungsgeschwindigkeit verbessern
Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Layer oder ganze Layer auszulagern.
Normalerweise `-ot ".ffn_.*_exps.=CPU"` lagert alle MoE-Layer auf die CPU aus! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.
Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie `-ot ".ffn_(up|down)_exps.=CPU"` Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.
Versuchen Sie `-ot ".ffn_(up)_exps.=CPU"` wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.
Sie können 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, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht.
Llama.cpp führt außerdem einen High-Throughput-Modus ein. Verwenden Sie `llama-parallel`. Lesen Sie mehr darüber [hier](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Sie können auch **den KV-Cache auf 4 Bit quantisieren** zum Beispiel um den VRAM-/RAM-Datenverkehr zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann.
### 📐Wie man langen Kontext einpasst (volle 200K)
Um längeren Kontext unterzubringen, können Sie **KV-Cache-Quantisierung** verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dies kann auch die Generierungsgeschwindigkeit aufgrund des geringeren RAM-/VRAM-Datenverkehrs erhöhen. Die zulässigen Optionen für die K-Quantisierung (Standard ist `f16`) sind unten aufgeführt.
`--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`
Sie sollten die `_1` Varianten verwenden, um die Genauigkeit etwas zu erhöhen, auch wenn es etwas langsamer ist. Zum Beispiel `q4_1, q5_1`
Sie können auch den V-Cache quantisieren, aber dafür müssen Sie **llama.cpp mit Flash Attention-Unterstützung kompilieren via** -DGGML\_CUDA\_FA\_ALL\_QUANTS=ON `, und`--flash-attn `verwenden, um es zu aktivieren. Dann können Sie es zusammen mit` --cache-type-k `--cache-type-v f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1` :
`verwenden`
---
# Agent Instructions: 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.