GLM-5.1 – Wie man es lokal ausführt

Führe das neue GLM-5.1-Modell von Z.ai auf deinem eigenen lokalen Gerät aus!

GLM-5.1 ist das neue Open-Model von Z.ai. Im Vergleich zu GLM-5, bietet es deutliche Verbesserungen bei Coding, agentischer Tool-Nutzung, Reasoning, Roleplay, langwierigen agentischen Aufgaben und der allgemeinen Chat-Qualitä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 dynamisches 1-Bit ist 200 GB (-85 %): GLM-5.1-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA-Quantisierungsleistung – daher werden bei niedrigeren Bits wichtige Schichten auf 8- oder 16-Bit hochgestuft. Vielen Dank an Z.ai für den Day-Zero-Zugriff auf Unsloth.

⚙️ Nutzungsanleitung

Die mittlere dynamische 2-Bit-Quantisierung UD-IQ2_M verwendet 236 GB Festplattenspeicher – das passt direkt auf einen Mac mit 256 GB Unified Memory und funktioniert gut auf einer 1x24GB-GPU und 256 GB RAM mit MoE-Offloading. Die 1-Bit Quantisierung passt auf 220 GB RAM, und 8-Bit benötigt 805 GB RAM.

Für beste Leistung stelle sicher, dass dein insgesamt verfügbarer Speicher (VRAM + System-RAM) größer ist als die Größe der quantisierten Modelldatei, die du herunterlädst. Wenn nicht, kann llama.cpp immer noch über SSD/HDD-Offloading laufen, aber die Inferenz wird langsamer sein.

Empfohlene Einstellungen

Verwende unterschiedliche Einstellungen für verschiedene Anwendungsfälle:

Standard-Einstellungen (die meisten Aufgaben)	Terminal Bench
Temperatur = 1.0	Temperatur = 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:

    --chat-template-kwargs '{"enable_thinking":false}'

Aktualisierung der Chat-Vorlage

GLM-5.1 verwendet die gleiche Architektur wie GLM-5, nur chat_template.jinja ist anders.

• Unterstützt Claudes Suchwerkzeug. Tools mit defer_loading=True werden aus dem System-Prompt ausgelassen und stattdessen in den Tool-Ergebnissen angezeigt.

• Leere Reasoning-Blöcke erlauben (<think></think>) in Assistant-Nachrichten. Aufeinanderfolgende Assistant-Nachrichten müssen im selben Modus bleiben, entweder Thinking oder Nicht-Thinking.

• Insgesamt verbessert GLM-5.1 vor allem die Tool-Exposition, die Rekonstruktion der Reasoning-Historie und das Rendering von Tool-Nachrichten.

GLM-5.1-Tutorials ausführen:

Du kannst GLM-5.1 jetzt in llama.cpp und Unsloth Studio.

🦥 In Unsloth Studio ausführen

GLM-5.1 kann jetzt in Unsloth 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:

• Suchen, herunterladen, GGUFs ausführen und Safetensor-Modelle

• Selbstheilendes Tool-Calling + Websuche

• Codeausführung (Python, Bash)

• Automatische Inferenz Parametertuning (Temp, Top-P usw.)

• Verwendet llama.cpp für schnelle CPU- + GPU-Inferenz und CPU-Offloading

1

Unsloth installieren

In deinem Terminal ausführen:

MacOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell:

irm https://unsloth.ai/install.ps1 | iex

2

Unsloth starten

MacOS, Linux, WSL und Windows:

unsloth studio -H 0.0.0.0 -p 8888

Dann öffne http://localhost:8888 in deinem Browser.

3

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 auswählen (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie UD-Q4_K_XL . Wir empfehlen unsere dynamische 2-Bit-Quantisierung UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszugleichen. Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

Dann gehe zum Studio Chat Tab und suche in der Suchleiste nach GLM-5.1 und lade dein gewünschtes Modell und deine gewünschte Quantisierung herunter. Aufgrund der Größe dauert der Download etwas, also bitte warten. Um eine schnelle Inferenz sicherzustellen, stelle sicher, dass du genügend RAM/VRAMhast, andernfalls funktioniert die Inferenz weiterhin, aber Unsloth lagert auf deine CPU aus.

4

GLM-5.1 ausführen

Die Inferenzparameter sollten bei Verwendung von Unsloth Studio automatisch gesetzt werden, du kannst sie jedoch weiterhin manuell ändern. Du kannst auch die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.

Weitere Informationen findest du in unserem Unsloth-Studio-Inferenzleitfaden.

🦙 In llama.cpp ausführen

1

Erhalte das neueste llama.cpp auf hier auf GitHub. 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. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF und fahre dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

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

2

Wenn du llama.cpp direkt zum Laden von Modellen verwenden möchtest, 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 erzwingen, dass an einem bestimmten Ort gespeichert wird. Denk daran, dass das Modell maximal nur eine Kontextlänge von 200K hat.

Folge dem hier für allgemeine Anwendungsfälle use-cases:

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 dem hier für Tool-Calling use-cases:

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

3

Lade das Modell herunter über (nach der Installation von pip install huggingface_hub hf_transfer ). Du kannst auswählen UD-Q2_K_XL auswählen (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie UD-Q4_K_XL . Wir empfehlen unsere dynamische 2-Bit-Quantisierung UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszugleichen. Wenn Downloads hängen bleiben, siehe Hugging Face Hub, XET-Debugging

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 dynamisches 1-Bit

4

Du kannst --threads 32 für die Anzahl der CPU-Threads ändern, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 2 für GPU-Offloading, für wie viele Schichten. Versuche, dies anzupassen, wenn deinem GPU der Speicher ausgeht. Entferne es auch, wenn du nur CPU-Inferenz hast.

./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

🦙 Llama-Server-Bereitstellung & OpenAIs Completion-Bibliothek

Um GLM-5.1 produktiv bereitzustellen, verwenden wir llama-server Öffne in einem neuen Terminal, zum Beispiel via tmux, und stelle das Modell bereit mit:

./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

Dann in einem neuen Terminal, nachdem du pip install openaiausgeführt hast:

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)

Du kannst dann das bereitgestellte Modell über die OpenAI-API aufrufen:

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,
)

🔨Tool-Calling mit GLM-5.1

Siehe Tool Calling Guide für weitere Details dazu, wie man Tool-Calling durchführt. In einem neuen Terminal (wenn du tmux verwendest, nutze STRG+B+D) erstellen wir einige Tools wie das Hinzufügen von 2 Zahlen, das Ausführen von Python-Code, das Ausführen von Linux-Funktionen und vieles mehr:

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 subtract_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 sich jedes Faultier so weit entwickelte, dass es übermenschliche Intelligenz hatte...",
        "Ohne es zu wissen, hatte einer der Freunde versehentlich ein Programm geschrieben, 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"Terminalbefehl `{command}` wird ausgeführt")
    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,
    "subtract_number": subtract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Addiert 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": "Multipliziert 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": "subtract_number",
            "description": "Subtrahiert 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ührt Operationen vom 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": "Ruft 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"],
            },
        },
    },
]

Wir verwenden dann die folgenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell aufrufen:

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

Nach dem Start von GLM 5.1 über llama-server wie in GLM-5.1 oder siehe Tool Calling Guide für weitere Details, können wir dann einige Tool-Aufrufe durchführen.

📊 Benchmarks

Weiter unten findest du GLM-5.1-Benchmarks in Tabellenform:

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 (am besten selbst angegeben)	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 Kontextverwaltung)	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