> 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/mistral-large3.md).

# 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


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/mistral-large3.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
