> 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

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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

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](https://clore.ai/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

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

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

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

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

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

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

GLM-5 hat native Unterstützung für Tool-Calling — ideal für den 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": "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](https://clore.ai/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](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)
* [GLM-5-vLLM-Rezept](https://docs.vllm.ai/projects/recipes/en/latest/GLM/GLM5.html)
* [GLM-5-Technikblog](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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.