MiniMax M3.1 Flash GGUF: Speicher, lokales Setup und API-Kosten

Starte bei MiniMax M3.1 Flash GGUF mit UD-Q2_K_XL und plane 160 GiB+ Speicher ein. Bevorzuge UD-Q4_K_XL mit 256 GiB+, wenn dein Rechner genügend Speicher hat. Müsstest du für gelegentliche Programmieraufgaben neue Hardware kaufen, berechne zuerst die Kosten eines API-Tests.

Diese Planungswerte von Unsloth gelten zum Stand 2026-11-06 für 16K Textkontext und einen Server-Slot. Der Speicher kann sich auf RAM und VRAM verteilen oder als gemeinsamer Speicher vorliegen. Die folgende Anleitung führt vom lokalen API-Server bis zur Anbindung an OpenCode 1.

Wie viel Speicher braucht M3.1 Flash?

Plane Platz für die vollständigen quantisierten Gewichte und den zusätzlichen Speicherbedarf der Laufzeitumgebung ein. Die ursprüngliche Modellkarte von MiniMax nennt etwa 428B Parameter, davon 23B aktiv pro Token. Die geringere aktive Zahl reduziert den Rechenaufwand. Beim Laden müssen aber die vollständigen Modellgewichte in den Speicher passen.

Unsloth veröffentlicht die folgenden Größen und Planungswerte. Downloadgrößen stehen in dezimalen GB, Speicherangaben in GiB.

Quantisierung	Downloadgröße	Größe der Gewichte	Geplanter Speicher
UD-IQ1_M	129.4 GB	120.5 GiB	Experiment bei knappem Speicher; siehe unten
UD-Q2_K_XL	143.9 GB	134.0 GiB	160 GiB+
UD-IQ3_XXS	160.0 GB	149.1 GiB	176 GiB+
UD-IQ3_S	175.5 GB	163.4 GiB	192 GiB+
UD-Q3_K_XL	194.0 GB	180.6 GiB	208 GiB+
UD-Q4_K_XL	249.4 GB	232.3 GiB	256 GiB+
UD-Q8_K_XL	259.1 GB	241.3 GiB	272 GiB+

Unsloth rechnet zusätzlich zu den Gewichten mit etwa 20–32 GiB für den Key-Value-Cache, die Laufzeitumgebung und das Betriebssystem. Dieser Cache speichert den Attention-Zustand des aktuellen Kontexts. Längere Kontexte, weitere Slots, Bildverarbeitung und spekulative Dekodierung benötigen zusätzlichen Speicher.

Allein die 1-bit-Gewichte lassen auf einem Rechner mit 128 GiB nur 7.5 GiB frei. Das liegt unter dem genannten zusätzlichen Speicherbedarf. Verwende für Q2 deshalb Unsloths vorsichtigere Empfehlung von 160 GiB.

RAM und VRAM bilden zusammen ein Budget für die Verteilung der Gewichte. Sie sind kein frei austauschbarer Speicherpool. Beim Auslagern auf die CPU muss im RAM des Rechners genügend Platz für diese Gewichte bleiben. Halte außerdem genügend Speicherplatz auf dem Datenträger für den gewählten Download frei.

Der angegebene Kontextumfang von 1M bedeutet nicht, dass diese Speicherwerte für einen Kontext von 1M gelten. Starte mit 16K und erhöhe den Wert erst, nachdem du den Speicherverbrauch geprüft hast.

Welche Quantisierung solltest du wählen?

Prüfe zunächst mit Q2, ob das Modell in den Speicher passt. Vergleiche danach Q4 anhand deiner tatsächlichen Programmieraufgaben, sofern genügend Speicher verfügbar ist. Wähle eine 3-bit-Variante, wenn Q4 dein Speicherbudget übersteigt.

Unsloths Gesamtwerte und die Werte einzelner Kategorien beziehen sich auf unterschiedliche Bereiche:

Von Unsloth gemeldete Top-1-Übereinstimmung	UD-Q2_K_XL	UD-Q4_K_XL
Gewichteter Gesamtwert	91.5%	98.0%
Programmierung	91.2%	97.6%
Allgemeiner Chat	88.5%	97.3%
Mathematik	95.7%	99.0%

Der Gesamtwert fasst sieben Kategorien gewichtet zusammen. Die Zeilen für Chat und Mathematik beschreiben dagegen einzelne Kategorien. Das erklärt, warum für Q2 sowohl 91.5% als auch 88.5% genannt werden.

Die Top-1-Übereinstimmung misst, ob das quantisierte Modell dasselbe höchstbewertete Token wie das Referenzmodell auswählt. Sie misst keine Erfolgsquote bei Programmieraufgaben. Ein Wert von 91.2% im Bereich Programmierung bedeutet nicht, dass 91.2% der Änderungen an einem Repository ihre Tests bestehen.

Betrachte 1-bit trotz etwa 89.9% Übereinstimmung im Gesamtwert als Experiment bei sehr knappem Speicher. Prüfe Dateiänderungen, Tool-Argumente und Abläufe mit mehreren Schritten, bevor du dich auf eine Quantisierung verlässt.

Q8 benötigt gegenüber Q4 weitere 9.7 GB beim Download. Unsloth beschreibt es als verlustfreie Konvertierung der veröffentlichten Gewichte, bei der die gemischten Formate NVFP4 und BF16 erhalten bleiben. Die Bezeichnung „8-bit“ steht deshalb nicht für eine einheitliche Präzision aller Tensoren.

Welche Laufzeitumgebung passt zu deiner Hardware?

Wähle einen Checkpoint und eine Anleitung, die für deine Laufzeitumgebung ausgelegt sind. Wenn ein EXL3-Checkpoint in den Speicher passt, gilt das nicht automatisch für die entsprechende GGUF-Version.

Die folgenden Möglichkeiten wurden anhand ihrer Quellen zum Stand 2026-11-06 geprüft:

Hardware	Zu prüfende Möglichkeit	Praktische Grenze
Apple Silicon	oQ3e-Checkpoint von MLX-community mit oMLX	Der gesamte Checkpoint umfasst 196.152 GB / 182.681 GiB, einschließlich Draft-Modell und Bildkomponenten. Plane zusätzlichen Speicher für Laufzeitumgebung und Kontext ein.
Ein DGX Spark	SAGE-EXL3-Anleitung von vcruz305	Für ein GB10-System mit 128 GB und festgelegten Versionen der Komponenten. Der Checkpoint erfordert eine Zugriffsfreigabe. Der Server verarbeitet nur Text und dekodiert jeweils eine Sequenz.
AMD Instinct	Quark-MXFP4-Checkpoint von AMD	Die dokumentierte Konfiguration nennt MI350/MI355, Linux, ROCm 7.2.3 und ein Beispiel mit Tensorparallelität auf vier GPUs. Sie ist keine allgemeine Anleitung für Radeon-Karten.
Vier RTX 3090-Karten	Speziell angepasste Inferenz aus MiniMax’ Community-Beitrag vom 1. November	MiniMax schreibt @superalesha einen Ansatz mit quantisierten Gewichten, Experten-Cache und System-RAM zu. Das garantiert nicht dieselbe Leistung auf anderen Systemen.

Folge für dein erstes GGUF-Setup der konkreten llama.cpp-Anleitung weiter unten. Prüfe vor einem kommerziellen Einsatz die MiniMax Community License, einschließlich ihrer Bedingungen zur Namensnennung und Benachrichtigung.

llama.cpp bauen und einen Server mit 16K Kontext starten

Verwende den von Unsloth verlinkten Zweig mit MiniMax-Unterstützung. Zum Stand 2026-11-06 war llama.cpp PR #31192 noch offen und nicht integriert. Dieses Beispiel fixiert den damals ermittelten Head-Commit.

Server bauen und Gewichte herunterladen

Nutze Bash unter Ubuntu oder WSL. Das NVIDIA CUDA Toolkit muss bereits installiert sein. Installiere die übrigen Voraussetzungen und baue den Server:

sudo apt-get update
sudo apt-get install -y build-essential cmake git libssl-dev python3-venv curl jq

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 --detach 6b95a9908d2c7b242817a447708aec38e937e2c0

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

Installiere unter macOS die Xcode-Kommandozeilenwerkzeuge, CMake, Python und jq. Lass die apt-get-Befehle aus und ersetze -DGGML_CUDA=ON durch -DGGML_CUDA=OFF. Laut Build-Anleitung ist Metal unter macOS standardmäßig aktiviert.

Lade mit der Hugging Face CLI alle vier Q2-Teildateien herunter:

python3 -m venv .venv-m31
source .venv-m31/bin/activate
python -m 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/*"

Lasse die Teildateien im selben Ordner. Wenn du die erste Datei angibst, lädt der Server den vollständigen Satz.

Server starten und prüfen

Starte mit einem Slot, ausdrücklich gesetztem 16K-Kontext und normaler Textdekodierung:

./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 \
  --alias m31-local \
  --ctx-size 16384 \
  --parallel 1 \
  --n-gpu-layers auto \
  --jinja \
  --flash-attn on \
  --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

Für diese Implementierung von Sparse Attention setzt die PR Jinja, Flash Attention und einen Slot voraus. Die Optionen von llama-server unterstützen die automatische Zuweisung von Schichten zur GPU.

Der Befehl bindet weder einen Vision-Projektor noch ein DSpark-Draft-Modell ein. Ein API-Schlüssel ist nicht konfiguriert. Der Server lauscht nur auf der lokalen Loopback-Adresse.

Scheitert die VRAM-Zuweisung, reduziere die Anzahl der GPU-Schichten und prüfe den freien RAM des Rechners. Reicht der Gesamtspeicher nicht aus, wähle eine kleinere Quantisierung oder erweitere den Speicher. Das Auslagern auf die CPU beseitigt den Speicherbedarf der Gewichte nicht.

Prüfe in einem zweiten Bash-Terminal, ob der Server bereit ist:

curl -sS -i http://127.0.0.1:8080/health

Fahre fort, sobald HTTP 200 mit {"status":"ok"} zurückkommt. HTTP 503 mit Loading model bedeutet, dass die Initialisierung noch läuft.

Rufe anschließend die Modellliste ab und fordere eine Antwort an:

curl -sS http://127.0.0.1:8080/v1/models | jq '.data[].id'

curl -sS http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  --data '{
    "model": "m31-local",
    "messages": [
      {"role": "user", "content": "Reply with LOCAL_OK."}
    ],
    "reasoning_effort": "low",
    "max_tokens": 4096,
    "stream": false
  }' | jq '{message: .choices[0].message, finish_reason: .choices[0].finish_reason}'

Prüfe, ob die Modellliste m31-local enthält und message.content die angeforderte Antwort ausgibt. Der Wert low in der Anfrage überschreibt bei diesem Kurztest den Serverstandard high.

Bei finish_reason gleich length wurde die Ausgabegrenze erreicht. Erhöhe sie innerhalb des gesamten Kontextbudgets, bevor du fehlenden Antworttext als Ladefehler des Modells deutest.

OpenCode 1 anbinden und einen Tool-Aufruf prüfen

Verbinde OpenCode über die dokumentierte Konfiguration für eigene Provider. OpenCode führt Datei-Tools aus; llama-server erzeugt die Modellantworten.

Diese Konfiguration folgt der Dokumentation für OpenCode 1. OpenCode 1 und OpenCode 2 verwenden beide den Befehl opencode. Nutze daher eine getrennte Umgebung, wenn du bereits V2 einsetzt.

Für eine neue V1-Installation müssen Node.js und npm verfügbar sein:

npm install -g opencode-ai
opencode --version

Übernimm diese Konfiguration in opencode.json im Projektstamm und führe sie mit vorhandenen Einstellungen zusammen. Sie folgt dem offiziellen Provider-Beispiel für llama.cpp:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "local": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "MiniMax local",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "m31-local": {
          "name": "MiniMax M3.1 Flash Q2",
          "limit": {
            "context": 16384,
            "output": 4096
          }
        }
      }
    }
  }
}

Für diese lokale Konfiguration brauchst du keinen Platzhalter als API-Schlüssel. Die Kontextgrenze entspricht der des laufenden Servers. Die Ausgabegrenze ist ein gewähltes Antwortbudget und nicht das Maximum des Modells.

Führe in einem Node-Projekt mit package.json Folgendes aus:

opencode run --model local/m31-local \
  "Read package.json with a file tool. Report scripts.test, or say it is missing. Do not edit files or run commands."

Prüfe, ob tatsächlich ein Tool zum Lesen der Datei aufgerufen wurde, und vergleiche die Antwort mit dem Dateiinhalt. Dass das Modell behauptet, die Datei gelesen zu haben, reicht nicht.

Scheitert die Verbindung, prüfe die Basis-URL mit /v1, den Modellalias und den laufenden Server. Funktionieren Textantworten, aber keine Tool-Aufrufe, prüfe --jinja. Wiederhole diesen kleinen Test, bevor du Dateien im Repository ändern lässt.

Halte die erste Sitzung klein. Wenn Tool-Definitionen zu viel Kontext belegen, nutze das Messverfahren aus dem Leitfaden zu MCP-Kontextkosten, bevor du das Kontextfenster vergrößerst.

Wann ist die API sinnvoller?

Starte mit der API, wenn du für gelegentliche Nutzung neue Hardware kaufen müsstest. Prüfe den lokalen Betrieb, wenn du bereits genügend Kapazität besitzt oder das Modell lokal ausführen musst.

Zum Stand 2026-11-06 nennt der Standardtarif der MiniMax-API folgende Preise:

Abrechnungsposten	USD pro 1 Million Token
Eingabe ohne Cache	$0.15
Lesen von Eingabe-Token aus dem Cache	$0.015
Ausgabe	$0.60

Diese API-Nutzungsgebühren werden vom Kontoguthaben abgezogen. MiniMax beschreibt auch die Tokenpreise von Flash als einheitlich. Die Cache-Kostenformel berechnet neue Eingaben, Cache-Treffer und Ausgaben, ohne einen separaten Posten für Cache-Schreibvorgänge hinzuzufügen.

Für ein monatliches Rechenbeispiel mit 20 Millionen Eingabe-Token ohne Cache und 2 Millionen abgerechneten Ausgabe-Token ergibt sich:

API token charge = 20 × $0.15 + 2 × $0.60
                 = $4.20 per month

Das Beispiel setzt reine Textanfragen, keine Cache-Treffer und keine kostenpflichtigen Server-Tools voraus. Steuern und Gebühren beim Bezahlen sind nicht enthalten.

Zum Vergleich dient dieses angenommene Budget für den lokalen Betrieb:

Hardware allocation = $3,000 ÷ 36 months
                    = $83.33 per month

Active electricity  = 0.15 kW × 60 hours × $0.20/kWh
                    = $1.80 per month

Local subtotal      = $85.13 per month

Alle Werte dieser lokalen Rechnung sind Annahmen. Sie ist kein Angebot für eine überprüfte Hardwarekonfiguration. Sie belegt auch nicht, dass diese Maschine die Arbeitslast in 60 Stunden bewältigt. Berücksichtige vor dem Kauf auch Strom im Leerlauf, Einrichtung, Wartung und nötige Hardwareaufrüstungen.

Nutze bei realen Vergleichsläufen denselben Reasoning-Aufwand. Die MiniMax-API verwendet standardmäßig max, während dieser lokale Server high nutzt. Rechne mit den abgerechneten Ausgabe-Token und bewerte die Kosten pro abgeschlossener Programmieraufgabe, einschließlich Wiederholungen und fehlgeschlagener Tool-Schritte.

BetterToken listet MiniMax-M3.1-Flash zum Stand 2026-11-06 ebenfalls für den Zugriff mit nutzungsabhängiger Abrechnung. Die dokumentierte OpenAI-kompatible Basis-URL lautet https://www.bettertoken.ai/v1. Verwende für die Berechnung dieser Variante die aktuellen Preise.

Wenn du die Hardware bereits besitzt, ersetze den angenommenen Anschaffungsanteil durch deine tatsächlichen zusätzlichen Kosten. Miss anschließend repräsentative Aufgaben. Ein lokales Setup ist sinnvoll, wenn das Modell in den Speicher passt und Bearbeitungszeit sowie akzeptierte Ergebnisse deinen Anforderungen entsprechen.