# GLM-5

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

```python
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

```python
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:

```bash
# 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

```bash
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

```python
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:

```bash
# 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

```bash
# 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:

```python
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](https://huggingface.co/zai-org/GLM-5)
* [GLM-5 FP8-Checkpoint](https://huggingface.co/zai-org/GLM-5-FP8)
* [Z.AI-Plattform](https://chat.z.ai)
* [Z.AI API-Dokumentation](https://docs.z.ai/guides/llm/glm-5)
* [vLLM GLM-5 Rezept](https://docs.vllm.ai/projects/recipes/en/latest/GLM/GLM5.html)
* [GLM-5 Technischer Blog](https://z.ai/blog/glm-5)
* [Slime RL Infrastruktur](https://github.com/THUDM/slime)