> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/minimax-m3.1-flash.md).

# MiniMax-M3.1-Flash: Lokal ausführen

Führen Sie MiniMax-M3.1-Flash lokal mit Unsloth Dynamic GGUFs aus.

MiniMax-M3.1-Flash ist das neue Modell von MiniMax: **428B** multimodales MoE-Modell mit 23B aktiven Parametern und **1M Kontext**, entwickelt für Coding und den Einsatz von Agenten. Erfahre, wie du MiniMax-M3.1-Flash mit [Unsloth-GGUFs](https://huggingface.co/unsloth/MiniMax-M3.1-Flash-GGUF) lokal mit Unsloth Desktop oder llama.cpp ausführst.

Unser 129.4GB **1-Bit-Modell** erzielt **\~89.9 % Top-1-Genauigkeit**; 143.9GB **2-Bit-Modell** erreicht **91.5%**, und 249.4 GB UD-Q4\_K\_XL mit 4 Bit erzielt 98.0 %. Beim Coding erreicht Q2 91.2 % und Q4 97.6 %. Wir haben die Quantisierungsleistung über **sieben Kategorien**gewichtet: Coding, Mathematik, Chat, Tools, Mehrsprachigkeit, Schlussfolgern und Agenteneinsatz. Vielen Dank an MiniMax für den Zugang ab dem ersten Tag.

### ⚙️ Anleitung zur Nutzung

MiniMax-M3.1-Flash unterstützt Text, Bilder und Video und bietet Sparse Attention über alle Layer hinweg, QAT für Attention und geroutete Experten sowie DSpark.

Für UD-Q2\_K\_XL mit 2 Bit solltest du mindestens 160 GB RAM + VRAM (oder Unified Memory) einplanen; für UD-Q4\_K\_XL mit 4 Bit mindestens 256 GB. Diese Richtwerte gehen von einem Textkontext von 16K und einem parallelen Slot aus.

Plane ein, die gesamten quantisierten Gewichte im RAM und VRAM zu halten, auch wenn pro Token nur 23B Parameter aktiv sind. Nutze CPU-Offloading, wenn der GPU-Speicher begrenzt ist.

#### Anforderungen für MiniMax-M3.1-Flash:

**Tabelle: Hardwareanforderungen** (RAM + VRAM oder Unified Memory).

| 1 Bit  | 2 Bit  | 3 Bit      | 4 Bit  | 8 Bit (verlustfrei) |
| ------ | ------ | ---------- | ------ | ------------------- |
| 134 GB | 150 GB | 176–208 GB | 256 GB | 272 GB              |

Richtwerte für einen Textkontext von 16K und einen Slot. Dabei sind etwa 20–32 GiB zusätzlich zu den Gewichten für KV-Cache, Laufzeitumgebung und Betriebssystem eingeplant. Die Speicherangaben verwenden GiB, die üblicherweise als GB vermarktet werden. Längere Kontexte, Bildverarbeitung und DSpark benötigen mehr Speicher.

Für 3 Bit solltest du mindestens 176 GB für `UD-IQ3_XXS`, mindestens 192 GB für `UD-IQ3_S` oder mindestens 208 GB für `UD-Q3_K_XL`einplanen. Die 8-Bit-Spalte bezieht sich auf `UD-Q8_K_XL`, das hier aufgeführte GGUF mit der höchsten Präzision.

**Gewichtsgrößen:** Die Downloadgrößen unten sind in dezimalen GB angegeben. Beginne mit einem Kontext von 16K und erhöhe ihn, sofern der Speicher es zulässt.

| Quantisierung | Downloadgröße (GB) | Gewichtsgröße (GiB) |
| ------------- | ------------------ | ------------------- |
| `UD-IQ1_M`    | 129,4 GB           | 120,5 GiB           |
| `UD-IQ2_XXS`  | 134,9 GB           | 125,7 GiB           |
| `UD-Q2_K_XL`  | 143,9 GB           | 134,0 GiB           |
| `UD-IQ3_XXS`  | 160,0 GB           | 149,1 GiB           |
| `UD-IQ3_S`    | 175,5 GB           | 163,4 GiB           |
| `UD-Q3_K_XL`  | 194,0 GB           | 180,6 GiB           |
| `UD-Q4_K_XL`  | 249,4 GB           | 232,3 GiB           |
| `UD-Q8_K_XL`  | 259,1 GB           | 241,3 GiB           |

### Empfohlene Einstellungen

Verwende die von MiniMax empfohlenen Konfigurationen:

| Einstellung | Wert                |
| ----------- | ------------------- |
| Temperatur  | `1.0`               |
| Top-p       | `0.95`              |
| Top-k       | `0` (deaktiviert)   |
| Min-p       | `0.0` (deaktiviert) |

#### Denkaufwand

Die Vorlage verwendet adaptives Denken. Setze `reasoning_effort` auf `low`, `medium`, `high`, `xhigh` oder `max`. Wir verwenden `high`; der Denkaufwand ist unabhängig von Kontext- und Ausgabetokenlimits.

```bash
--chat-template-kwargs '{"reasoning_effort":"high"}'
```

### 📊 Quantisierungsanalyse

UD-Q8\_K\_XL ist eine direkte verlustfreie Konvertierung der originalen Safetensors-Dateien. MiniMax verwendet NVFP4 für die MoE-Layer und MXFP8 für den Rest – wir haben UD-Q8\_K\_XL bei NVFP4 + BF16 belassen.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FwPOGpnK3wxeulnC9lrJq%2Fminimax-kld.png?alt=media&amp;token=c7fb9b86-729f-45f1-827a-c8acee92d0a5" alt="MiniMax-M3.1-Flash GGUF KLD by file size across seven evaluation categories. Lower is better."><figcaption><p>Mittlerer KLD-Wert nach Dateigröße. Niedriger ist besser; die vertikale Achse ist logarithmisch.</p></figcaption></figure>

Wir haben die von uns erstellten MiniMax-M3.1-Flash-Quants mit generischen llama.cpp- und imatrix-Quants in mehreren unterschiedlichen Bereichen verglichen, um sicherzustellen, dass unsere Quantisierungsalgorithmen nicht auf einen bestimmten Bereich überangepasst sind. Wir zeigen, dass Unsloth Dynamic v3 überraschend gut in allen Bereichen funktioniert.

Wir haben außerdem Top-1%-Diagramme erstellt und zeigen, dass UD3 auch bei geringerer Bitzahl weiterhin gut funktioniert – im Vergleich zu naiven llama.cpp-Layouts mit imatrix.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FEGL7IdsBG2LJa8kp9krw%2Fsize_vs_top1_per_axis.png?alt=media&amp;token=1898d4b7-b4b4-46a7-b5e2-9a9a4915cdce" alt=""><figcaption></figcaption></figure>

**Top-1-Übereinstimmung nach Quantisierung:**

| Quantisierung | Dateigröße | Top-1 im allgemeinen Chat | Top-1 bei Mathematik |
| ------------- | ---------- | ------------------------- | -------------------- |
| `UD-IQ1_M`    | 129,4 GB   | 86.2%                     | 94.9%                |
| `UD-IQ2_XXS`  | 134,9 GB   | 87.5%                     | 95.3%                |
| `UD-Q2_K_XL`  | 143,9 GB   | 88.5%                     | 95.7%                |
| `UD-IQ3_XXS`  | 160,0 GB   | 89.9%                     | 96.3%                |
| `UD-IQ3_S`    | 175,5 GB   | 91.2%                     | 96.8%                |
| `UD-Q3_K_XL`  | 194,0 GB   | 92.6%                     | 97.4%                |
| `UD-Q4_K_XL`  | 249,4 GB   | 97.3%                     | 99.0%                |
| `UD-Q8_K_XL`  | 259,1 GB   | 97.8%                     | 99.3%                |

Dynamische Quants weisen bei vergleichbarer oder geringerer Größe einen niedrigeren KLD und eine höhere Übereinstimmung auf. **UD-Q3\_K\_XL (194.0 GB)** übertrifft generisches **IQ4\_XS (ca. 230 GB)** bei der Top-1-Übereinstimmung in allen sieben Kategorien.

**Eine Quantisierung auswählen:** Q2 erreicht bei 143.9 GB eine Übereinstimmung von 88.5 % im allgemeinen Chat und 95.7 % bei Mathematik. Mit Q4 steigen diese Werte auf 97.3 % und 99.0 %; die mehrsprachige Übereinstimmung steigt von 90.8 % bei Q3 auf 97.6 %. Q8 benötigt zusätzlich 9.7 GB und bringt dafür einen geringeren Genauigkeitsgewinn.

## Tutorials zu MiniMax-M3.1-Flash ausführen:

Wir verwenden **UD-Q2\_K\_XL** für die Beispiele. Bildeingabe und DSpark werden in Unsloth automatisch aktiviert.

### 🦥 Unsloth-Anleitung

[Unsloth Desktop](https://unsloth.ai/docs/desktop) ist unsere Open-Source-Benutzeroberfläche für macOS, Windows und Linux. Lade GGUFs herunter und konfiguriere Sampling sowie CPU-/GPU-Offloading in einer einzigen App.

{% stepper %}
{% step %}

### Unsloth installieren

Lade [Unsloth Desktop](https://unsloth.ai/download) für dein Betriebssystem herunter. Verwende einen Build mit Unterstützung für MiniMax-M3.1 oder den unten aufgeführten llama.cpp-PR.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Unsloth herunterladen</a>
{% endstep %}

{% step %}

### MiniMax-M3.1-Flash suchen und herunterladen

Suche in **Unsloth Chat** oder im **Model Hub**nach **MiniMax-M3.1-Flash** und wähle [unsloth/MiniMax-M3.1-Flash-GGUF](https://huggingface.co/unsloth/MiniMax-M3.1-Flash-GGUF). Lade deine Quantisierung herunter; wir verwenden `UD-Q2_K_XL` (143.9 GB).
{% endstep %}

{% step %}

### MiniMax-M3.1-Flash ausführen

Lade das Modell mit den empfohlenen Einstellungen, **16K Kontext**, **einem parallelen Slot** und `high` Reasoning-Aufwand. Verwende das enthaltene Chat-Template und passe das CPU-/GPU-Offloading an deinen verfügbaren Speicher an.

Weitere Informationen findest du in der [Unsloth-Inferenzanleitung](https://unsloth.ai/docs/de/neu/studio/chat.md).
{% endstep %}

{% step %}

### MiniMax-M3.1-Flash mit der Unsloth-API bereitstellen

Mit einer kompatiblen Laufzeitumgebung kannst du das Modell mit `unsloth run` und llama-server-Optionen bereitstellen:

```bash
unsloth run --model unsloth/MiniMax-M3.1-Flash-GGUF:UD-Q2_K_XL \\
    --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":"high"}' \
    --host 127.0.0.1 --port 8080
```

Chatten unter `http://localhost:8080`; die OpenAI-kompatible API-Basis-URL lautet `http://localhost:8080/v1`.
{% endstep %}

{% step %}

### Tools verbinden

Verbinde deinen API-Client mit diesem Endpunkt und verwende eine Modell-ID aus `/v1/models`. Lass den Server laufen.
{% endstep %}
{% endstepper %}

### 🦙 MiniMax-M3.1-Flash in llama.cpp ausführen

{% stepper %}
{% step %}

### llama.cpp mit MiniMax-M3.1-Unterstützung erstellen

Erstelle [PR #31192](https://github.com/ggml-org/llama.cpp/pull/31192) mit Bash unter Linux, WSL oder macOS.

Installiere unter Ubuntu / WSL die Build-Abhängigkeiten:

```bash
sudo apt-get update
sudo apt-get install -y build-essential cmake git libssl-dev
```

Installiere für NVIDIA das [CUDA-Toolkit](https://developer.nvidia.com/cuda-downloads). Installiere unter macOS die Xcode-Befehlszeilenwerkzeuge und CMake; verwende `-DGGML_CUDA=OFF` (Metal ist standardmäßig aktiviert). Verwende `OFF` auch für reine CPU-Builds.

```bash
git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/31192/head:minimax-m31
git -C llama.cpp checkout minimax-m31
cmake llama.cpp -B llama.cpp/build \
    -DCMAKE_BUILD_TYPE=Release \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --target llama-server
```

{% endstep %}

{% step %}

### GGUF herunterladen

Installiere die Hugging-Face-CLI und lade **alle vier Shards** von `UD-Q2_K_XL`:

```bash
pip install -U huggingface_hub
hf download unsloth/MiniMax-M3.1-Flash-GGUF \
    --local-dir unsloth/MiniMax-M3.1-Flash-GGUF \
    --include "UD-Q2_K_XL/*"
```

Bewahre alle Shards zusammen auf und gib bei `--model` den Pfad zum ersten an; llama.cpp lädt die übrigen. Ändere für eine andere Quantisierung den Downloadfilter und den Modellpfad.
{% endstep %}

{% step %}

### MiniMax-M3.1-Flash ausführen

Starte den lokalen Chat-Server:

```bash
./llama.cpp/build/bin/llama-server \
    --model unsloth/MiniMax-M3.1-Flash-GGUF/UD-Q2_K_XL/MiniMax-M3.1-Flash-UD-Q2_K_XL-00001-of-00004.gguf \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 0 \
    --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":"high"}' \
    --host 127.0.0.1 --port 8080
```

{% endstep %}
{% endstepper %}

#### Bildeingaben

Lade für Bildeingaben das separate `mmproj-BF16.gguf` Vision-Projektormodell herunter (ca. 1,74 GB):

```bash
hf download unsloth/MiniMax-M3.1-Flash-GGUF \
    --local-dir unsloth/MiniMax-M3.1-Flash-GGUF \
    --include "mmproj-BF16.gguf"
```

Füge diese Serveroption hinzu und plane zusätzlichen Speicher für den Projektor und die Bildverarbeitung ein:

```bash
--mmproj unsloth/MiniMax-M3.1-Flash-GGUF/mmproj-BF16.gguf
```

### ⚡ DSpark – spekulatives Decoding

M3.1 ersetzt das EAGLE-ähnliche [MTP](https://unsloth.ai/docs/de/modelle/mtp.md) durch **DSpark**: Ein Entwurfsmodell schlägt Tokens vor, die das Hauptmodell überprüft, wodurch das Decoding möglicherweise beschleunigt wird. Dafür wird ein passendes MiniMax-M3.1-Entwurfsmodell und zusätzlicher Speicher benötigt.

[PR #31192](https://github.com/ggml-org/llama.cpp/pull/31192) unterstützt DSpark; die obigen Befehle verwenden gewöhnliches Decoding. Mit einem passenden Entwurfsmodell füge diese Optionen hinzu und ersetze den Dateinamen durch den lokalen Pfad:

```bash
--spec-type draft-dspark \
    -md MiniMax-M3.1-Flash-DSpark-BF16.gguf \
    --spec-draft-p-min 0
```

## 📊 Benchmarks

### GGUF-KLD- und Top-1-%-Benchmarks

Über die sieben Kategorien hinweg erreicht **UD-Q2\_K\_XL eine Top-1-Übereinstimmung von ca. 85,3–95,7 %**, **UD-Q4\_K\_XL ca. 97,3–99,0 %**, und **UD-Q8\_K\_XL ca. 97,8–99,3 %**. Q4 spart gegenüber Q8 9,7 GB bei nur geringfügig niedrigerer Übereinstimmung; außerdem ist der KLD-Wert von Q8 durchgehend niedriger.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FLKBqgmIgiNf9wTXbGNsX%2Fminimax-top1.png?alt=media&amp;token=3a155732-d550-4397-86b2-c3d134e5912d" alt="MiniMax-M3.1-Flash GGUF top-1 agreement by file size across seven evaluation categories. Higher is better."><figcaption><p>Top-1-Token-Übereinstimmung über sieben Kategorien. Höher ist besser; die angegebenen Werte sind ungefähre Ablesungen aus dem Diagramm.</p></figcaption></figure>

### Offizielle Benchmarks

[Die offiziellen Ergebnisse von MiniMax](https://huggingface.co/MiniMaxAI/MiniMax-M3.1-Flash) sind unten aufgeführt.

| Benchmark               | MiniMax-M3.1-Flash | DeepSeek-V4.1-Flash-1017 |
| ----------------------- | ------------------ | ------------------------ |
| Automation-Bench v1.0.6 | 62.8               | 60.5                     |
| Terminal Bench 4.0      | 38.1               | 42.3                     |
| DeepSWE v1.1            | 73.7               | 77.0                     |
| NL2Repo-Bench           | 61.2               | 68.2                     |
| BabyVision (mit Tools)  | 91.0               | 92.5                     |
| HLE (ohne Tools)†       | 43.4               | 42.6                     |
| OSWorld 2.0             | 61.7               | —                        |
| LOCA-Bench 256K         | 60.3               | —                        |

† HLE verwendet die Teilmenge nur mit Text. Evaluierungsharnesses: Codex 0.149.1 für Terminal Bench; mini-SWE-agent 2.4.5 für DeepSWE; Claude Code 2.1.233 für NL2Repo. Für die beiden letztgenannten wird ein Kontext von 512K verwendet. Die Ergebnisse hängen von der Konfiguration und dem Reasoning-Aufwand ab; — bedeutet, dass kein Ergebnis veröffentlicht wurde.


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/modelle/minimax-m3.1-flash.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
