# GLM-5.1 - So führst du es lokal aus
GLM-5.1 ist Z.ais neues Open-Model. Im Vergleich zu [GLM-5](https://unsloth.ai/docs/de/modelle/tutorials/glm-5)bringt es deutliche Verbesserungen bei Coding, agentischer Tool-Nutzung, Schlussfolgerung, Rollenspiel, langfristigen agentischen Aufgaben und der allgemeinen Chatqualität.
Das vollständige GLM-5.1-Modell mit 744B Parametern (40B aktiv) hat ein **200K-Kontext** Fenster und benötigt **1,65 TB** Festplattenspeicher. Unsloth Dynamic 2-Bit GGUF reduziert die Größe auf **220 GB** **(-80%)**und dynamisch **1-Bit sind es 200 GB (-85 %):** [**GLM-5.1-GGUF**](https://huggingface.co/unsloth/GLM-5.1-GGUF)
Alle Uploads verwenden Unsloth [Dynamic 2.0](https://unsloth.ai/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs) für SOTA-Quantisierungsleistung – daher werden bei niedrigeren Bits wichtige Schichten auf 8- oder 16-Bit hochgestuft. Danke an Z.ai, dass Unsloth Zugang vom ersten Tag an erhalten hat.
{% hint style="info" %}
**NICHT** die CUDA-13.2-Runtime für irgendein GGUF verwenden, da dies zu schlechten Ausgaben führt.
{% endhint %}
#### :gear: Nutzungshandbuch
Die mittlere 2-Bit-Dynamic-Quantisierung `UD-IQ2_M` verwendet **236 GB** Festplattenspeicher – das kann direkt auf einen **Mac mit 256 GB Unified Memory** passen und funktioniert gut mit **1x24-GB-GPU** und **256 GB RAM** mit MoE-Auslagerung. Die **1-Bit** Quantisierung passt in 220 GB RAM, und 8-Bit benötigt 805 GB RAM.
{% hint style="success" %}
Für beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (VRAM + Systemspeicher) die Größe der quantisierten Modelldatei übersteigt, die du herunterlädst. Falls nicht, kann llama.cpp weiterhin über SSD/HDD-Auslagerung laufen, aber die Inferenz wird langsamer sein.
{% endhint %}
### Empfohlene Einstellungen
Verwende unterschiedliche Einstellungen für verschiedene Anwendungsfälle:
| Standard-Einstellungen (die meisten Aufgaben) | Terminal Bench |
| --------------------------------------------- | ------------------------ |
| `temperature` = 1.0 | `temperature` = 0.7 |
| `top_p` = 0.95 | `top_p` = 1.0 |
| max. neue Tokens = 131072 | max. neue Tokens = 16384 |
* **Maximales Kontextfenster:** `202,752`.
* In GLM-5.1 ist Thinking standardmäßig aktiviert. Um Thinking zu deaktivieren:
{% code expandable="true" %}
```bash
--chat-template-kwargs '{"enable_thinking":false}'
```
{% endcode %}
#### Aktualisierung der Chat-Vorlage
GLM-5.1 verwendet dieselbe Architektur wie GLM-5, nur `chat_template.jinja` ist anders.
* Unterstützt Claudes Such-Tool. Tools mit `defer_loading=True` werden aus dem System-Prompt weggelassen und stattdessen in den Tool-Ergebnissen angezeigt.
* Leere Reasoning-Blöcke zulassen (``) in Assistenten-Nachrichten. Aufeinanderfolgende Assistenten-Nachrichten müssen im selben Modus bleiben, entweder mit Thinking oder ohne Thinking.
* Insgesamt verbessert GLM-5.1 vor allem die Tool-Exposition, die Rekonstruktion der Reasoning-Historie und das Rendern von Tool-Nachrichten.
## GLM-5.1-Tutorials ausführen:
Du kannst GLM-5.1 jetzt in [llama.cpp](#run-in-llama.cpp) und [Unsloth Studio](#run-in-unsloth-studio).
### 🦥 In Unsloth Studio ausführen
GLM-5.1 kann jetzt in [Unsloth Studio](https://unsloth.ai/docs/de/neu/studio)unserer neuen Open-Source-Web-UI für lokale KI ausgeführt werden. Mit Unsloth Studio kannst du Modelle lokal auf **MacOS, Windows**, Linux und:
{% columns %}
{% column %}
* Suchen, herunterladen, [GGUFs ausführen](https://unsloth.ai/docs/de/neu/studio#run-models-locally) und Safetensor-Modelle
* [**Selbstheilendes** Tool-Calling](https://unsloth.ai/docs/de/neu/studio#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](https://unsloth.ai/docs/de/neu/studio#run-models-locally) (Python, Bash)
* [Automatische Inferenz](https://unsloth.ai/docs/de/neu/studio#model-arena) Parameter-Tuning (Temp, Top-P usw.)
* Verwendet llama.cpp für schnelle CPU- + GPU-Inferenz und CPU-Auslagerung
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% stepper %}
{% step %}
#### Unsloth installieren
Führe dies in deinem Terminal aus:
**MacOS, Linux, WSL:**
```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```
**Windows PowerShell:**
```bash
irm https://unsloth.ai/install.ps1 | iex
```
{% endstep %}
{% step %}
#### Unsloth starten
**MacOS, Linux, WSL und Windows:**
```bash
unsloth studio -H 0.0.0.0 -p 8888
```
**Dann öffne `http://localhost:8888` in deinem Browser.**
{% endstep %}
{% step %}
#### GLM-5.1 suchen und herunterladen
Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen.
Du kannst `UD-Q2_K_XL` (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie `UD-Q4_K_XL` wählen. Wir **empfehlen unsere dynamische 2-Bit-Quantisierung**** ****`UD-Q2_K_XL`**** ****zu verwenden, um Größe und Genauigkeit auszubalancieren**. Falls Downloads hängen bleiben, siehe [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention")
Dann gehe zum [Studio Chat](https://unsloth.ai/docs/de/neu/studio/chat) Tab und suche in der Suchleiste nach GLM-5.1 und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter. Der Download wird aufgrund der Größe etwas dauern, also bitte warten. Um eine schnelle Inferenz sicherzustellen, stelle sicher, dass du [genügend RAM/VRAM](#usage-guide)hast; andernfalls funktioniert die Inferenz weiterhin, aber Unsloth lagert auf deine CPU aus.
{% endstep %}
{% step %}
#### GLM-5.1 ausführen
Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst außerdem die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.
Für weitere Informationen kannst du unseren [Inferenzleitfaden für Unsloth Studio](https://unsloth.ai/docs/de/neu/studio/chat).
{% endstep %}
{% endstepper %}
### 🦙 In llama.cpp ausführen
{% stepper %}
{% step %}
Besorge dir die neueste `llama.cpp` **auf** [**GitHub hier**](https://github.com/ggml-org/llama.cpp). Du kannst auch die Build-Anweisungen unten befolgen. Ä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` 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
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 verwenden möchtest `llama.cpp` direkt zum Laden von Modellen, kannst du Folgendes tun: (:`IQ2_M`) ist der Quantisierungstyp. Du kannst auch über Hugging Face herunterladen (Punkt 3). Das ist ähnlich wie `ollama run` . Verwende `export LLAMA_CACHE="folder"` um `llama.cpp` zu zwingen, an einem bestimmten Ort zu speichern. Denke daran, dass das Modell nur eine maximale Kontextlänge von 200K hat.
Folge dies für **allgemeine Anweisungen** Anwendungsfälle:
```bash
export LLAMA_CACHE="unsloth/GLM-5.1-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/GLM-5.1-GGUF:UD-IQ2_M \
--ctx-size 16384 \
--temp 0.7 \
--top-p 1.0
```
Folge dies für **Tool-Calling** Anwendungsfälle:
```bash
export LLAMA_CACHE="unsloth/GLM-5.1-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/GLM-5.1-GGUF:UD-IQ2_M \
--ctx-size 16384 \
--temp 1.0 \
--top-p 0.95
```
{% endstep %}
{% step %}
Lade das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst `UD-Q2_K_XL` (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie `UD-Q4_K_XL` wählen. Wir **empfehlen unsere dynamische 2-Bit-Quantisierung**** ****`UD-Q2_K_XL`**** ****zu verwenden, um Größe und Genauigkeit auszubalancieren**. Falls Downloads hängen bleiben, siehe [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention")
```bash
pip install -U huggingface_hub
hf download unsloth/GLM-5.1-GGUF \
--local-dir unsloth/GLM-5.1-GGUF \
--include "*UD-IQ2_M*" # Verwende "*UD-TQ1_0*" für Dynamic 1bit
```
{% endstep %}
{% step %}
Du kannst `--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-Auslagerung, wie viele Schichten. Versuche, dies anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne es außerdem, wenn du nur CPU-Inferenz verwendest.
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--model unsloth/GLM-5.1-GGUF/UD-IQ2_M/GLM-5.1-UD-IQ2_M-00001-of-00006.gguf \
--temp 1.0 \
--top-p 0.95 \
--ctx-size 16384 \
--seed 3407
```
{% endcode %}
{% endstep %}
{% endstepper %}
#### 🦙 Llama-Server-Bereitstellung & OpenAIs Completion-Bibliothek
Um GLM-5 für den produktiven Einsatz bereitzustellen, verwenden wir `llama-server` In einem neuen Terminal, zum Beispiel via tmux, stelle das Modell bereit mit:
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-server \
--model unsloth/GLM-5.1-GGUF/UD-IQ2_M/GLM-5.1-UD-IQ2_M-00001-of-00006.gguf \
--alias "unsloth/GLM-5.1" \
--prio 3 \
--temp 1.0 \
--top-p 0.95 \
--ctx-size 16384 \
--port 8001
```
{% endcode %}
Dann in einem neuen Terminal, nach `pip install openai`, führe Folgendes aus:
{% code overflow="wrap" %}
```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-5.1",
messages = [{"role": "user", "content": "Erstelle ein Snake-Spiel."},],
)
print(completion.choices[0].message.content)
```
{% endcode %}
Anschließend kannst du das bereitgestellte Modell über die OpenAI-API aufrufen:
```python
from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # oder AsyncOpenAI
api_key = openai_api_key,
base_url = openai_api_base,
)
```
### :hammer:Tool-Calling mit GLM-5.1
Siehe [tool-calling-guide-for-local-llms](https://unsloth.ai/docs/de/grundlagen/tool-calling-guide-for-local-llms "mention") für weitere Details dazu, wie Tool-Calling durchgeführt wird. In einem neuen Terminal (bei Verwendung von tmux nutze CTRL+B+D) erstellen wir einige Tools wie das Addieren von 2 Zahlen, das Ausführen von Python-Code, das Ausführen von Linux-Funktionen und vieles mehr:
{% code expandable="true" %}
```python
import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
return float(a) * float(b)
def substract_number(a: float | str, b: float | str) -> float:
return float(a) - float(b)
def write_a_story() -> str:
return random.choice([
"Vor langer, langer Zeit in einer weit, weit entfernten Galaxie...",
"Es gab 2 Freunde, die Faultiere und Code liebten...",
"Die Welt ging unter, weil jedes Faultier sich zu übermenschlicher Intelligenz entwickelte...",
"Ohne es dem einen Freund zu sagen, programmierte der andere versehentlich ein Programm, um Faultiere weiterzuentwickeln...",
])
def terminal(command: str) -> str:
if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
msg = "Kann die Befehle 'rm, sudo, dd, chmod' nicht ausführen, da sie gefährlich sind"
print(msg); return msg
print(f"Führe Terminalbefehl `{command}` aus")
try:
return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
except subprocess.CalledProcessError as e:
return f"Befehl fehlgeschlagen: {e.stderr}"
def python(code: str) -> str:
data = {}
exec(code, data)
del data["__builtins__"]
return str(data)
MAP_FN = {
"add_number": add_number,
"multiply_number": multiply_number,
"substract_number": substract_number,
"write_a_story": write_a_story,
"terminal": terminal,
"python": python,
}
tools = [
{
"type": "function",
"function": {
"name": "add_number",
"description": "Addiere zwei Zahlen.",
"parameters": {
"type": "object",
"properties": {
"a": {
"type": "string",
"description": "Die erste Zahl.",
},
"b": {
"type": "string",
"description": "Die zweite Zahl.",
},
},
"required": ["a", "b"],
},
},
},
{
"type": "function",
"function": {
"name": "multiply_number",
"description": "Multipliziere zwei Zahlen.",
"parameters": {
"type": "object",
"properties": {
"a": {
"type": "string",
"description": "Die erste Zahl.",
},
"b": {
"type": "string",
"description": "Die zweite Zahl.",
},
},
"required": ["a", "b"],
},
},
},
{
"type": "function",
"function": {
"name": "substract_number",
"description": "Subtrahiere zwei Zahlen.",
"parameters": {
"type": "object",
"properties": {
"a": {
"type": "string",
"description": "Die erste Zahl.",
},
"b": {
"type": "string",
"description": "Die zweite Zahl.",
},
},
"required": ["a", "b"],
},
},
},
{
"type": "function",
"function": {
"name": "write_a_story",
"description": "Schreibt eine zufällige Geschichte.",
"parameters": {
"type": "object",
"properties": {},
"required": [],
},
},
},
{
"type": "function",
"function": {
"name": "terminal",
"description": "Führe Operationen im Terminal aus.",
"parameters": {
"type": "object",
"properties": {
"command": {
"type": "string",
"description": "Der Befehl, den du ausführen möchtest, z. B. `ls`, `rm`, ...",
},
},
"required": ["command"],
},
},
},
{
"type": "function",
"function": {
"name": "python",
"description": "Rufe einen Python-Interpreter mit etwas Python-Code auf, der ausgeführt wird.",
"parameters": {
"type": "object",
"properties": {
"code": {
"type": "string",
"description": "Der auszuführende Python-Code",
},
},
"required": ["code"],
},
},
},
]
```
{% endcode %}
Dann verwenden wir die folgenden Funktionen (kopieren und einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell aufrufen:
{% code overflow="wrap" expandable="true" %}
```python
from openai import OpenAI
def unsloth_inference(
messages,
temperature = 1.0,
top_p = 0.95,
top_k = -1,
min_p = 0.01,
repetition_penalty = 1.0,
):
messages = messages.copy()
openai_client = OpenAI(
base_url = "http://127.0.0.1:8001/v1",
api_key = "sk-no-key-required",
)
model_name = next(iter(openai_client.models.list())).id
print(f"Verwende Modell = {model_name}")
has_tool_calls = True
original_messages_len = len(messages)
while has_tool_calls:
print(f"Aktuelle Nachrichten = {messages}")
response = openai_client.chat.completions.create(
model = model_name,
messages = messages,
temperature = temperature,
top_p = top_p,
tools = tools if tools else None,
tool_choice = "auto" if tools else None,
extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
)
tool_calls = response.choices[0].message.tool_calls or []
content = response.choices[0].message.content or ""
tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
for tool_call in tool_calls:
fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
out = MAP_FN[fx](**json.loads(args))
messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
else:
has_tool_calls = False
return messages
```
{% endcode %}
Nach dem Start von GLM 5.1 über `llama-server` wie in [#deploy-with-llama-server-and-openais-completion-library](#deploy-with-llama-server-and-openais-completion-library "mention") oder siehe [tool-calling-guide-for-local-llms](https://unsloth.ai/docs/de/grundlagen/tool-calling-guide-for-local-llms "mention") für weitere Details können wir dann einige Tool-Aufrufe durchführen.
### 📊 Benchmarks
Weiter unten kannst du die GLM-5.1-Benchmarks im Tabellenformat ansehen:
| Benchmark | GLM-5.1 | GLM-5 | Qwen3.6-Plus | Minimax M2.7 | DeepSeek-V3.2 | Kimi K2.5 | Claude Opus 4.6 | Gemini 3.1 Pro | GPT-5.4 |
| ------------------------------------------- | ------------------ | ------------------ | ------------ | ------------------ | ------------------ | --------- | --------------- | -------------- | ---------------- |
| HLE | 31.0 | 30.5 | 28.8 | 28.0 | 25.1 | 31.5 | 36.7 | **45.0** | 39.8 |
| HLE (mit Tools) | 52.3 | 50.4 | 50.6 | - | 40.8 | 51.8 | **53.1**\* | 51.4\* | 52.1\* |
| AIME 2026 | 95.3 | 95.4 | 95.1 | 89.8 | 95.1 | 94.5 | 95.6 | 98.2 | **98.7** |
| HMMT Nov. 2025 | 94.0 | **96.9** | 94.6 | 81.0 | 90.2 | 91.1 | 96.3 | 94.8 | 95.8 |
| HMMT Feb. 2026 | 82.6 | 82.8 | 87.8 | 72.7 | 79.9 | 81.3 | 84.3 | 87.3 | **91.8** |
| IMOAnswerBench | 83.8 | 82.5 | 83.8 | 66.3 | 78.3 | 81.8 | 75.3 | 81.0 | **91.4** |
| GPQA-Diamond | 86.2 | 86.0 | 90.4 | 87.0 | 82.4 | 87.6 | 91.3 | **94.3** | 92.0 |
| SWE-Bench Pro | **58.4** | 55.1 | 56.6 | 56.2 | - | 53.8 | 57.3 | 54.2 | 57.7 |
| NL2Repo | 42.7 | 35.9 | 37.9 | 39.8 | - | 32.0 | **49.8** | 33.4 | 41.3 |
| Terminal-Bench 2.0 (Terminus-2) | 63.5 | 56.2 | 61.6 | - | 39.3 | 50.8 | 65.4 | **68.5** | - |
| Terminal-Bench 2.0 (beste selbstberichtete) | 66.5 (Claude Code) | 56.2 (Claude Code) | - | 57.0 (Claude Code) | 46.4 (Claude Code) | - | - | - | **75.1** (Codex) |
| CyberGym | **68.7** | 48.3 | - | - | 17.3 | 41.3 | 66.6 | - | - |
| BrowseComp | **68.0** | 62.0 | - | - | 51.4 | 60.6 | - | - | - |
| BrowseComp (mit Context Manage) | 79.3 | 75.9 | - | - | 67.6 | 74.9 | 84.0 | **85.9** | 82.7 |
| τ³-Bench | 70.6 | 69.2 | 70.7 | 67.6 | 69.2 | 66.0 | 72.4 | 67.1 | **72.9** |
| MCP-Atlas (öffentlicher Datensatz) | 71.8 | 69.2 | **74.1** | 48.8 | 62.2 | 63.8 | 73.8 | 69.2 | 67.2 |
| Tool-Decathlon | 40.7 | 38.0 | 39.8 | 46.3 | 35.2 | 27.8 | 47.2 | 48.8 | **54.6** |
| Vending Bench 2 | $5,634.00 | $4,432.12 | $5,114.87 | - | $1,034.00 | $1,198.46 | **$8,017.59** | $911.21 | $6,144.18 |
