# Mistral Large 3 (675B MoE)

Mistral Large 3 ist Mistral AIs leistungsstärkstes Open-Weight-Modell, veröffentlicht im Dezember 2025 unter der **Apache-2.0-Lizenz**. Es ist ein Mixture-of-Experts-(MoE)-Modell mit insgesamt 675B Parametern, aber nur 41B aktiv pro Token — liefert Spitzenleistung zu einem Bruchteil des Rechenaufwands eines dichten 675B-Modells. Mit nativer Multimodal-Unterstützung (Text + Bilder), einem Kontextfenster von 256K und besten agentischen Fähigkeiten konkurriert es direkt mit GPT-4o- und Claude-Klassen-Modellen und ist zugleich vollständig selbst hostbar.

**HuggingFace:** [mistralai/Mistral-Large-3-675B-Instruct-2512](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) **Ollama:** [mistral-large-3:675b](https://ollama.com/library/mistral-large-3) **Lizenz:** Apache 2.0

## Hauptmerkmale

* **675B insgesamt / 41B aktive Parameter** — MoE-Effizienz bedeutet, dass Sie Spitzenleistung erhalten, ohne jeden Parameter zu aktivieren
* **Apache-2.0-Lizenz** — vollständig offen für kommerzielle und private Nutzung, keine Einschränkungen
* **Nativ multimodal** — versteht sowohl Text als auch Bilder über einen 2,5B Vision-Encoder
* **256K Kontextfenster** — verarbeitet massive Dokumente, Codebasen und lange Gespräche
* **Beste agentische Fähigkeiten ihrer Klasse** — native Funktionsaufrufe, JSON-Modus, Werkzeugnutzung
* **Mehrere Bereitstellungsoptionen** — FP8 auf H200/B200, NVFP4 auf H100/A100, GGUF-quantisiert für Consumer-GPUs

## Modellarchitektur

| Komponente       | Details                             |
| ---------------- | ----------------------------------- |
| Architektur      | Granulares Mixture-of-Experts (MoE) |
| Gesamtparameter  | 675B                                |
| Aktive Parameter | 41B (pro Token)                     |
| Vision-Encoder   | 2,5B Parameter                      |
| Kontextfenster   | 256K Tokens                         |
| Training         | 3.000× H200 GPUs                    |
| Veröffentlichung | Dezember 2025                       |

## Anforderungen

| Konfiguration | Budget (Q4 GGUF) | Standard (NVFP4) | Voll (FP8)     |
| ------------- | ---------------- | ---------------- | -------------- |
| GPU           | 4× RTX 4090      | 8× A100 80GB     | 8× H100/H200   |
| VRAM          | 4×24GB (96GB)    | 8×80GB (640GB)   | 8×80GB (640GB) |
| RAM           | 128GB            | 256GB            | 256GB          |
| Festplatte    | 400GB            | 700GB            | 1,4TB          |
| CUDA          | 12.0+            | 12.0+            | 12.0+          |

**Empfohlene Clore.ai-Konfiguration:**

* **Bestes Preis-Leistungs-Verhältnis:** 4× RTX 4090 (\~$2–8/Tag) — führen Sie Q4 GGUF-Quantisierung über llama.cpp oder Ollama aus
* **Produktionsqualität:** 8× A100 80GB (\~$16–32/Tag) — NVFP4 mit vollem Kontext über vLLM
* **Maximale Leistung:** 8× H100 (\~$24–48/Tag) — FP8, voller 256K Kontext

## Schnellstart mit Ollama

Der schnellste Weg, Mistral Large 3 auf einer Multi-GPU Clore.ai-Instanz auszuführen:

```bash
# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Führen Sie das 675B-Modell aus (erfordert Multi-GPU, ~96GB+ VRAM für Q4)
ollama run mistral-large-3:675b

# Für die kleineren dichten Varianten (Single-GPU):
ollama run mistral3:14b    # 14B dicht — passt auf RTX 3060+
ollama run mistral3:8b     # 8B dicht — passt auf jede GPU
```

## Schnellstart mit vLLM (Produktion)

Für produktionstaugliches Serving mit OpenAI-kompatibler API:

```bash
# Installiere vLLM
pip install vllm

# Serve mit NVFP4-Quantisierung auf 8× A100/H100
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --host 0.0.0.0 \
    --port 8000

# Für FP8 (originale Gewichte, höchste Qualität):
vllm serve mistralai/Mistral-Large-3-675B-Instruct-2512 \
    --tensor-parallel-size 8 \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --max-model-len 131072 \
    --host 0.0.0.0 \
    --port 8000
```

## Beispielanwendungen

### 1. Chat Completion (OpenAI-kompatible API)

Sobald vLLM läuft, verwenden Sie jeden OpenAI-kompatiblen Client:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="nicht benötigt"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Coding-Assistent."},
        {"role": "user", "content": "Schreibe einen asynchronen Python-Web-Scraper mit aiohttp und BeautifulSoup."}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)
```

### 2. Funktionsaufruf / Werkzeugnutzung

Mistral Large 3 glänzt bei strukturierten Werkzeugaufrufen:

```python
import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Hole die aktuelle Wetterlage für einen Ort",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Stadtname"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{"role": "user", "content": "Wie ist das Wetter in Tokio?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Function: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")
```

### 3. Vision — Bildanalyse

Mistral Large 3 versteht Bilder nativ:

```python
import base64
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

# Bild kodieren
with open("diagram.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Beschreibe dieses Architekturdiagramm ausführlich."},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}}
        ]
    }],
    max_tokens=2048
)

print(response.choices[0].message.content)
```

## Tipps für Clore.ai-Nutzer

1. **Beginnen Sie mit NVFP4 auf A100s** — Der `Mistral-Large-3-675B-Instruct-2512-NVFP4` Checkpoint ist speziell für A100/H100-Knoten ausgelegt und bietet nahezu verlustfreie Qualität bei halbiertem Speicherbedarf im Vergleich zu FP8.
2. **Verwenden Sie Ollama für schnelle Experimente** — Wenn Sie eine 4× RTX 4090-Instanz haben, übernimmt Ollama die GGUF-Quantisierung automatisch. Perfekt zum Testen, bevor Sie sich für eine vLLM-Produktionsbereitstellung entscheiden.
3. **Stellen Sie die API sicher bereit** — Wenn Sie vLLM auf einer Clore.ai-Instanz ausführen, verwenden Sie SSH-Tunneling (`ssh -L 8000:localhost:8000 root@<ip>`) anstatt Port 8000 direkt zu öffnen.
4. **Niedriger `max-model-len` um VRAM zu sparen** — Wenn Sie nicht den vollen 256K-Kontext benötigen, setzen Sie `--max-model-len 32768` oder `65536` um die KV-Cache-Speichernutzung deutlich zu reduzieren.
5. **Betrachten Sie die dichten Alternativen** — Für Single-GPU-Setups liefert Mistral 3 14B (`mistral3:14b` in Ollama) hervorragende Leistung auf einer einzelnen RTX 4090 und gehört zur selben Modellfamilie.

## Fehlerbehebung

| Problem                              | Lösung                                                                                                                                |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory` auf vLLM        | Reduziere `--max-model-len` (versuchen Sie 32768), erhöhen Sie `--tensor-parallel-size`, oder verwenden Sie NVFP4-Checkpoint          |
| Langsame Generierungsgeschwindigkeit | Stelle sicher, dass `--tensor-parallel-size` entspricht Ihrer GPU-Anzahl; aktivieren Sie spekulatives Decoding mit Eagle-Checkpoint   |
| Ollama kann 675B nicht laden         | Stellen Sie sicher, dass Sie 96GB+ VRAM über GPUs haben; Ollama benötigt `OLLAMA_NUM_PARALLEL=1` für große Modelle                    |
| `tokenizer_mode mistral` Fehler      | Sie müssen alle drei Flags übergeben: `--tokenizer-mode mistral --config-format mistral --load-format mistral`                        |
| Vision funktioniert nicht            | Stellen Sie sicher, dass Bilder nahe einem Seitenverhältnis von 1:1 sind; vermeiden Sie sehr breite/dünne Bilder für beste Ergebnisse |
| Download zu langsam                  | Verwenden Sie `huggingface-cli download mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4` mit `HF_TOKEN` setzen                     |

## Weiterführende Lektüre

* [Mistral 3 Ankündigungs-Blog](https://mistral.ai/news/mistral-3) — Offizieller Startbeitrag mit Benchmarks
* [HuggingFace Model Card](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512) — Bereitstellungsanleitungen und Benchmark-Ergebnisse
* [NVFP4 quantisierte Version](https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4) — Optimiert für A100/H100
* [GGUF quantisiert (Unsloth)](https://huggingface.co/unsloth/Mistral-Large-3-675B-Instruct-2512-GGUF) — Für llama.cpp und Ollama
* [vLLM-Dokumentation](https://docs.vllm.ai/) — Produktions-Serving-Framework
* [Red Hat Day-0 Anleitung](https://developers.redhat.com/articles/2025/12/02/run-mistral-large-3-ministral-3-vllm-red-hat-ai) — Schritt-für-Schritt vLLM-Bereitstellung
