GLM-5

Setzen Sie GLM-5 (744B MoE) von Zhipu AI auf Clore.ai ein — API-Zugang und Self-Hosting mit vLLM

GLM-5, veröffentlicht im Februar 2026 von Zhipu AI (Z.AI), ist ein Mixture-of-Experts mit 744 Milliarden Parametern Sprachmodell, das pro Token nur 40B Parameter aktiviert. Es erreicht erstklassige Open-Source-Leistung bei Reasoning-, Coding- und agentischen Aufgaben — erzielt 77,8 % bei SWE-bench Verified und steht frontier-Modellen wie Claude Opus 4.5 und GPT-5.2 in Konkurrenz. Das Modell ist verfügbar unter MIT-Lizenz auf HuggingFace.

Hauptmerkmale

• 744B gesamt / 40B aktiv — 256-Experten-MoE mit hocheffizientem Routing

• Frontier-Leistung beim Programmieren — 77,8 % SWE-bench Verified, 73,3 % SWE-bench Multilingual

• Tiefes Reasoning — 92,7 % bei AIME 2026, 96,9 % bei HMMT Nov 2025, integrierter Denkmodus

• Agentische Fähigkeiten — native Tool-Aufrufe, Funktionsausführung und Langzeit-Aufgabenplanung

• 200K+ Kontextfenster — verarbeitet massive Codebasen und lange Dokumente

• MIT-Lizenz — vollständig offene Gewichte, kommerzielle Nutzung erlaubt

Anforderungen

GLM-5 selbst zu hosten ist ein ernsthaftes Unterfangen — der FP8-Checkpoint erfordert ~860GB VRAM.

Komponente	Minimum (FP8)	Empfohlen
GPU	8× H100 80GB	8× H200 141GB
VRAM	640GB	1.128GB
RAM	256GB	512GB
Festplatte	1,5TB NVMe	2TB NVMe
CUDA	12.0+	12.4+

Clore.ai-Empfehlung: Für die meisten Nutzer zugreifen Sie auf GLM-5 über die API (Z.AI, OpenRouter). Selbsthosting macht nur Sinn, wenn Sie 8× H100/H200 mieten können (~24–48 $/Tag auf Clore.ai).

API-Zugriff (empfohlen für die meisten Nutzer)

Die praktischste Möglichkeit, GLM-5 von einer Clore.ai-Maschine oder von überall zu nutzen:

Über die Z.AI-Plattform

from openai import OpenAI

client = OpenAI(
    api_key="Ihr-zai-api-key",
    base_url="https://api.z.ai/v1"
)

response = client.chat.completions.create(
    model="glm-5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Schreibe einen asynchronen Python-Web-Scraper mit aiohttp und BeautifulSoup"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)

Über OpenRouter

from openai import OpenAI

client = OpenAI(
    api_key="Ihr-openrouter-key",
    base_url="https://openrouter.ai/api/v1"
)

response = client.chat.completions.create(
    model="zai-org/glm-5",
    messages=[
        {"role": "user", "content": "Erkläre die in GLM-5 verwendete MoE-Architektur"}
    ],
    max_tokens=2048
)
print(response.choices[0].message.content)

vLLM-Setup (Self-Hosting)

Für diejenigen mit Zugang zu hochklassigen Multi-GPU-Maschinen auf Clore.ai:

# Installiere vLLM (Nightly erforderlich für GLM-5-Unterstützung)
pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly

# Installiere neueste transformers (erforderlich)
pip install git+https://github.com/huggingface/transformers.git

FP8 auf 8× H200 GPUs bereitstellen

vllm serve zai-org/GLM-5-FP8 \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --served-model-name glm-5-fp8 \
  --gpu-memory-utilization 0.85

Den Server abfragen

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

# Mit Denkmodus (Standard)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Löse: finde alle Primzahlen p, bei denen p^2 + 2 ebenfalls prim ist"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)

# Ohne Denkmodus (schneller, kürzere Antworten)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "user", "content": "Schreibe einen Quicksort in Rust"}
    ],
    temperature=1.0,
    max_tokens=4096,
    extra_body={
        "chat_template_kwargs": {"enable_thinking": False}
    }
)
print(response.choices[0].message.content)

SGLang-Alternative

SGLang unterstützt GLM-5 ebenfalls und kann auf bestimmter Hardware bessere Leistung bieten:

# Verwendung von Docker (Hopper-GPUs)
docker pull lmsysorg/sglang:glm5-hopper

# Server starten
python3 -m sglang.launch_server \
  --model-path zai-org/GLM-5-FP8 \
  --tp-size 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --mem-fraction-static 0.85 \
  --served-model-name glm-5-fp8

Docker Quick Start

# vLLM-Docker-Image mit GLM-5-Unterstützung
docker run --gpus all -p 8000:8000 \
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:glm5 zai-org/GLM-5-FP8 \
  --tensor-parallel-size 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --served-model-name glm5 \
  --trust-remote-code

Beispiel für Tool-Aufrufe

GLM-5 hat native Tool-Calling-Unterstützung — ideal zum Aufbau agentischer Anwendungen:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Hole die aktuelle Wetterlage für eine Stadt",
        "parameters": {
            "type": "object",
            "required": ["city"],
            "properties": {
                "city": {"type": "string", "description": "Stadtname"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[{"role": "user", "content": "Wie ist das Wetter in Tokio?"}],
    tools=tools,
    tool_choice="auto"
)
print(response.choices[0].message.tool_calls)

Tipps für Clore.ai-Nutzer

• API zuerst, Self-Host zweitens: GLM-5 erfordert 8× H200 (~24–48 $/Tag auf Clore.ai). Für gelegentliche Nutzung ist die Z.AI-API oder OpenRouter weitaus kosteneffizienter. Selbsthosting nur, wenn Sie dauerhaften Durchsatz oder Datenschutz benötigen.

• Erwägen Sie stattdessen GLM-4.7: Wenn 8× H200 zu viel ist, läuft der Vorgänger GLM-4.7 (355B, 32B aktiv) auf 4× H200 oder 4× H100 (~12–24 $/Tag) und liefert weiterhin exzellente Leistung.

• Verwenden Sie FP8-Gewichte: Verwenden Sie immer zai-org/GLM-5-FP8 — gleiche Qualität wie BF16, aber nahezu halbierter Speicherbedarf. Die BF16-Version erfordert 16× GPUs.

• VRAM-Nutzung überwachen: watch nvidia-smi — Abfragen mit langem Kontext können den Speicher hochschnellen lassen. Setzen Sie --gpu-memory-utilization 0.85 um Spielraum zu lassen.

• Kompromiss des Denkmodus: Der Denkmodus liefert bessere Ergebnisse für komplexe Aufgaben, verwendet jedoch mehr Tokens und Zeit. Deaktivieren Sie ihn für einfache Abfragen mit enable_thinking: false.

Fehlerbehebung

Problem	Lösung
OutOfMemoryError beim Start	Stellen Sie sicher, dass Sie 8× H200 (je 141GB) haben. FP8 benötigt insgesamt ~860GB VRAM.
Langsame Downloads (~800GB)	Verwenden Sie huggingface-cli download zai-org/GLM-5-FP8 mit --local-dir um fortzusetzen.
vLLM-Version stimmt nicht überein	GLM-5 erfordert vLLM Nightly. Installieren Sie über pip install -U vllm --pre.
Werkzeugaufrufe funktionieren nicht	Hinzufügen --tool-call-parser glm47 --enable-auto-tool-choice für serve-Befehl.
DeepGEMM-Fehler	Installieren Sie DeepGEMM für FP8: verwenden Sie das install_deepgemm.sh Skript aus dem vLLM-Repo.
Denkmodus liefert leere Ausgabe	Setze temperature=1.0 — der Denkmodus erfordert eine Temperatur ungleich Null.

Weiterführende Lektüre

• GLM-5 auf HuggingFace

• GLM-5 FP8-Checkpoint

• Z.AI-Plattform

• Z.AI API-Dokumentation

• vLLM GLM-5 Rezept

• GLM-5 Technischer Blog

• Slime RL Infrastruktur