> 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/glm-5-1.md).

# GLM-5.1 (744B MoE, #1 SWE-Bench Pro)

Deploye GLM-5.1 (744B MoE, 40B aktiv) von Z.ai auf Clore.ai — das Open-Weight-Modell, das im April 2026 SWE-Bench Pro anführte

{% hint style="info" %}
**Status (April 2026):** GLM-5.1 wurde veröffentlicht am **7. April 2026** von Z.ai (ehemals Zhipu AI) als eine inkrementelle, aber bedeutende Aktualisierung von [GLM-5](/guides/guides_v2-de/sprachmodelle/glm5.md). Es ist das erste Open-Weight-Modell, das an die Spitze von **SWE-Bench Pro (58,4 %)**, und liegt laut vom Anbieter veröffentlichten Zahlen vor GPT-5.4 (57,7) und Claude Opus 4.6 (57,3). Die Gewichte liegen unter [huggingface.co/zai-org/GLM-5.1](https://huggingface.co/zai-org/GLM-5.1) unter der **MIT-Lizenz**.
{% endhint %}

GLM-5.1 ist ein **744-Milliarden-Parameter-Mixture-of-Experts** Sprachmodell, das nur **\~40 Mrd. Parameter pro Token**. Im Vergleich zu seinem Vorgänger [GLM-5](/guides/guides_v2-de/sprachmodelle/glm5.md), behält die 5.1-Version dasselbe MoE-Gerüst bei, liefert aber verfeinertes Expert Routing, ein **Kontextfenster mit 200K Tokens**, ein **maximale Ausgabe von 131K Tokens**, und ein Training mit Fokus auf **langfristiges agentisches Programmieren** — das Modell ist ausdrücklich darauf abgestimmt, Tausende von Tool-Aufrufen und Hunderte von Refactoring-Runden ohne Abdriften durchzuhalten.

Für Clore.ai-Nutzer ist der interessante Teil die **40B aktiven** Zahl: Sie brauchen kein vollständiges 8×H200-Rack, um es bereitzustellen. Ein Tensor-Parallel-Setup über **2×H100 80GB** (FP8) oder **4×A100 80GB** (BF16 mit Sharding) reicht für praktischen Durchsatz aus — und bringt Coding auf Frontier-Niveau bei [Bare Metal](https://clore.ai/bare-metal) auf dem Marktplatz in Reichweite.

### Wichtige Spezifikationen

| Eigenschaft            | Wert                                                |
| ---------------------- | --------------------------------------------------- |
| Gesamtparameter        | 744B (MoE)                                          |
| Aktive Parameter       | \~40B pro Forward-Pass                              |
| Kontextfenster         | 200.000 Tokens                                      |
| Maximale Ausgabe       | 131.072 Tokens                                      |
| Lizenz                 | MIT                                                 |
| Veröffentlichungsdatum | 7. April 2026                                       |
| Organisation           | Z.ai (zai-org auf HuggingFace)                      |
| Primäre Tools          | vLLM, SGLang, llama.cpp (GGUF), xLLM, KTransformers |

### Warum GLM-5.1?

* **#1 auf SWE-Bench Pro** — 58,4 % laut Anbieter, vor GPT-5.4 und Claude Opus 4.6
* **Agenten mit langem Horizont** — hält die Optimierung über Hunderte von Runden und Tausende von Tool-Aufrufen hinweg aufrecht
* **200K Kontext** — genug für eine komplette Codebasis mittlerer Größe plus Testsuite
* **40B aktive MoE** — Sie zahlen die Inferenzkosten eines 40B-dichten Modells, nicht die eines 744B-Modells
* **MIT-Lizenz** — vollständig offene Gewichte, keine Einschränkungen für kommerzielle Nutzung oder Feintuning
* **Offener Trainings-Stack** — Z.ai hat das Modell veröffentlicht und Berichten zufolge ohne Nvidia-Rechenzentrums-GPUs trainiert

***

## 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 %}

{% hint style="warning" %}
**Immer noch ein großes Modell.** Während „40B active“ freundlich klingt, müssen die vollständigen 744B-Gewichte in den VRAM geladen werden (oder ausgelagert). FP8-Gewichte sind \~860 GB; BF16 ist \~1,5 TB. Planen Sie entsprechend.
{% endhint %}

| Komponente | Minimum (Q4 GGUF, Offload)     | Empfohlen (FP8)                  | Vollständiges BF16 |
| ---------- | ------------------------------ | -------------------------------- | ------------------ |
| GPU-VRAM   | \~80 GB (Q4 + RAM-Auslagerung) | 2× H100 80GB aktiv, 8× insgesamt | 8× H200 141 GB     |
| RAM        | 256 GB                         | 256 GB                           | 512 GB             |
| Festplatte | 500 GB NVMe                    | 1TB NVMe                         | 2 TB NVMe          |
| CUDA       | 12.8+                          | 12.8+                            | 12.8+              |

**Clore.ai-Wahl:** Für die meisten Teams sind 2× H100 80GB mit dem FP8-Checkpoint und aggressivem Offloading der Sweet Spot (\~2,08 $/Std.). Wenn Sie vollen BF16-Durchsatz benötigen, wechseln Sie auf 8× H200 oder nutzen Sie die Z.ai API für gelegentliche Aufrufe.

***

## Option A — Ollama / GGUF (quantisiert, Community-Builds)

{% hint style="warning" %}
**Hinweis:** Community-GGUF-Quants erscheinen typischerweise 1–2 Wochen nach einer Z.ai-Veröffentlichung. Wenn `ollama pull` fehlschlägt, prüfen Sie [huggingface.co/models?search=glm-5.1+gguf](https://huggingface.co/models?search=glm-5.1+gguf) und weisen Sie llama.cpp direkt auf die Datei.
{% endhint %}

```bash
# Sobald ein Q4_K_M-Build verfügbar ist
docker exec ollama ollama pull glm-5.1:q4_K_M
docker exec ollama ollama run glm-5.1:q4_K_M

# Oder direkt mit llama.cpp auf einer GGUF-Datei
docker run --gpus all -it --rm -p 8080:8080 \\
  -v $(pwd)/models:/models \\
  ghcr.io/ggerganov/llama.cpp:server-cuda \\
  -m /models/glm-5.1-q4_k_m.gguf \\
  --n-gpu-layers 80 --ctx-size 32768 \
  --port 8080 --host 0.0.0.0
```

***

## Option B — vLLM (Produktions-API, empfohlen)

vLLM ist Z.ais primäres Serving-Ziel. Der FP8-Checkpoint (`zai-org/GLM-5.1-FP8`) ist der richtige für Sie — gleiche Qualität wie BF16, etwa die halbe Speichernutzung.

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model zai-org/GLM-5.1-FP8
      --tensor-parallel-size 8
      --max-model-len 65536
      --gpu-memory-utilization 0.88
      --tool-call-parser glm47
      --reasoning-parser glm45
      --enable-auto-tool-choice
      --served-model-name glm-5.1
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

```bash
# API testen
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "glm-5.1",
    "messages": [
      {"role": "system", "content": "Sie sind ein leitender Softwareingenieur."},
      {"role": "user", "content": "Refaktorieren Sie diesen Go-Handler so, dass er context.Context korrekt verwendet, und fügen Sie Wiederholungsversuche hinzu."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0
  }'
```

{% hint style="info" %}
Verwende `--tensor-parallel-size 2` auf 2× H100, wenn Sie knapp mit der GPU-Anzahl sind, aber rechnen Sie mit langsamerem Prefill bei 200K-Kontexten. `--enable-chunked-prefill` hilft sehr.
{% endhint %}

***

## Option C — SGLang (Alternative, oft schneller auf Hopper)

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \
  --model-path zai-org/GLM-5.1-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.88 \\
  --context-length 65536 \\
  --served-model-name glm-5.1
```

SGLangs EAGLE-Spekulativdekodierung bringt bei langen Code-Vervollständigungen typischerweise einen Durchsatzschub von 1,5–2×.

***

## GPU-Empfehlungen für Clore.ai

| Einrichtung    | VRAM     | Erwartete Leistung                    | Clore.ai-Kosten                           |
| -------------- | -------- | ------------------------------------- | ----------------------------------------- |
| 2× H100 80GB   | 160GB    | FP8 mit Auslagerung, \~15–25 Tok/s    | \~2,08 $/h                                |
| 4× A100 80GB   | 320 GB   | BF16 geshardet, \~20–30 Tok/s         | [Bare Metal](https://clore.ai/bare-metal) |
| 8× H100 80 GB  | 640GB    | FP8 vollständig, \~60+ Tok/s          | \~8,32 $/h                                |
| 8× H200 141 GB | 1.128 GB | BF16 vollständig, maximaler Durchsatz | [Bare Metal](https://clore.ai/bare-metal) |

{% hint style="success" %}
**Bestes Preis-Leistungs-Verhältnis:** 2× H100 80GB mit dem FP8-Checkpoint. Sie erhalten Coding-Leistung auf Frontier-Niveau für ungefähr den Preis eines Claude-Opus-Abos — und die Gewichte bleiben auf Ihrem System.
{% endhint %}

***

## Anwendungsfälle

* **Autonome SWE-Agents** — GLM-5.1 wurde ausdrücklich für lange Tool-Calling-Schleifen trainiert; kombinieren Sie es mit etwas wie SWE-agent oder OpenHands
* **Verständnis der Codebasis** — werfen Sie 100K+ Tokens Go/Rust/Python in den Kontext und bitten Sie um Architektur-Reviews
* **RAG mit langem Kontext** — 200K ctx verarbeitet gesamte Produktdokumente + Support-Tickets in einem Rutsch
* **Refactoring-Pipelines** — anhaltende Korrektheit über Hunderte von Dateiänderungen hinweg
* **Orchestrierung von Agenten der Agenten** — verwenden Sie GLM-5.1 als Planer und kleinere Modelle (Qwen3.5-35B, GLM-4.7) als Arbeiter

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig prüfen.** Die folgenden Zahlen stammen aus Z.ais Ankündigung vom 7. April 2026. Unabhängige Reproduktionen auf SWE-Bench Pro laufen noch ein.
{% endhint %}

| Benchmark          | GLM-5.1   | GPT-5.4 | Claude Opus 4.6 | GLM-5 |
| ------------------ | --------- | ------- | --------------- | ----- |
| SWE-Bench Pro      | **58.4%** | 57.7%   | 57.3%           | \~52% |
| SWE-Bench Verified | \~79%     | \~78%   | \~80%           | 77.8% |
| HumanEval          | \~94%     | \~95%   | \~94%           | \~93% |
| LiveCodeBench      | \~72%     | \~73%   | \~70%           | \~68% |

***

## Fehlerbehebung

| Problem                              | Lösung                                                                                                                               |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError` beim Laden        | Der FP8-Checkpoint benötigt insgesamt etwa 860 GB VRAM. Verwenden Sie 8× H100/H200 oder wechseln Sie zu GGUF Q4 mit RAM-Auslagerung. |
| Langsamer HuggingFace-Download       | Verwende `huggingface-cli download zai-org/GLM-5.1-FP8 --local-dir ./weights --resume-download`. Rechnen Sie mit 800 GB+.            |
| Tool-Calls stillschweigend verworfen | Stelle sicher `--tool-call-parser glm47` und `--enable-auto-tool-choice` sind beide in vLLM gesetzt.                                 |
| Thinking-Modus leer                  | Erfordert `temperature=1.0` — Zero-Temp-Sampling bricht die Reasoning-Trace.                                                         |
| vLLM lehnt die Konfiguration ab      | GLM-5.1 benötigt vLLM ≥ 0.7.x (Release April 2026). Verwenden Sie `pip install -U vllm --pre` bei älteren Versionen.                 |
| 200K-Kontext OOMs                    | Beginnen Sie mit `--max-model-len 65536` und füge `--enable-chunked-prefill`; erst erhöhen, wenn stabil.                             |

***

## Nächste Schritte

* **Vorgänger:** [GLM-5](/guides/guides_v2-de/sprachmodelle/glm5.md) — gleiche MoE-Struktur, etwas weniger auf Coden fokussiert
* **Günstigere Alternative:** [Qwen3.5](/guides/guides_v2-de/sprachmodelle/qwen35.md) — dichtes 35B passt auf eine einzelne RTX 4090
* **Alternative mit massivem Kontext:** [DeepSeek V4](/guides/guides_v2-de/sprachmodelle/deepseek-v4.md) — 1M ctx, multimodal, \~1T Parameter
* **Clore.ai-Marktplatz:** [clore.ai/marketplace](https://clore.ai/marketplace) — mieten Sie H100/H200/A100 von [Bare Metal](https://clore.ai/bare-metal)

### Links

* [GLM-5.1 auf HuggingFace](https://huggingface.co/zai-org/GLM-5.1)
* [Z.ai Blog — GLM-5.1-Ankündigung](https://z.ai/blog/glm-5.1)
* [Z.ai Platform (gehostete API)](https://chat.z.ai)
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [SGLang-Repo](https://github.com/sgl-project/sglang)


---

# 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/glm-5-1.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.