> 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/mimo-v2-flash.md).

# MiMo-V2-Flash

Deploye MiMo-V2-Flash (309B MoE) mit spekulativer Decodierung auf Clore.ai — extrem schnelle Inferenz mit 150+ Token/s

> MiMo-V2-Flash ist ein **Mixture-of-Experts mit 309 Milliarden Parametern** Sprachmodell, das 15 Mrd. Parameter pro Token aktiviert. Mit fortschrittlichem spekulativem Decoding (EAGLE/MTP) liefert es **150+ Token/Sekunde** auf 8×H100 bei gleichzeitigem Erhalt von Frontier-Niveau-Leistung. Veröffentlicht unter **MIT-Lizenz**, stellt es die Speerspitze effizienter Inferenz im großen Maßstab dar.

## Auf einen Blick

* **Modellgröße**: 309 Mrd. insgesamt / 15 Mrd. aktive Parameter (MoE)
* **Lizenz**: MIT (voll kommerziell nutzbar)
* **Kontext**: 32K Token
* **Leistung**: Spitzenreiter bei Reasoning-Benchmarks
* **VRAM**: \~320 GB FP16 (mindestens 4×A100 80GB)
* **Geschwindigkeit**: 150+ Tok/s auf 8×H100 mit spekulativem Decoding

## Warum MiMo-V2-Flash?

**Durchbruchsgeschwindigkeit**: MiMo-V2-Flash erreicht beispiellose Inferenzgeschwindigkeiten durch EAGLE (Extrapolation Algorithm for Greater Language model Efficiency) und MTP (Multi-Token Prediction). Während traditionelle Modelle ein Token nach dem anderen erzeugen, sagt MiMo-V2 mehrere Token parallel voraus und validiert sie.

**Produktionsreife Skalierung**: Mit 309 Mrd. Parametern konkurriert MiMo-V2-Flash mit den größten Frontier-Modellen und bleibt gleichzeitig auf realistischen Hardware-Konfigurationen einsetzbar. Die 15 Mrd. aktiven Parameter sorgen trotz der massiven Parameterzahl für effiziente Inferenz.

**Fortschrittliche Architektur**: Über standardmäßiges MoE hinaus integriert MiMo-V2-Flash spekulatives Decoding nativ in die Modellarchitektur. Das ist keine Optimierung nach dem Training — es ist in die Grundlage eingebaut und ermöglicht garantierte Beschleunigungen.

**Unternehmensqualität**: MIT-Lizenz ohne Nutzungsbeschränkungen. Im großen Maßstab bereitstellen, feinabstimmen oder in kommerzielle Produkte integrieren, ohne sich um Lizenzfragen sorgen zu müssen.

## GPU-Empfehlungen

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

| Einrichtung     | VRAM   | Leistung       | Tägliche Kosten\* |
| --------------- | ------ | -------------- | ----------------- |
| **4×A100 80GB** | 320GB  | \~80 tok/s     | \~$16.00          |
| **8×A100 40GB** | 320GB  | \~70 Tok/s     | \~$28.00          |
| **2×H100**      | 160 GB | \~90 Tok/s     | \~$12.00          |
| **8×H100**      | 640GB  | **150+ Tok/s** | \~$48.00          |
| 4×H200          | 564GB  | \~120 Tok/s    | \~$32.00          |

**Bestes Preis-Leistungs-Verhältnis**: 4×A100 80GB bietet ein hervorragendes Preis-Leistungs-Verhältnis und ist verfügbar als [Bare Metal](https://clore.ai/bare-metal). Auf dem Marktplatz entspricht das einem 4× RTX PRO 6000 Blackwell-Rig (380GB). **Maximale Leistung**: 8×H100 entfesselt das volle Potenzial des spekulativen Decodings.

\*Geschätzte Preise auf dem Clore.ai-Marktplatz

## Mit SGLang bereitstellen (empfohlen)

SGLang bietet die beste Unterstützung für die spekulativen Decoding-Funktionen von MiMo-V2-Flash:

### SGLang installieren

```bash
pip install "sglang[all]>=0.3.0"
# oder die neueste Version
pip install git+https://github.com/sgl-project/sglang.git
```

### Multi-GPU-Setup mit MTP

```bash
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 8 \\
  --mtp-acceptance-rate 0.8 \\
  --mem-fraction-static 0.85 \\
  --dtype float16 \\
  --context-length 32768 \\
  --served-model-name mimo-v2-flash
```

### Abfrage mit OpenAI API

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="mimo-v2-flash",
    messages=[
        {"role": "system", "content": "Sie sind ein Experte für KI-Forschung."},
        {"role": "user", "content": "Erklären Sie den spekulativen Decoding-Algorithmus EAGLE und warum er schnellere Inferenz ermöglicht"}
    ],
    max_tokens=1024,
    temperature=0.7,
    stream=True  # Empfohlen für die beste Latenz
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='', flush=True)
```

## Mit vLLM bereitstellen

Auch vLLM unterstützt MiMo-V2-Flash mit spekulativem Decoding:

```bash
pip install vllm>=0.6.0

vllm serve mimo-ai/MiMo-V2-Flash \\
  --tensor-parallel-size 8 \
  --speculative-model mimo-ai/MiMo-V2-Flash-Draft \\
  --speculative-max-model-len 32768 \\
  --speculative-draft-tensor-parallel-size 2 \\
  --use-v2-block-manager \\
  --dtype float16 \\
  --served-model-name mimo-v2-flash \\
  --trust-remote-code
```

## Docker-Vorlage

```dockerfile
FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# Abhängigkeiten installieren
RUN apt-get update && \\
    apt-get install -y python3.10 python3-pip git && \\
    rm -rf /var/lib/apt/lists/*

# SGLang mit MTP-Unterstützung installieren
RUN pip install "sglang[all]>=0.3.0" transformers

# Umgebungsvariablen setzen
ENV PYTHONUNBUFFERED=1
ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7

# Modell vorab herunterladen (optional, spart Startzeit)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('mimo-ai/MiMo-V2-Flash', trust_remote_code=True)"

EXPOSE 30000

CMD ["python", "-m", "sglang.launch_server", \\
     "--model-path", "mimo-ai/MiMo-V2-Flash", \\
     "--host", "0.0.0.0", \\
     "--port", "30000", \\
     "--tp-size", "8", \\
     "--enable-mtp", \\
     "--mtp-max-draft-tokens", "8", \\
     "--dtype", "float16"]
```

Mit allen GPUs ausführen:

```bash
docker build -t mimo-v2-flash .
docker run --gpus all -p 30000:30000 \\
  --shm-size=64g \\
  --ulimit memlock=-1 \\
  --ulimit stack=67108864 \\
  mimo-v2-flash
```

## Erweiterte Konfiguration

### Spekulatives Decoding optimieren

Passen Sie die spekulativen Parameter an Ihre Arbeitslast an:

```bash
# Für Codegenerierung (höhere Akzeptanzrate)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 12 \\
  --mtp-acceptance-rate 0.9 \\
  --temperature 0.1

# Für kreatives Schreiben (niedrigere Akzeptanzrate)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 6 \\
  --mtp-acceptance-rate 0.7 \\
  --temperature 0.8
```

### Speicheroptimierung

Für speicherbeschränkte Setups:

```bash
# Speicherverbrauch reduzieren (langsamer, passt aber auf 4×A100)
python -m sglang.launch_server \\
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 4 \\
  --mem-fraction-static 0.75 \\
  --context-length 16384 \\
  --dtype float16 \\
  --disable-cuda-graph  # Spart VRAM
```

## Benchmark-Beispiel

Testen Sie den Geschwindigkeitsvorteil von MiMo-V2-Flash:

```python
import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

def benchmark_generation():
    start_time = time.time()
    
    response = client.chat.completions.create(
        model="mimo-v2-flash",
        messages=[
            {"role": "user", "content": "Schreiben Sie eine ausführliche Erklärung des Quantencomputings mit genau 500 Wörtern"}
        ],
        max_tokens=600,
        temperature=0.1,
        stream=False
    )
    
    end_time = time.time()
    content = response.choices[0].message.content
    
    tokens = len(content.split())  # Grobe Schätzung der Tokenanzahl
    duration = end_time - start_time
    tokens_per_second = tokens / duration
    
    print(f"{tokens} Token in {duration:.2f}s erzeugt")
    print(f"Geschwindigkeit: {tokens_per_second:.1f} Token/Sekunde")
    
    return tokens_per_second

# Benchmark ausführen
speed = benchmark_generation()
print(f"\nMiMo-V2-Flash erreichte {speed:.1f} Tok/s")
```

## Tipps für Clore.ai-Nutzer

* **Multi-GPU unverzichtbar**: MiMo-V2-Flash erfordert mindestens 4×A100 80GB. Eine Bereitstellung auf einer einzelnen GPU ist nicht praktikabel.
* **NVLink-Vorteil**: Wählen Sie Clore.ai-Hosts mit NVLink zwischen den GPUs für optimale Multi-GPU-Kommunikation.
* **RAM-Anforderungen**: Stellen Sie für einen reibungslosen Betrieb mit 8 GPUs 256 GB+ Systemspeicher sicher.
* **Spekulatives Tuning**: Passen Sie `mtp-max-draft-tokens` basierend auf Ihrem Anwendungsfall an — höher für repetitive Aufgaben, niedriger für kreative Arbeiten.
* **Kontextlänge**: Ein 32K-Kontext ist optimal. Längere Kontexte verringern die Wirksamkeit des spekulativen Decodings.

## Fehlerbehebung

| Problem                                   | Lösung                                                                                                |
| ----------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` beim Start             | Reduziere `mem-fraction-static` oder `tp-size`                                                        |
| Langsame Kommunikation zwischen GPUs      | NVLink überprüfen: `nvidia-ml-py3` oder `nvidia-smi topo -m`                                          |
| MTP beschleunigt nicht                    | Prüfe `mtp-acceptance-rate` — zu hohe Werte deaktivieren die Spekulation                              |
| Zeitüberschreitung beim Laden des Modells | Vorab herunterladen: `huggingface-cli download mimo-ai/MiMo-V2-Flash`                                 |
| Schlechte Token-Akzeptanz                 | Überprüfen Sie die Temperatureinstellungen — sehr niedrige/hohe Temperaturen verringern die Akzeptanz |

## Leistungsvergleich

| Modell            | Größe    | Geschwindigkeit (8×H100) | Qualität |
| ----------------- | -------- | ------------------------ | -------- |
| GPT-4 Turbo       | \~1.7T   | \~15-25 Tok/s            | ★★★★★    |
| Claude Sonnet 3.5 | \~200B   | \~25-35 Tok/s            | ★★★★★    |
| **MiMo-V2-Flash** | **309B** | **150+ Tok/s**           | ★★★★☆    |
| Llama 3.1 405B    | 405B     | \~30-45 Tok/s            | ★★★★☆    |

MiMo-V2-Flash erreicht eine 3- bis 5-fache Beschleunigung gegenüber vergleichbaren Modellen bei gleichzeitig wettbewerbsfähiger Qualität.

## Ressourcen

* [MiMo-V2-Flash auf Hugging Face](https://huggingface.co/mimo-ai/MiMo-V2-Flash)
* [EAGLE-Paper](https://arxiv.org/abs/2401.15077)
* [SGLang-Dokumentation](https://sgl-project.github.io/start/install.html)
* [Multi-Token-Prediction](https://arxiv.org/abs/2404.19737)
* [Leitfaden zum spekulativen Decoding](https://huggingface.co/blog/assisted-generation)


---

# 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/mimo-v2-flash.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.
