> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/glm5.md).

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/glm5.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.