> 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-ru/yazykovye-modeli/mistral-medium35.md).

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

{% hint style="info" %}
**Статус (апрель 2026):** Mistral Medium 3.5 был выпущен **29 апреля 2026 года** компанией Mistral AI как преемник Mistral Medium 3. Веса доступны на [huggingface.co/mistralai/Mistral-Medium-3.5](https://huggingface.co/mistralai/Mistral-Medium-3.5) по **Лицензии Mistral Research License (MRL)** для исследований; **Лицензия Mistral Commercial License** требуется для производственного использования сверх оценки. vLLM (≥ 0.8.x) и SGLang поставляются с поддержкой с первого дня.
{% endhint %}

Mistral Medium 3.5 — это **плотный трансформер на 128B** с **контекстным окном на 256K токенов** и **нативным переключателем режима reasoning** который переключается между быстрыми ответами "instant" и более длинными цепочками рассуждений "deep" в одном и том же чекпойнте. Этот релиз объединяет три ранее отдельных линии Mistral — **Medium 3** (общие инструкции), **Codestral** (код) и предварительный просмотр reasoning от Mistral — в одну модель с переключением режимов, что и является главным изменением для инженерных команд, которые работали с несколькими весами.

Для пользователей Clore.ai практическое значение — в размере. Плотная модель 128B в FP8 весит примерно **128 ГБ** до KV-кэша, так что она **не** помещается на одну GPU 80 ГБ в полном качестве — вам нужно **4× H100 80 ГБ** (FP8) или **2× H200 141 ГБ** чтобы корректно обслуживать её через vLLM. На маркетплейсе это будет около **24–48 $/день** за конфигурацию 4× H100 или **30–50 $/день** за 2× H200, что и является оптимальным вариантом для большинства команд. Развёртывания на одном H100 работают только с агрессивной квантизацией Q4 GGUF (\~70 ток/с через llama.cpp), а контекст 256K — это первое, что исчезает при сжатии.

## Ключевые особенности

* **плотные параметры 128B** — без трюков маршрутизации MoE, предсказуемый профиль VRAM и задержек, проще дообучать, чем разреженные модели
* **контекстное окно 256K** — анализ всей кодовой базы, RAG по длинным документам, многоходовые циклы агента без усечения
* **Два режима reasoning** — переключатель `reasoning_mode=instant` для задержки уровня чата или `reasoning_mode=deep` чтобы вывести `<think>` трассировку перед ответом
* **Объединённые инструкции + код + reasoning** — один набор весов заменяет Medium 3 + Codestral + предварительный просмотр reasoning
* **Вызов функций и структурированные ответы** — нативное принудительное соблюдение JSON Schema, формат вызовов инструментов, совместимый с OpenAI
* **Открытые веса** — MRL для исследований, коммерческая лицензия доступна; веса остаются у вас и никогда не отправляются обратно в API вендора
* **Поддержка vLLM и SGLang с первого дня** — готовые к продакшену пути FP8, тензорный параллелизм, chunked prefill, непрерывный batching

## Режимы reasoning

Medium 3.5 — первая модель Mistral, которая поставляется с одним чекпойнтом, обслуживающим и быстрые, и "думающие" ответы. Переключатель управляется во время запроса, а не при загрузке, поэтому один процесс vLLM обрабатывает оба режима для одного и того же клиента.

| Режим                    | Когда использовать                                                                          | Типичное TTFT                  | Форма вывода                                            |
| ------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------ | ------------------------------------------------------- |
| `instant` (по умолчанию) | Чат, автодополнение, классификация, вызовы функций, где важна задержка                      | 50–250 мс                      | Только ответ                                            |
| `deep`                   | Ревью кода, многошаговое планирование, математика, сложная отладка, шаг планирования агента | 1–6 с до первого токена ответа | `<think>...</think>` трассировка, затем финальный ответ |

В `deep` режиме модель выдаёт скрытый фрагмент reasoning (обёрнутый в `<think>...</think>` chat template) перед видимым ответом. Это стоит от нескольких сотен до нескольких тысяч дополнительных токенов за ход, так что **не включайте это для каждого запроса** — оставляйте для задач, где иначе вы бы просили меньшую модель "think step by step." Разумный подход — держать `instant` по умолчанию и повышать только до `deep` для этапов планирования вызова инструментов или синтеза финального ответа.

{% hint style="warning" %}
**Рекомендуемая вендором выборка.** Mistral рекомендует `temperature=0.15` для `instant` и `temperature=0.7` с `top_p=0.95` для `deep` режимом. Выборка с нулевой температурой, как правило, слишком рано обрезает цепочки рассуждений.
{% endhint %}

## Выберите развёртывание

Три реалистичные конфигурации на маркетплейсе Clore.ai. Сначала выбирайте по бюджету VRAM, затем по пропускной способности.

| Конфигурация                                                                                                        | Точность            | Общий объём VRAM | Контекст (практический) | Пропускная способность | Рекомендуемый уровень Clore                 | Примечания                                                         |
| ------------------------------------------------------------------------------------------------------------------- | ------------------- | ---------------- | ----------------------- | ---------------------- | ------------------------------------------- | ------------------------------------------------------------------ |
| 1× H100 80 ГБ                                                                                                       | Q4 GGUF (llama.cpp) | 80 ГБ            | 32K–64K                 | \~50–70 ток/с          | Одно-GPU, оценка/разработка                 | Агрессивная квантизация; немного теряется качество на длинном коде |
| 4× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 80 ГБ  | FP8 (vLLM)          | 320 ГБ           | Полные 256K             | \~80–140 ток/с         | **Оптимальный вариант для продакшена**      | TP=4, лучший ток/$ для постоянного трафика                         |
| 2× [H200](https://clore.ai/rent-h200.html?utm_source=docs\&utm_medium=guide\&utm_campaign=mistral-medium-35) 141 ГБ | FP8 или BF16        | 282 ГБ           | Полные 256K             | \~90–130 ток/с         | Высокий контекст, меньше GPU для управления | Более простая топология, запас для KV-кэша на 256K                 |

{% hint style="success" %}
**Выбор по умолчанию:** **4× H100 80 ГБ FP8** через vLLM. Вы получаете полный контекст 256K, \~100 ток/с в устойчивом режиме, API, совместимый с OpenAI, и аккуратное масштабирование тензорного параллелизма — примерно за дневную стоимость одной тяжёлой рабочей сессии Claude Opus.
{% endhint %}

## Требования к серверу

| Компонент     | Минимум (Q4, одна GPU)       | Рекомендуется (FP8, 4× H100)          | Высокий контекст (2× H200) |
| ------------- | ---------------------------- | ------------------------------------- | -------------------------- |
| VRAM GPU      | 80 ГБ (1× H100)              | 4× 80 ГБ = 320 ГБ                     | 2× 141 ГБ = 282 ГБ         |
| Системная RAM | 128 ГБ                       | 256 ГБ                                | 256 ГБ                     |
| Диск (NVMe)   | 200 ГБ                       | 400 ГБ                                | 400 ГБ                     |
| Сеть          | 1 Гбит/с+ для загрузки из HF | 1 Гбит/с+                             | 1 Гбит/с+                  |
| CUDA          | 12.4+                        | 12.4+                                 | 12.6+                      |
| Драйвер       | ≥ 555                        | ≥ 555                                 | ≥ 555                      |
| Время запуска | 3–6 мин (холодная загрузка)  | 6–12 мин (холодная загрузка, 4 шарда) | 5–10 мин                   |

Первый холодный старт в основном зависит от загрузки HuggingFace — веса FP8 весят примерно **128 ГБ**, BF16 — ближе к **256 ГБ**. Смонтируйте постоянный том на `/root/.cache/huggingface` так, чтобы вы платили за эту полосу пропускания только один раз на сервер.

## Быстрое развёртывание на CLORE.AI

Самый быстрый путь — официальный `vllm/vllm-openai` образ с тензорным параллелизмом, настроенным на число ваших GPU. Пример ниже предполагает инстанс 4× H100.

**Docker-образ:**

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

**Порты:**

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

**Команда запуска (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
```

**Альтернатива — 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" %}
Начните с `--max-model-len 65536` даже на оборудовании, где поместится больше. Память KV-кэша растёт линейно с контекстом, а большинство нагрузок никогда не доходят до 256K. Увеличьте значение после того, как подтвердите профиль запросов.
{% endhint %}

**Альтернатива SGLang** (часто быстрее на Hopper для длинных 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
```

## Примеры использования

После развёртывания найдите ваш `http_pub` URL в **Мои заказы** на Clore.ai (например, `abc123.clorecloud.net`). Замените `localhost:8000` с `https://YOUR_HTTP_PUB_URL` в примерах ниже при вызове извне сервера.

### 1. Чат — Instant Mode (по умолчанию)

Ответ с низкой задержкой, без видимой трассировки reasoning. Подходит для чат-интерфейсов, автодополнения, классификации.

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "system", "content": "Вы — старший backend-инженер."},
      {"role": "user", "content": "Напишите Go HTTP middleware, который ограничивает rate limit по API-ключу с помощью token bucket."}
    ],
    "temperature": 0.15,
    "max_tokens": 1024,
    "extra_body": {"reasoning_mode": "instant"}
  }'
```

### 2. Чат — Deep Mode (переключатель reasoning)

Включает `<think>` трассировку перед финальным ответом. Используйте для сложной отладки, планирования, математики.

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [
      {"role": "user", "content": "Пользователь сообщает, что наш payment webhook срабатывает дважды для 1% заказов. Разберите наиболее вероятные причины по убыванию вероятности и предложите план диагностики."}
    ],
    "temperature": 0.7,
    "top_p": 0.95,
    "max_tokens": 4096,
    "extra_body": {"reasoning_mode": "deep"}
  }'
```

В ответе будет `reasoning_content` поле (vLLM извлекает `<think>...</think>` span из видимого сообщения) вместе с `content`. Убирайте или показывайте трассировку в зависимости от вашего продукта.

### 3. Python — клиент, совместимый с OpenAI

```python
from openai import OpenAI

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

# Instant mode — чат
response = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "system", "content": "Вы — полезный ассистент по программированию."},
        {"role": "user", "content": "Отрефакторьте эту Python-функцию для лучшей читаемости."}
    ],
    temperature=0.15,
    max_tokens=1024,
    extra_body={"reasoning_mode": "instant"}
)
print(response.choices[0].message.content)

# Deep mode — шаг планирования
plan = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[
        {"role": "user", "content": "Спланируйте миграцию с MongoDB на PostgreSQL для таблицы orders размером 2 ТБ без простоя."}
    ],
    temperature=0.7,
    max_tokens=4096,
    extra_body={"reasoning_mode": "deep"}
)

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

### 4. Структурированные выходные данные — JSON Schema

Medium 3.5 поддерживает декодирование по JSON Schema через `response_format`. Полезно, когда потребитель на следующем этапе — парсер, а не человек.

```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": "Классифицируйте входящий баг-репорт. Верните строгий JSON."},
        {"role": "user", "content": "Вход в систему не работает для пользователей с апострофами в email, возвращая 500 из /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. Вызов функций

```python
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "search_orders",
        "description": "Поиск в базе заказов по ID пользователя и необязательному диапазону дат",
        "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": "Найдите все заказы для пользователя u_4821 в апреле 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)
```

## Советы по производительности

1. **Предпочтительно использовать FP8-чекпойнт на Hopper.** `Mistral-Medium-3.5-FP8` — это FP8-сборка от вендора; она примерно в 2 раза легче BF16 при практически нулевой потере качества на оборудовании класса Hopper. Это правильный вариант по умолчанию и для 4× H100, и для 2× H200.
2. **Тензорный параллелизм = число GPU.** Для 4× H100 используйте `--tensor-parallel-size 4`; для 2× H200 используйте `--tensor-parallel-size 2`. Pipeline parallelism на одном узле обычно ухудшает пропускную способность для плотной модели 128B.
3. **Ограничьте `max-model-len` до реально используемого значения.** KV-кэш на 256K огромен — одна последовательность на полном контексте может съесть 30–50 ГБ. Установите `--max-model-len 65536` (или 32768), если у вас нет подтверждённой необходимости в большем значении, и повышайте только после профилирования.
4. **Включите chunked prefill.** `--enable-chunked-prefill` — он позволяет токенам декодирования продолжать поступать, пока большие промпты ещё обрабатываются. Для промптов 100K+ это разница между "отзывчиво" и "тайм-аут."
5. **Кэшируйте веса.** Смонтируйте Docker-том на `/root/.cache/huggingface` и переиспользуйте его между перезапусками. Повторная загрузка 128 ГБ на каждом холодном старте — самая частая причина того, что "vLLM медленно запускается."
6. **Квантизация KV-кэша для небольшого запаса.** На 4× H100 можно увеличить число одновременных сессий с помощью `--kv-cache-dtype fp8`. По данным вендора, качество почти не теряется; проверьте на своём наборе оценок, прежде чем включать в продакшене.
7. **Не используйте `deep` режим для каждого запроса.** Трассировки reasoning стоят реальных токенов и реальной задержки. Маршрутизируйте по типу задачи: классификация, автодополнение и генерация аргументов для инструментов остаются в `instant`; шаги планирования и проверки переходят в `deep`.
8. **Спекулятивное декодирование помогает.** vLLM и SGLang поддерживают speculative decoding с draft-моделью (например, с draft-моделью Ministral 3B). На длинных completion для кода это обычно даёт рост пропускной способности в 1.3–1.7 раза без потери качества.

## Бенчмарки

{% hint style="warning" %}
**Числа, опубликованные вендором — проверяйте независимо.** Таблица ниже взята из анонса Mistral AI от 29 апреля 2026 года. Независимые воспроизведения третьими сторонами (LMSys, EQ-Bench, SWE-Bench leaderboard) всё ещё поступают. Смотрите на это как на ориентир, а не как на истину в последней инстанции.
{% endhint %}

| Бенчмарк                                  | Mistral Medium 3.5 (вендор) | Точки сравнения (по данным вендора)   |
| ----------------------------------------- | --------------------------- | ------------------------------------- |
| MMLU-Pro                                  | \~78%                       | Llama 4 Maverick \~76%, GPT-5.4 \~81% |
| HumanEval                                 | \~92%                       | Codestral 25.01 \~88%, GLM-5.1 \~94%  |
| LiveCodeBench (апр. 2026)                 | \~68%                       | GLM-5.1 \~72%, Llama 4 Maverick \~64% |
| AIME 2025 (deep mode)                     | \~62%                       | GPT-5.4 \~73%, GLM-5.1 \~58%          |
| GPQA Diamond (deep mode)                  | \~59%                       | Claude Opus 4.6 \~63%, GLM-5.1 \~57%  |
| Воспроизведение длинного контекста (128K) | \~95%                       | Llama 4 Maverick \~93%                |

Позиционирование, на которое нацелен Mistral: **примерно уровень Llama 4 Maverick / GLM-5.1 по общим задачам, более узкий разрыв в кодинге, отдельный переключатель reasoning**. Его не позиционируют как конкурента GPT-5.4 / Claude Opus 4.6.

## Устранение неполадок

| Проблема                                                            | Решение                                                                                                                                                   |
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory` при загрузке (4× H100)                         | Скорее всего, вы по ошибке загружаете BF16. Используйте FP8-чекпойнт (`Mistral-Medium-3.5-FP8`) или снизьте до `--max-model-len 32768`.                   |
| `CUDA out of memory` в середине запроса с контекстом 256K           | KV-кэш переполнился. Уменьшите `--max-model-len`, включите `--kv-cache-dtype fp8`или ограничьте `--max-num-seqs` (попробуйте 8).                          |
| Deep mode выдаёт пустой `reasoning_content`                         | Проверьте `--reasoning-parser mistral` в vLLM и что `temperature ≥ 0.5`. Выборка с нулевой температурой обрезает трассировку.                             |
| Медленное время до первого токена в deep mode                       | Ожидаемо — deep mode выдаёт `<think>` span перед любым видимым выводом. Передавайте поток клиенту с `stream=true` и показывайте UI-состояние "thinking…". |
| `403 Forbidden` при загрузке из HuggingFace                         | Mistral Medium 3.5 **закрыта**. Примите MRL на карточке модели и установите `HF_TOKEN` в переменных окружения контейнера.                                 |
| `tokenizer_mode mistral` ошибки                                     | Все три флага требуются вместе: `--tokenizer-mode mistral --config-format mistral --load-format mistral`.                                                 |
| Вызовы инструментов тихо отбрасываются                              | Установите оба `--enable-auto-tool-choice` и `--tool-call-parser mistral`. Без парсера vLLM возвращает аргументы инструментов как обычный текст.          |
| Пропускная способность резко падает после \~32 одновременных сессий | Вы достигли вытеснения KV-кэша. Уменьшите `--max-model-len`, увеличьте `--gpu-memory-utilization` до 0.92 или масштабируйтесь до второй реплики.          |
| Ошибка лицензии, блокирующая коммерческое использование             | MRL предназначена только для исследований. Свяжитесь с отделом продаж Mistral за коммерческой лицензией до обслуживания платящих пользователей.           |

## FAQ

**В: Mistral Medium 3.5 vs Llama 4 Maverick — что выбрать?**

Обе модели находятся примерно в одной весовой категории (Maverick — 17B-active MoE при 400B всего; Medium 3.5 — 128B dense). Выбирайте **Medium 3.5** если вам нужны предсказуемые VRAM/задержки, двухрежимный переключатель reasoning в одном чекпойнте и более сильная производительность в коде. Выбирайте **Llama 4 Maverick** если вам нужна более permissive-лицензия для безусловного коммерческого использования (у Llama 4 community-лицензия, у Medium 3.5 для продакшена нужна коммерческая лицензия Mistral) или если вы хотите более низкую стоимость инференса на токен, которую даёт MoE в расчёте на запрос.

**В: Как включить режим reasoning?**

Передайте `extra_body={"reasoning_mode": "deep"}` в Python-клиенте OpenAI или укажите `"reasoning_mode": "deep"` на верхнем уровне вашего HTTP JSON body. По умолчанию используется `"instant"`. На стороне сервера убедитесь, что vLLM был запущен с `--reasoning-parser mistral` чтобы `<think>` span распарсился в `reasoning_content` поле, а не попал в `content`.

**В: Почему 4× H100, а не 2× H100?**

Весы FP8 — это \~128 ГБ до KV-кэша. 2× H100 80 ГБ дают всего 160 ГБ — достаточно, чтобы загрузить веса, но почти без запаса для KV-кэша, активаций или даже умеренного контекстного окна. На практике 2× H100 сразу упираются в OOM уже после контекста 8K. **4× H100 — минимально допустимый вариант для развёртывания с поддержкой 256K**; 2× H200 (282 ГБ) — альтернатива, если вы предпочитаете меньше GPU при немного более высокой стоимости на GPU.

**В: Можно ли использовать Mistral Medium 3.5 коммерчески?**

Стандартная Mistral Research License (MRL) разрешает исследования и внутреннюю оценку, но **не** коммерческий продакшен. Для развёртываний, обслуживающих платящих клиентов, вам нужна **Лицензия Mistral Commercial License** — свяжитесь с продажами Mistral. Это то же ограничение, которое ранее применялось к Medium 3 и Codestral. Если вам критически важна лицензия, дружелюбная к коммерческому использованию, рассмотрите [Mistral Small 3.1](/guides/guides_v2-ru/yazykovye-modeli/mistral-small.md) (Apache 2.0) или [Llama 4](/guides/guides_v2-ru/yazykovye-modeli/llama4.md) (Llama community license).

**В: Поддерживает ли Medium 3.5 vision или audio?**

Нет. Medium 3.5 — только текст. Для мультимодального Mistral используйте [Mistral Large 3](/guides/guides_v2-ru/yazykovye-modeli/mistral-large3.md), которая поставляется с vision-энкодером на 2.5B. Для других мультимодальных вариантов на Clore.ai см. Qwen3.5-Omni или Gemma 3.

## Связанные руководства

* [Mistral Large 3](/guides/guides_v2-ru/yazykovye-modeli/mistral-large3.md) — мультимодальная frontier-модель MoE на 675B, Apache 2.0, если вам нужны vision и максимальное качество
* [Mistral и Mixtral](/guides/guides_v2-ru/yazykovye-modeli/mistral-mixtral.md) — более старые Mistral 7B и Mixtral 8x7B/8x22B для развёртываний на одной GPU
* [vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) — фреймворк для продакшен-сервинга, рекомендуемый backend для Medium 3.5
* [Llama 4](/guides/guides_v2-ru/yazykovye-modeli/llama4.md) — ближайший open-weight аналог такого масштаба, альтернативa с permissive-лицензией

### Внешние ссылки

* [Mistral Medium 3.5 на HuggingFace](https://huggingface.co/mistralai/Mistral-Medium-3.5)
* [FP8-чекпойнт Mistral Medium 3.5](https://huggingface.co/mistralai/Mistral-Medium-3.5-FP8)
* [Анонс Mistral AI (29 апреля 2026)](https://mistral.ai/news/mistral-medium-3-5)
* [Лицензия Mistral Research License](https://mistral.ai/licenses/MRL-0.1.md)
* [Документация vLLM](https://docs.vllm.ai)
* [Репозиторий SGLang](https://github.com/sgl-project/sglang)
* [Маркетплейс Clore.ai](https://clore.ai/marketplace) — аренда H100 / H200 от 0.50 $/день


---

# 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-ru/yazykovye-modeli/mistral-medium35.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.
