> 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/minimax-m27.md).

# MiniMax M2.7 (229B MoE Coding)

Deploye MiniMax M2.7 (229B MoE) auf Clore.ai — die Open-Weight-Self-Hosted-Version hinter MiniMax' Vorstoß mit dem Coding-Agenten, mit FP8-Single-Node-Deployment auf H100/H200

{% hint style="info" %}
**Status (April 2026):** MiniMax M2.7 wurde am auf HuggingFace veröffentlicht **9. April 2026** von MiniMaxAI und erreichte **496K Downloads in drei Wochen** — nach Verbreitung die größte Open-Weight-Veröffentlichung unseres April-Updates. Die Gewichte liegen unter [huggingface.co/MiniMaxAI/MiniMax-M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7) einer **benutzerdefinierten MiniMax-Lizenz** (`Lizenz: Sonstige`). Es ist **nicht** Apache/MIT — lies [die LICENSE](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) vor jeder kommerziellen Bereitstellung.
{% endhint %}

{% hint style="warning" %}
**Korrektur:** Frühere Versionen unseres Modellindex führten M2.7 als proprietäres Modell nur für APIs auf. Das war am 9. April 2026 falsch — die Gewichte sind öffentlich. Dieser Leitfaden ersetzt diesen Eintrag.
{% endhint %}

MiniMax M2.7 ist ein **229-Milliarden-Parameter-Mixture-of-Experts** Modell (256 Experten, 8 aktiv pro Token) und der neueste Eintrag in MiniMaxs M2-Familie — eine Linie, die um **selbstentwickeltes / RL-gesteuertes Post-Training** und **agentische Codierung** Workloads herum aufgebaut ist. Die 2.7-Version ist das öffentliche, selbst hostbare Gegenstück zu MiniMaxs gehostetem Coding-Agenten und wird von MiniMax als konkurrenzfähig mit Claude Sonnet 4.5 bei agentischen Benchmarks positioniert, während sie sich bei einigen davon Claude-Opus-4.6-Gefilden nähert.

Das interessante architektonische Detail ist **Interleaved Thinking** (eingeführt in M2.1 und verfeinert über 2.5/2.7): Das Modell wechselt `<think>` zwischen Denkblöcken und normaler Generierung über mehrere Tool-Call-Runden hinweg, sodass die Gedankenlinie über Funktionsaufruf-Roundtrips hinweg erhalten bleibt, statt in jeder Runde verworfen zu werden. Das ist es, was es für Agents mit langem Horizont interessant macht — die Denktrace wird nicht jedes Mal zurückgesetzt, wenn du eine `tool_use` -Grenze erreichst.

Für Clore.ai-Nutzer ist die praktische Nachricht, dass M2.7 mit einem **FP8-(float8\_e4m3fn)-Checkpoint** im offiziellen Repo ausgeliefert wird. Damit ist ein Deployment auf einem einzelnen Knoten in Reichweite auf **4× H100 80GB** oder **2× H200 141GB** — keine H200-Octets oder 16-GPU-Racks erforderlich. Wenn du bereits [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) und ein zweites Open-Weight-Modell mit anderem Bias-Profil in deinem Agenten-Stack willst, dann ist das das richtige zum Kombinieren.

### Wichtige Spezifikationen

| Eigenschaft             | Wert                                                                                                                                  |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Gesamtparameter         | 229B (MoE, 256 Experten)                                                                                                              |
| Experten pro Token      | 8 von 256                                                                                                                             |
| Aktive Parameter        | **Nicht offiziell veröffentlicht** — siehe Model Card. Die M2-Familie hatte historisch \~10B aktiv; vor öffentlichem Zitieren prüfen. |
| Hidden Size / Layer     | 3,072 / 62                                                                                                                            |
| Attention               | 48 Köpfe, 8 KV (GQA)                                                                                                                  |
| Kontextfenster          | 204.800 Tokens (200K)                                                                                                                 |
| Tensor-Typen            | F32, BF16, F8\_E4M3                                                                                                                   |
| MTP                     | Multi-Token-Prediction aktiviert (3 MTP-Module)                                                                                       |
| Lizenz                  | **Benutzerdefiniertes MiniMax — standardmäßig nicht-kommerziell**                                                                     |
| Veröffentlichungsdatum  | 9. April 2026                                                                                                                         |
| HF-Downloads (3 Wochen) | \~496K                                                                                                                                |
| Empfohlenes Sampling    | `temperature=1.0`, `top_p=0.95`, `top_k=40`                                                                                           |
| Primäre Tools           | vLLM, SGLang, Transformers, KTransformers, MLX-LM                                                                                     |

### Warum MiniMax M2.7?

* **Offene Gewichte bei 229B** — größtes „echtes“ Open-Weight-Coding-Modell, das noch auf einen einzelnen 4×H100-Knoten in FP8 passt
* **Interleaved Thinking** — `<think>` Blöcke überleben über Tool-Call-Runden hinweg, was für SWE-artige Agenten wirklich nützlich ist
* **Fokus auf Codierung in mehreren Sprachen** — MiniMax vermarktet starke Leistung bei Rust, Go, Java, Kotlin, Swift und TypeScript, nicht nur bei Python
* **Adoptionssignal** — 496K Downloads in drei Wochen sind der stärkste Community-Start jeder von uns verfolgten Open-Weight-Veröffentlichung im April 2026
* **MTP-Unterstützung** — spekulatives Decoding über Multi-Token-Prediction-Module ist eingebaut, was sich auf H100/H200 in echten Durchsatz übersetzt
* **Gehostete Fallback-Option** — wenn dein Workload einen einzelnen Knoten sprengt, gibt es den gehosteten Endpunkt von MiniMax; du musst dich zur Architekturzeit nicht festlegen

***

## 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" %}
**229B sind immer noch 229B.** BF16-Gewichte sind \~460GB. Der FP8-Checkpoint ist ungefähr halb so groß — \~230GB — und genau das macht ein Single-Node-Deployment praktikabel. Community-INT4-Quants liegen darunter bei \~120GB, werden aber nicht offiziell unterstützt.
{% endhint %}

| Komponente  | Hobby (INT4 GGUF, Auslagerung)       | Empfohlen (FP8 Einzelknoten)        | Volles BF16                  |
| ----------- | ------------------------------------ | ----------------------------------- | ---------------------------- |
| GPU-VRAM    | 24–48GB GPU + 128GB+ RAM-Auslagerung | 4× H100 80GB **oder** 2× H200 141GB | 8× H100 80GB / 4× H200 141GB |
| Gesamt-VRAM | \~48GB GPU + Auslagerung             | 320GB / 282GB                       | 640GB / 564GB                |
| RAM         | 128 GB                               | 256 GB                              | 512 GB                       |
| Festplatte  | 200 GB NVMe                          | 400GB NVMe                          | 600GB NVMe                   |
| CUDA        | 12.8+                                | 12.8+                               | 12.8+                        |

**Clore.ai-Wahl:** Der FP8-Checkpoint auf **2× H200** ist das sauberste Deployment-Ziel — minimale Tensor-Parallel-Splits, weniger NCCL-Hops, und die Mathematik für 200K Kontext funktioniert einfach. **4× H100** ist die günstigere Alternative, wenn H200 knapp ist.

***

## Option A — Ollama / GGUF (quantisiert)

{% hint style="warning" %}
**Nur Community-Quants.** MiniMax veröffentlicht keine offiziellen GGUF-Gewichte für M2.7. Community-Q4/Q5-Builds erscheinen typischerweise 1–2 Wochen nach der Veröffentlichung — suche [huggingface.co/models?search=minimax-m2.7+gguf](https://huggingface.co/models?search=minimax-m2.7+gguf) und prüfe den Uploader. Die Qualität variiert bei MoE-Quants unter Q4.
{% endhint %}

```bash
# Sobald ein Community-Build Q4_K_M auftaucht (zuerst auf HuggingFace prüfen)
docker exec ollama ollama pull minimax-m2.7:q4_K_M
docker exec ollama ollama run minimax-m2.7:q4_K_M

# Oder direkt mit llama.cpp auf einem heruntergeladenen GGUF
docker run --gpus all -it --rm -p 8080:8080 \\
  -v $(pwd)/models:/models \\
  ghcr.io/ggerganov/llama.cpp:server-cuda \\
  -m /models/minimax-m2.7-q4_k_m.gguf \\
  --n-gpu-layers 80 --ctx-size 32768 \\
  --temp 1.0 --top-p 0.95 --top-k 40 \\
  --port 8080 --host 0.0.0.0
```

Nur für Hobbyzwecke. Für echte Workloads verwende vLLM oder SGLang gegen den FP8-Checkpoint.

***

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

vLLM ist das primäre Serving-Ziel. Der offizielle FP8-Checkpoint ist der richtige zum Ziehen — gleiche Qualität wie BF16 bei ungefähr halbem VRAM.

### docker-compose.yml — 4× H100 80GB

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 4
      --max-model-len 65536
      --gpu-memory-utilization 0.88
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --served-model-name minimax-m2.7
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

### docker-compose.yml — 2× H200 141GB

Reduziere `--tensor-parallel-size` auf 2 und erhöhe `--max-model-len` um den Spielraum zu nutzen:

```yaml
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 2
      --max-model-len 131072
      --gpu-memory-utilization 0.90
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --enable-chunked-prefill
      --served-model-name minimax-m2.7
      --trust-remote-code
```

### Rauchtest

```bash
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "minimax-m2.7",
    "messages": [
      {"role": "system", "content": "Du bist ein Senior Engineer. Verwende Interleaved Thinking beim Schlussfolgern über Tool-Calls hinweg."},
      {"role": "user", "content": "Prüfe diesen Rust-Async-Handler auf Cancellation-Safety von Tokio: ..."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0,
    "top_p": 0.95
  }'
```

{% hint style="info" %}
**Nicht senken `temperature` unter 1.0.** MiniMaxs empfohlene Sampling-Einstellung ist `T=1.0, top_p=0.95, top_k=40`. Greedy Decoding bricht stillschweigend die `<think>` Verschachtelung bei mehrstufigen Tool-Calls.
{% endhint %}

***

## Option C — SGLang

Der MoE-Scheduler von SGLang ist auf Hopper konkurrenzfähig mit vLLM und gewinnt bei langen Code-Completionen oft dank des EAGLE-spekuativen Decodings, das mit den MTP-Modulen von M2.7 zusammenspielt.

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \
  --model-path MiniMaxAI/MiniMax-M2.7 \\
  --quantization fp8 \
  --tp-size 4 \\
  --mem-fraction-static 0.88 \\
  --context-length 65536 \\
  --enable-mixed-chunk \\
  --speculative-algorithm EAGLE \\
  --speculative-num-steps 3 \\
  --speculative-eagle-topk 1 \\
  --speculative-num-draft-tokens 4 \\
  --served-model-name minimax-m2.7 \\
  --trust-remote-code
```

Erwarte etwa 1,5–2× mehr Durchsatz als bei Vanilla-vLLM bei langen Agenten-Traces. Reduziere `--tp-size` auf 2 auf H200.

***

## GPU-Empfehlungen für Clore.ai

| Einrichtung                        | VRAM         | Erwartete Leistung                                     | Clore.ai-Kosten                               |
| ---------------------------------- | ------------ | ------------------------------------------------------ | --------------------------------------------- |
| 1× RTX 4090 24GB + RAM-Auslagerung | 24GB + 128GB | INT4-Hobby, \~5–10 tok/s                               | ca. 0,14–0,42 $/h                             |
| 4× A100 80GB                       | 320GB        | BF16 geshardet, \~15–25 tok/s                          | [Bare Metal](https://clore.ai/bare-metal)     |
| **4× H100 80GB (FP8)**             | **320GB**    | **FP8-Produktion, \~40–60 tok/s**                      | **\~$4,16/h**                                 |
| **2× H200 141GB (FP8)**            | **282GB**    | **FP8-Produktion, \~50–70 tok/s, voller 200K-Kontext** | [**Bare Metal**](https://clore.ai/bare-metal) |
| 8× H100 80 GB                      | 640GB        | BF16 voll, \~80+ tok/s                                 | \~$8,32/h                                     |

{% hint style="success" %}
**Bestes Preis-Leistungs-Verhältnis:** 2× H200 mit dem FP8-Checkpoint. Gleiche Durchsatzklasse wie 4× H100 mit halb so vielen Tensor-Parallel-Hops, oft günstiger pro Tag auf dem Marktplatz, und du behältst genug VRAM-Reserve für den vollen 200K-Kontext.
{% endhint %}

Miete die Maschinen hier:

* [**H200 als Bare Metal**](https://clore.ai/bare-metal) — empfohlen für das 2× H200 FP8-Deployment
* [**H100-GPUs mieten**](https://clore.ai/rent-h100.html) — für das 4× H100 FP8-Deployment
* [**A100 80GB als Bare Metal**](https://clore.ai/bare-metal) — BF16-Multi-GPU-Fallback
* [**RTX 4090 mieten**](https://clore.ai/rent-4090.html) — nur für INT4-Hobbygebrauch
* [**Marktplatz**](https://clore.ai/marketplace) — gesamter Bestand, On-Demand und Spot-Gebote

***

## Anwendungsfälle

* **SWE-Agenten für mehrere Sprachen** — Rust, Go, Java, Kotlin, Swift und TypeScript werden erstklassig behandelt, nicht nur Python/JS
* **Tool-Calling-Schleifen mit langem Horizont** — Interleaved Thinking hält die Denktrace über Hunderte von `tool_use` Roundtrips
* **Codebase-Audits** — 200K Kontext passt eine mittelgroße Service-App plus Tests in einen Prompt
* **Refactoring-Pipelines** — anhaltende Korrektheit über viele Dateiänderungen hinweg durch die MTP-Module
* **Orchestrierung von Agenten durch Agenten** — verwende M2.7 als Planner und ein kleineres Modell (Qwen3.5, GLM-4.7-Flash) als Worker
* **Selbst gehostete Alternative zu Claude Sonnet/Opus** für nicht-kommerzielle Codierforschung — aber **lies zuerst die Lizenz**

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig prüfen.** Die Zahlen unten stammen aus den Release-Notes von MiniMax vom 9. April 2026. Unabhängige Reproduktionen laufen noch ein.
{% endhint %}

| Benchmark        | MiniMax M2.7 | Claude Sonnet 4.5 (Anbieter-Referenz) | Claude Opus 4.6 (Anbieter-Referenz) | GPT-5.3-Codex |
| ---------------- | ------------ | ------------------------------------- | ----------------------------------- | ------------- |
| SWE-Pro          | **56.22%**   | \~55%                                 | \~57.3%                             | 56.2%         |
| VIBE-Pro         | **55.6%**    | —                                     | \~57%                               | —             |
| Terminal Bench 2 | **57.0%**    | —                                     | —                                   | —             |
| GDPval-AA (ELO)  | **1495**     | —                                     | —                                   | —             |

MiniMaxs Einordnung: M2.7 erreicht oder übertrifft Claude Sonnet 4.5 in der Agentic-Coding-Suite, die ihnen wichtig ist, und landet bei SWE-Pro / VIBE-Pro innerhalb weniger Punkte von Claude Opus 4.6. Betrachte das als Richtungssignal, nicht als feststehendes Ranking — der Abstand zu geschlossenen Frontier-Modellen schrumpft mit jeder Veröffentlichung.

***

## MiniMax M2-Familie

| Version  | Veröffentlicht  | Architektonischer Fokus                                            | Empfohlen für                                           |
| -------- | --------------- | ------------------------------------------------------------------ | ------------------------------------------------------- |
| M2       | Okt 2025        | Erste 229B-MoE-Veröffentlichung, RL-optimierte Codierung           | Referenz / historisch                                   |
| M2.1     | Dez 2025        | **Interleaved Thinking** eingeführt                                | Früheste Version, die sich für Agents lohnt             |
| M2.5     | Feb 2026        | Selbstentwickeltes RL-Post-Training, längerer Kontext              | Solides Coding-Modell, wenn der Speicherplatz knapp ist |
| **M2.7** | **9. Apr 2026** | **Verfeinertes Codieren in mehreren Sprachen, MTP, FP8 offiziell** | **Standardwahl — nimm diese**                           |

Wenn du neu startest, überspringe die früheren Versionen und gehe direkt zu M2.7. Die architektonischen Unterschiede summieren sich, und die FP8-Ergonomie ist deutlich besser.

***

## Fehlerbehebung

| Problem                                | Lösung                                                                                                                              |
| -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` bei FP8-Ladung      | Benötigt \~230 GB VRAM. Verwende 4× H100 80GB oder 2× H200 141GB. Reduziere `--max-model-len` zuerst auf 32768.                     |
| Langsamer HuggingFace-Download         | `huggingface-cli download MiniMaxAI/MiniMax-M2.7 --local-dir ./weights --resume-download`. Rechne mit \~230 GB FP8 / \~460 GB BF16. |
| Tool-Calls stillschweigend verworfen   | Setze `--enable-auto-tool-choice --tool-call-parser hermes` in vLLM. M2.7 verwendet Hermes-artige Tool-Tags.                        |
| `<think>` Blöcke leer oder verstümmelt | Sampling muss `temperature=1.0, top_p=0.95, top_k=40`. Greedy Decoding bricht Interleaved Thinking.                                 |
| MTP-Fehler / Form-Mismatch             | Aktualisiere vLLM auf die neueste stabile Version; die MTP-Unterstützung kam spät, und ältere Builds liefern die Module nicht mit.  |
| 200K-Kontext führt auf H100 zu OOMs    | Verwende `--enable-chunked-prefill` und starte bei `--max-model-len 65536`. Der volle 200K-Kontext erfordert realistisch H200.      |
| Lizenzverwirrung                       | Standard = nicht-kommerziell. E-Mail `api@minimax.io` mit Betreff „M2.7 licensing“ vor jeder bezahlten Produktnutzung.              |

***

## Nächste Schritte

* **Audio-Geschwistermodell:** [MiniMax Speech](/guides/guides_v2-de/audio-and-stimme/minimax-speech.md) — derselbe Anbieter, Audio-/Sprachgenerierung
* **Open-Lizenz-Alternative:** [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — 744B / 40B aktiv, MIT-Lizenz, Top SWE-Bench Pro
* **Alternative mit riesigem Kontext:** [DeepSeek V4](/guides/guides_v2-de/sprachmodelle/deepseek-v4.md) — 1M Kontext, multimodal
* **Günstigere agentische Option:** [GLM-4.7 Flash](/guides/guides_v2-de/sprachmodelle/glm-47-flash.md) — passt auf einen einzelnen H100, MIT
* **Clore.ai-Marktplatz:** [clore.ai/marketplace](https://clore.ai/marketplace) — H100/H200/A100 vom Spot-Markt

### Links

* [MiniMax M2.7 auf HuggingFace](https://huggingface.co/MiniMaxAI/MiniMax-M2.7)
* [MiniMax M2.7 LICENSE](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) — vor kommerzieller Nutzung lesen
* [MiniMax-Plattform](https://www.minimax.io)
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [SGLang-Repo](https://github.com/sgl-project/sglang)
* [KTransformers](https://github.com/kvcache-ai/ktransformers)


---

# 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/minimax-m27.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.
