GLM-5

Deploye GLM-5 (744B MoE) von Zhipu AI auf Clore.ai — API-Zugriff und Self-Hosting mit vLLM

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

Hauptfunktionen

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

• Spitzenleistung beim Coding — 77,8 % SWE-bench Verified, 73,3 % SWE-bench Multilingual

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

• Agentische Fähigkeiten — natives Tool-Calling, Funktionsausführung und Aufgabenplanung über lange Horizonte

• Kontextfenster von über 200K — verarbeitet riesige Codebasen und lange Dokumente

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

Anforderungen

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Das Selbst-Hosting von GLM-5 ist ein ernstzunehmendes Unterfangen — der FP8-Checkpoint benötigt ~860 GB VRAM.

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

Clore.ai-Empfehlung: Für die meisten Nutzer, greifen Sie über die API auf GLM-5 zu (Z.AI, OpenRouter). Selbst-Hosting lohnt sich nur, wenn Sie 8× H100/H200 mieten können (Bare Metal auf Clore.ai).

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

Die praktischste Art, GLM-5 von einer Clore.ai-Maschine aus oder von überall zu nutzen:

Über die Z.AI-Plattform

from openai import OpenAI

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

response = client.chat.completions.create(
    model="glm-5",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Schreibe einen Python-Async-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="your-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 High-End-Multi-GPU-Maschinen auf Clore.ai:

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

# Neueste transformers installieren (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": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Löse: Finde alle Primzahlen p, für die p^2 + 2 ebenfalls prim ist"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)

# Ohne Denkmodus (schnellere, kürzere Antworten)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "user", "content": "Schreibe 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 ebenfalls GLM-5 und bietet auf einigen Hardwarekonfigurationen möglicherweise bessere Leistung:

# Mit 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-Schnellstart

# 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-Calling

GLM-5 hat native Unterstützung für Tool-Calling — ideal für den 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": "Aktuelles Wetter für eine Stadt abrufen",
        "parameters": {
            "type": "object",
            "required": ["city"],
            "properties": {
                "city": {"type": "string", "description": "Name der Stadt"}
            }
        }
    }
}]

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, Selbst-Hosting danach: GLM-5 benötigt 8× H200 (Bare Metal auf Clore.ai). Für gelegentliche Nutzung sind die Z.AI API oder OpenRouter weitaus kosteneffizienter. Selbst hosten nur, wenn Sie anhaltenden Durchsatz oder Datenschutz benötigen.

• Stattdessen GLM-4.7 in Betracht ziehen: Wenn 8× H200 zu viel sind, läuft der Vorgänger GLM-4.7 (355B, 32B aktiv) auf 4× H200 oder 4× H100 (~4,16 $/h) und liefert dennoch hervorragende Leistung.

• FP8-Gewichte verwenden: Verwenden Sie immer zai-org/GLM-5-FP8 — gleiche Qualität wie BF16, aber fast nur halb so viel Speicherbedarf. Die BF16-Version benötigt 16× GPUs.

• VRAM-Nutzung überwachen: watch nvidia-smi — Long-Context-Abfragen können den Speicherbedarf stark erhöhen. Stellen Sie --gpu-memory-utilization 0.85 ein, um Spielraum zu lassen.

• Abwägung beim Denkmodus: Der Denkmodus liefert bessere Ergebnisse bei komplexen Aufgaben, verwendet aber 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 141 GB) haben. FP8 benötigt insgesamt etwa 860 GB VRAM.
Langsame Downloads (~800 GB)	Verwende huggingface-cli download zai-org/GLM-5-FP8 mit --local-dir zum Fortsetzen.
vLLM-Versionskonflikt	GLM-5 erfordert vLLM Nightly. Installieren Sie mit pip install -U vllm --pre.
Tool-Aufrufe funktionieren nicht	Fügen Sie --tool-call-parser glm47 --enable-auto-tool-choice zum serve-Befehl.
DeepGEMM-Fehler	Installieren Sie DeepGEMM für FP8: verwenden Sie das install_deepgemm.sh Skript aus dem vLLM-Repo.
Ausgabe im Denkmodus leer	Setze temperature=1.0 — 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

• GLM-5-vLLM-Rezept

• GLM-5-Technikblog

• Slime RL-Infrastruktur