# Mistral Medium 3.5 (128B Dense, 256K)

{% hint style="info" %}
**Status (April 2026):** Mistral Medium 3.5 wurde veröffentlicht am **29. April 2026** von Mistral AI als Nachfolger von Mistral Medium 3. Die Gewichte sind verfügbar unter [huggingface.co/mistralai/Mistral-Medium-3.5](https://huggingface.co/mistralai/Mistral-Medium-3.5) unter der **Mistral Research License (MRL)** für Forschungszwecke; die **Mistral Commercial License** ist für den Produktionseinsatz über die Evaluierung hinaus erforderlich. vLLM (≥ 0.8.x) und SGLang liefern Unterstützung ab Tag 0.
{% endhint %}

Mistral Medium 3.5 ist ein **128B dichter Transformer** mit einem **256K-Token-Kontextfenster** und einem **nativen Reasoning-Umschalter** der zwischen schnellen „instant“-Antworten und längeren Chain-of-Thought-„deep“-Traces im selben Checkpoint wechselt. Die Veröffentlichung vereint drei zuvor separate Mistral-Linien — **Medium 3** (allgemeine Anweisungen), **Codestral** (Code) und Mistrals Reasoning-Vorschau — in ein einziges umschaltbares Modell; das ist die wichtigste Änderung für Engineering-Teams, die mit mehreren Gewichten jongliert haben.

Für Clore.ai-Nutzer ist die praktische Konsequenz die Dimensionierung. Ein dichter 128B-Model in FP8 belegt ungefähr **128 GB** vor dem KV-Cache, daher passt es **nicht** auf eine einzelne 80-GB-GPU in voller Präzision — Sie benötigen **4× H100 80 GB** (FP8) oder **2× H200 141 GB** um es sauber über vLLM bereitzustellen. Auf dem Marktplatz liegt das bei etwa **24–48 $/Tag** für das 4×-H100-Setup oder **30–50 $/Tag** für 2× H200, was für die meisten Teams der Sweet Spot ist. Single-H100-Deployments funktionieren nur mit aggressiver Q4-GGUF-Quantisierung (\~70 tok/s via llama.cpp), und der 256K-Kontext ist das Erste, das beim Komprimieren verschwindet.

## Hauptfunktionen

* **128B dichte Parameter** — keine MoE-Routing-Tricks, vorhersehbares VRAM- und Latenzprofil, einfacher feinzujustieren als spärliche Modelle
* **256K-Kontextfenster** — Analyse ganzer Codebasen, RAG über lange Dokumente, Multi-Turn-Agent-Loops ohne Abschneiden
* **Zweimodus-Reasoning** — Umschalten `reasoning_mode=instant` für \~Chat-Latenz oder `reasoning_mode=deep` um einen `<think>` Trace vor der Antwort
* **Einheitliche Anweisungs- + Code- + Reasoning-Unterstützung** — ein Satz Gewichte ersetzt Medium 3 + Codestral + die Reasoning-Vorschau
* **Funktionsaufrufe und strukturierte Ausgaben** — native JSON-Schema-Durchsetzung, OpenAI-kompatibles Tool-Call-Format
* **Offene Gewichte** — MRL für Forschung, kommerzielle Lizenz verfügbar; die Gewichte bleiben auf Ihrem System und werden nie per Roundtrip an eine Anbieter-API geschickt
* **Unterstützung ab Tag 0 für vLLM und SGLang** — produktionsreife FP8-Pfade, Tensor Parallelism, chunked prefill, Continuous Batching

## Reasoning-Modi

Medium 3.5 ist das erste Mistral-Modell, das einen einzelnen Checkpoint liefert, der sowohl „schnelle“ als auch „denkenden“ Antworten ausgibt. Der Umschalter wird zur Anforderungszeit gesteuert, nicht beim Laden, sodass ein vLLM-Prozess beide Modi für denselben Aufrufer bedient.

| Modus                | Wann verwenden                                                                                   | Typische TTFT                      | Ausgabeform                                     |
| -------------------- | ------------------------------------------------------------------------------------------------ | ---------------------------------- | ----------------------------------------------- |
| `instant` (Standard) | Chat, Autocomplete, Klassifizierung, Funktionsaufrufe, bei denen Latenz wichtig ist              | 50–250 ms                          | Nur Antwort                                     |
| `deep`               | Code-Review, mehrstufige Planung, Mathematik, schwieriges Debugging, Planungsschritt für Agenten | 1–6 s bis zum ersten Antwort-Token | `<think>...</think>` Trace, dann finale Antwort |

Im `deep` Modus erzeugt das Modell einen versteckten Reasoning-Abschnitt (umhüllt in `<think>...</think>` durch die Chat-Vorlage) vor der sichtbaren Antwort. Das kostet pro Turn irgendwo zwischen ein paar hundert und ein paar tausend zusätzliche Tokens, also **nicht für jede Anfrage aktivieren** — reservieren Sie es für Aufgaben, bei denen Sie sonst ein kleineres Modell mit „denk Schritt für Schritt“ prompten würden. Ein vernünftiges Muster ist, `instant` als Standard zu behalten und nur auf `deep` für Tool-Call-Planungsschritte oder die Synthese der finalen Antwort zu eskalieren.

{% hint style="warning" %}
**Vom Anbieter empfohlene Sampling-Einstellungen.** Mistral empfiehlt `temperature=0.15` für `instant` und `temperature=0.7` mit `top_p=0.95` für `deep` Modus. Sampling mit Null-Temperatur neigt dazu, Reasoning-Traces frühzeitig abzuschneiden.
{% endhint %}

## Wählen Sie Ihr Deployment

Drei realistische Konfigurationen auf dem Clore.ai-Marktplatz. Wählen Sie zuerst nach VRAM-Budget, dann nach Durchsatz.

| Setup                                                                                                               | Präzision           | Gesamtes VRAM | Kontext (praktisch) | Durchsatz      | Empfohlene Clore-Stufe                   | Hinweise                                                               |
| ------------------------------------------------------------------------------------------------------------------- | ------------------- | ------------- | ------------------- | -------------- | ---------------------------------------- | ---------------------------------------------------------------------- |
| 1× H100 80 GB                                                                                                       | Q4 GGUF (llama.cpp) | 80 GB         | 32K–64K             | \~50–70 tok/s  | Single-GPU, Evaluierung/Entwicklung      | Aggressive Quantisierung; etwas Qualität bei langem Code geht verloren |
| 4× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 80 GB  | FP8 (vLLM)          | 320 GB        | Voll 256K           | \~80–140 tok/s | **Produktions-Sweet-Spot**               | TP=4, bestes tok/$ für anhaltenden Traffic                             |
| 2× [H200](https://clore.ai/rent-h200.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 141 GB | FP8 oder BF16       | 282 GB        | Voll 256K           | \~90–130 tok/s | Hoher Kontext, weniger GPUs zu verwalten | Einfachere Topologie, Puffer für KV-Cache bei 256K                     |

{% hint style="success" %}
**Standardwahl:** **4× H100 80 GB FP8** via vLLM. Sie erhalten den vollen 256K-Kontext, \~100 tok/s nachhaltig, eine OpenAI-kompatible API und sauberes Tensor-Parallel-Scaling — für ungefähr die Tageskosten eines einzelnen Claude-Opus-Heavy-Use-Sitzes.
{% endhint %}

## Serveranforderungen

| Komponente         | Minimum (Q4 Single-GPU) | Empfohlen (FP8, 4× H100)           | Hoher Kontext (2× H200) |
| ------------------ | ----------------------- | ---------------------------------- | ----------------------- |
| GPU-VRAM           | 80 GB (1× H100)         | 4× 80 GB = 320 GB                  | 2× 141 GB = 282 GB      |
| System-RAM         | 128 GB                  | 256 GB                             | 256 GB                  |
| Datenträger (NVMe) | 200 GB                  | 400 GB                             | 400 GB                  |
| Netzwerk           | 1 Gbps+ für HF-Download | 1 Gbps+                            | 1 Gbps+                 |
| CUDA               | 12.4+                   | 12.4+                              | 12.6+                   |
| Treiber            | ≥ 555                   | ≥ 555                              | ≥ 555                   |
| Startzeit          | 3–6 Min. (kalter Abruf) | 6–12 Min. (kalter Abruf, 4 Shards) | 5–10 Min.               |

Der erste Kaltstart wird vom HuggingFace-Download dominiert — FP8-Gewichte sind ungefähr **128 GB**, BF16 näher an **256 GB**. Mounten Sie ein persistentes Volume unter `/root/.cache/huggingface` damit Sie diese Bandbreitenkosten nur einmal pro Server zahlen.

## Schnelle Bereitstellung auf CLORE.AI

Der schnellste Weg ist das offizielle `vllm/vllm-openai` Image mit Tensor Parallelism entsprechend Ihrer GPU-Anzahl. Das folgende Beispiel geht von einer 4×-H100-Instanz aus.

**Docker-Image:**

```
vllm/vllm-openai:latest
```

**Ports:**

```
22/tcp
8000/http
```

**Startbefehl (4× H100, FP8):**

```bash
vllm serve mistralai/Mistral-Medium-3.5-FP8 \
    --tensor-parallel-size 4 \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --enable-chunked-prefill \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --reasoning-parser mistral \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \
    --port 8000
```

**Alternative — 2× H200 BF16:**

```bash
vllm serve mistralai/Mistral-Medium-3.5 \
    --tensor-parallel-size 2 \
    --max-model-len 131072 \
    --gpu-memory-utilization 0.92 \
    --enable-chunked-prefill \
    --enable-auto-tool-choice \
    --tool-call-parser mistral \
    --reasoning-parser mistral \
    --tokenizer-mode mistral \
    --config-format mistral \
    --load-format mistral \
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \
    --port 8000
```

{% hint style="info" %}
Beginnen Sie mit `--max-model-len 65536` auch auf Hardware, die mehr aufnehmen könnte. KV-Cache-Speicher wächst linear mit dem Kontext, und die meisten Workloads erreichen 256K nie. Erhöhen Sie ihn erst, nachdem Sie den Anfrage-Mix bestätigt haben.
{% endhint %}

**SGLang-Alternative** (oft schneller auf Hopper bei langen Prefills):

```bash
python3 -m sglang.launch_server \
    --model-path mistralai/Mistral-Medium-3.5-FP8 \
    --tp-size 4 \
    --tool-call-parser mistral \
    --reasoning-parser mistral \
    --mem-fraction-static 0.88 \
    --context-length 65536 \
    --served-model-name mistral-medium-3.5 \
    --host 0.0.0.0 \
    --port 8000
```

## Anwendungsbeispiele

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen** auf Clore.ai (z. B. `abc123.clorecloud.net`). Ersetzen Sie `localhost:8000` mit `https://YOUR_HTTP_PUB_URL` in den folgenden Beispielen, wenn Sie von außerhalb des Servers aufrufen.

### 1. Chat — Instant-Modus (Standard)

Antwort mit niedriger Latenz, kein sichtbarer Reasoning-Trace. Gut für Chat-UIs, Autocomplete, Klassifizierung.

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Write a Go HTTP middleware that rate-limits per API key with a token bucket."}
    ],
    "temperature": 0.15,
    "max_tokens": 1024,
    "extra_body": {"reasoning_mode": "instant"}
  }'
```

### 2. Chat — Deep-Modus (Reasoning-Umschalter)

Aktiviert den `<think>` Trace vor der finalen Antwort. Verwenden Sie dies für schwieriges Debugging, Planung, Mathematik.

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "user", "content": "A user reports our payment webhook fires twice for 1% of orders. Walk through the most likely root causes in order of probability and propose a diagnostic plan."}
    ],
    "temperature": 0.7,
    "top_p": 0.95,
    "max_tokens": 4096,
    "extra_body": {"reasoning_mode": "deep"}
  }'
```

Die Antwort enthält ein `reasoning_content` Feld (vLLM parst den `<think>...</think>` Span aus der sichtbaren Nachricht) zusammen mit `content`. Entfernen Sie den Trace oder zeigen Sie ihn an, je nach Produkt.

### 3. Python — OpenAI-kompatibler Client

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

# Instant-Modus — Chat
response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Refactor this Python function for readability."}
    ],
    temperature=0.15,
    max_tokens=1024,
    extra_body={"reasoning_mode": "instant"}
)
print(response.choices[0].message.content)

# Deep-Modus — Planungsschritt
plan = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "user", "content": "Plan a migration from MongoDB to PostgreSQL for a 2TB orders table with zero downtime."}
    ],
    temperature=0.7,
    max_tokens=4096,
    extra_body={"reasoning_mode": "deep"}
)

msg = plan.choices[0].message
print("DENKEN:\n", getattr(msg, "reasoning_content", ""))
print("\nANTWORT:\n", msg.content)
```

### 4. Strukturierte Ausgaben — JSON-Schema

Medium 3.5 unterstützt JSON-Schema-gesteuertes Decoding über vLLMs `response_format`. Nützlich, wenn der nachgelagerte Verbraucher ein Parser ist, kein Mensch.

```python
from openai import OpenAI

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

schema = {
    "type": "object",
    "properties": {
        "severity": {"type": "string", "enum": ["low", "medium", "high", "critical"]},
        "categories": {
            "type": "array",
            "items": {"type": "string", "enum": ["auth", "payments", "db", "ui", "infra"]}
        },
        "summary": {"type": "string", "maxLength": 240},
        "next_action": {"type": "string"}
    },
    "required": ["severity", "categories", "summary", "next_action"],
    "additionalProperties": False
}

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "Classify the incoming bug report. Return strict JSON."},
        {"role": "user", "content": "Login fails for users with apostrophes in their email, returning 500 from /webapi/login."}
    ],
    temperature=0.0,
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "triage", "schema": schema, "strict": True}
    },
    extra_body={"reasoning_mode": "instant"}
)

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

### 5. Funktionsaufruf

```python
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "search_orders",
        "description": "Durchsuche die Auftragsdatenbank nach Benutzer-ID und optionalem Datumsbereich",
        "parameters": {
            "type": "object",
            "properties": {
                "user_id": {"type": "string"},
                "start_date": {"type": "string", "format": "date"},
                "end_date": {"type": "string", "format": "date"}
            },
            "required": ["user_id"]
        }
    }
}]

response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[{"role": "user", "content": "Find all orders for user u_4821 in April 2026."}],
    tools=tools,
    tool_choice="auto",
    temperature=0.1
)

for call in response.choices[0].message.tool_calls or []:
    print(call.function.name, call.function.arguments)
```

## Leistungstipps

1. **Bevorzugen Sie den FP8-Checkpoint auf Hopper.** `Mistral-Medium-3.5-FP8` ist der vom Anbieter bereitgestellte FP8-Build und ist auf Hopper-Klasse-Hardware mit vernachlässigbarem Qualitätsverlust ungefähr 2× leichter als BF16. Es ist die richtige Standardwahl für sowohl 4× H100 als auch 2× H200.
2. **Tensor Parallelism = Anzahl der GPUs.** Für 4× H100 verwenden Sie `--tensor-parallel-size 4`; für 2× H200 verwenden Sie `--tensor-parallel-size 2`. Pipeline Parallelism auf einem einzelnen Knoten verschlechtert den Durchsatz bei einem dichten 128B-Modell normalerweise.
3. **Begrenzen Sie `max-model-len` auf das, was Sie tatsächlich verwenden.** Der KV-Cache bei 256K ist enorm — eine einzelne Sequenz im vollen Kontext kann 30–50 GB verbrauchen. Setzen Sie `--max-model-len 65536` (oder 32768), sofern Sie keinen verifizierten Bedarf für mehr haben, und erhöhen Sie erst nach dem Profiling.
4. **Aktivieren Sie chunked prefill.** `--enable-chunked-prefill` hält Decode-Tokens in Bewegung, während große Prompts noch verarbeitet werden. Bei Prompts mit 100K+ ist das der Unterschied zwischen „reaktionsfähig“ und „Zeitüberschreitung“.
5. **Cachen Sie die Gewichte.** Mounten Sie ein Docker-Volume auf `/root/.cache/huggingface` und verwenden Sie es über Neustarts hinweg erneut. Das erneute Herunterladen von 128 GB bei jedem Kaltstart ist die häufigste Ursache für „vLLM scheint langsam zu starten“.
6. **KV-Cache-Quantisierung für etwas mehr Spielraum.** Auf 4× H100 können Sie mit `--kv-cache-dtype fp8`mehr gleichzeitige Sitzungen unterbringen. Der Anbieter meldet nahezu verlustfreie Qualität; prüfen Sie das auf Ihrem Evaluierungsdatensatz, bevor Sie es in der Produktion aktivieren.
7. **Verwenden Sie nicht `deep` Modus für jede Anfrage.** Reasoning-Traces kosten echte Tokens und echte Latenz. Leiten Sie nach Aufgabentyp weiter: Klassifizierung, Autocomplete und Tool-Argument-Generierung bleiben in `instant`; Planungs- und Verifizierungsschritte eskalieren zu `deep`.
8. **Spekulatives Decoding hilft.** vLLM und SGLang unterstützen beide spekulatives Decoding mit Draft-Modell (z. B. mit einem Ministral-3B-Draft). Bei langen Code-Vervollständigungen bringt das typischerweise 1,3–1,7× Durchsatz bei keinen Qualitätskosten.

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter veröffentlichte Zahlen — unabhängig überprüfen.** Die folgende Tabelle stammt aus Mistral AIs Ankündigung vom 29. April 2026. Unabhängige Reproduktionen von Dritten (LMSys, EQ-Bench, das SWE-Bench-Leaderboard) laufen noch ein. Betrachten Sie sie als Richtwerte, nicht als autoritativ.
{% endhint %}

| Benchmark                     | Mistral Medium 3.5 (Anbieter) | Referenzwerte (vom Anbieter zitiert)    |
| ----------------------------- | ----------------------------- | --------------------------------------- |
| MMLU-Pro                      | \~78%                         | Llama 4 Maverick \~76 %, GPT-5.4 \~81 % |
| HumanEval                     | \~92%                         | Codestral 25.01 \~88 %, GLM-5.1 \~94 %  |
| LiveCodeBench (Apr. 2026)     | \~68%                         | GLM-5.1 \~72 %, Llama 4 Maverick \~64 % |
| AIME 2025 (Deep-Modus)        | \~62%                         | GPT-5.4 \~73 %, GLM-5.1 \~58 %          |
| GPQA Diamond (Deep-Modus)     | \~59%                         | Claude Opus 4.6 \~63 %, GLM-5.1 \~57 %  |
| Langkontext-Erinnerung (128K) | \~95%                         | Llama 4 Maverick \~93 %                 |

Die Positionierung, auf die Mistral abzielt: **etwa Llama 4 Maverick / GLM-5.1-Niveau bei allgemeinen Aufgaben, geringere Lücke beim Coden, unterschiedlicher Reasoning-Umschalter**. Es wird nicht als Herausforderer von GPT-5.4 / Claude Opus 4.6 positioniert.

## Fehlerbehebung

| Problem                                                             | Lösung                                                                                                                                                                         |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `CUDA außer Speicher` beim Laden (4× H100)                          | Sie laden wahrscheinlich versehentlich BF16. Verwenden Sie den FP8-Checkpoint (`Mistral-Medium-3.5-FP8`) oder wechseln Sie zu `--max-model-len 32768`.                         |
| `CUDA außer Speicher` mitten in der Anfrage bei 256K Kontext        | Der KV-Cache ist explodiert. Senken Sie `--max-model-len`, aktivieren Sie `--kv-cache-dtype fp8`oder begrenzen Sie `--max-num-seqs` (versuchen Sie 8).                         |
| Deep-Modus erzeugt leere `reasoning_content`                        | Bestätigen Sie `--reasoning-parser mistral` ist in vLLM gesetzt und dass `temperature ≥ 0.5`. Sampling mit Null-Temperatur schneidet den Trace ab.                             |
| Langsame Time-to-First-Token im Deep-Modus                          | Erwartet — Deep-Modus gibt einen `<think>` Span aus, bevor sichtbare Ausgabe erscheint. Streamen Sie mit `stream=true` zum Client und zeigen Sie einen UI-Zustand „denke…“ an. |
| `403 Forbidden` beim HuggingFace-Download                           | Mistral Medium 3.5 ist **gesperrt**. Akzeptieren Sie die MRL auf der Modellkarte und setzen Sie `HF_TOKEN` in der Container-Umgebung.                                          |
| `tokenizer_mode mistral` Fehler                                     | Alle drei Flags müssen zusammen verwendet werden: `--tokenizer-mode mistral --config-format mistral --load-format mistral`.                                                    |
| Tool-Aufrufe stillschweigend verworfen                              | Setzen Sie beides `--enable-auto-tool-choice` und `--tool-call-parser mistral`. Ohne den Parser gibt vLLM Tool-Argumente als Klartext zurück.                                  |
| Der Durchsatz bricht jenseits von \~32 gleichzeitigen Sitzungen ein | Sie haben KV-Cache-Eviction erreicht. Senken Sie `--max-model-len`, erhöhen Sie `--gpu-memory-utilization` auf 0.92 oder skalieren Sie auf eine zweite Replik aus.             |
| Lizenzfehler blockiert kommerzielle Nutzung                         | MRL ist nur für Forschung. Kontaktieren Sie den Vertrieb von Mistral für die kommerzielle Lizenz, bevor Sie zahlende Nutzer bedienen.                                          |

## FAQ

**F: Mistral Medium 3.5 vs. Llama 4 Maverick — welches sollte ich wählen?**

Beide liegen in einer ähnlichen Gewichtsklasse (Maverick ist ein 17B-aktives MoE bei 400B gesamt; Medium 3.5 ist ein 128B dichter Modellkern). Wählen Sie **Medium 3.5** wenn Sie vorhersehbares VRAM-/Latenzverhalten, den Zweimodus-Reasoning-Umschalter in einem Checkpoint und stärkere Code-Performance möchten. Wählen Sie **Llama 4 Maverick** wenn Sie eine permissive Lizenz für uneingeschränkte kommerzielle Nutzung benötigen (Llama 4 ist community-lizenziert, Medium 3.5 benötigt für die Produktion eine kommerzielle Mistral-Lizenz) oder wenn Sie die günstigeren Inferenzkosten pro Token möchten, die MoE Ihnen pro Anfrage verschafft.

**F: Wie aktiviere ich den Reasoning-Modus?**

Übergeben Sie `extra_body={"reasoning_mode": "deep"}` im OpenAI-Python-Client oder fügen Sie `"reasoning_mode": "deep"` auf oberster Ebene Ihres HTTP-JSON-Bodys hinzu. Der Standard ist `"instant"`. Stellen Sie serverseitig sicher, dass vLLM mit `--reasoning-parser mistral` gestartet wurde, damit der `<think>` Span in das `reasoning_content` Feld geparst wird, statt in `content`.

**F: Warum 4× H100 statt 2× H100?**

FP8-Gewichte sind \~128 GB vor dem KV-Cache. 2× H100 80 GB ergeben insgesamt 160 GB — genug, um die Gewichte zu laden, aber mit fast keinem Spielraum für KV-Cache, Aktivierungen oder auch nur ein moderates Kontextfenster. In der Praxis läuft 2× H100 sofort bei mehr als 8K Kontext in einen OOM. **4× H100 ist das Minimum für ein nutzbares Deployment mit 256K-Fähigkeit**; 2× H200 (282 GB) ist die Alternative, wenn Sie lieber weniger GPUs mit etwas höheren Kosten pro GPU verwalten möchten.

**F: Kann ich Mistral Medium 3.5 kommerziell nutzen?**

Die standardmäßige Mistral Research License (MRL) erlaubt Forschung und interne Evaluierung, aber **nicht** die kommerzielle Produktion. Für produktive Einsätze gegenüber zahlenden Kunden benötigen Sie die **Mistral Commercial License** — kontaktieren Sie den Vertrieb von Mistral. Das ist dieselbe Sperre, die zuvor für Medium 3 und Codestral galt. Wenn eine kommerzielle, freundliche Lizenzierung zwingend erforderlich ist, schauen Sie sich [Mistral Small 3.1](/guides/guides_v2-de/sprachmodelle/mistral-small.md) (Apache 2.0) oder [Llama 4](/guides/guides_v2-de/sprachmodelle/llama4.md) (Llama-Community-Lizenz) an.

**F: Unterstützt Medium 3.5 Vision oder Audio?**

Nein. Medium 3.5 ist nur Text. Für multimodales Mistral verwenden Sie [Mistral Large 3](/guides/guides_v2-de/sprachmodelle/mistral-large3.md), das einen 2,5B-Vision-Encoder mitbringt. Für andere multimodale Optionen auf Clore.ai siehe Qwen3.5-Omni oder Gemma 3.

## Verwandte Leitfäden

* [Mistral Large 3](/guides/guides_v2-de/sprachmodelle/mistral-large3.md) — 675B MoE multimodales Frontier-Modell, Apache 2.0, wenn Sie Vision und maximale Qualität benötigen
* [Mistral & Mixtral](/guides/guides_v2-de/sprachmodelle/mistral-mixtral.md) — ältere Mistral 7B und Mixtral 8x7B/8x22B für Single-GPU-Deployments
* [vLLM](/guides/guides_v2-de/sprachmodelle/vllm.md) — Produktions-Serving-Framework, das empfohlene Backend für Medium 3.5
* [Llama 4](/guides/guides_v2-de/sprachmodelle/llama4.md) — nächster Open-Weight-Peer in dieser Größenordnung, permissiv lizenzierte Alternative

### Externe Links

* [Mistral Medium 3.5 auf HuggingFace](https://huggingface.co/mistralai/Mistral-Medium-3.5)
* [Mistral Medium 3.5 FP8-Checkpoint](https://huggingface.co/mistralai/Mistral-Medium-3.5-FP8)
* [Mistral-AI-Ankündigung (29. April 2026)](https://mistral.ai/news/mistral-medium-3-5)
* [Mistral Research License](https://mistral.ai/licenses/MRL-0.1.md)
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [SGLang-Repo](https://github.com/sgl-project/sglang)
* [Clore.ai-Marktplatz](https://clore.ai/marketplace) — H100 / H200 ab 0,50 $/Tag mieten


---

# Agent Instructions: 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-medium35.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.