> 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-rs.md).

# Mistral.rs

**Молниеносный инференс LLM, написанный на Rust** — готовый к продакшену сервер с поддержкой GGUF, GGML, SafeTensors и API, совместимого с OpenAI.

> 🦀 **Создан на Rust** для максимальной производительности | поддержка GGUF и визуальных моделей | лицензия Apache-2.0

***

## Что такое Mistral.rs?

Mistral.rs — это высокопроизводительный движок инференса LLM, написанный полностью на **Rust**. Изначально он был сосредоточен на моделях Mistral, но теперь поддерживает весь спектр современных LLM. Основа на Rust обеспечивает:

* **Абстракции без накладных расходов** — без пауз на сборку мусора во время инференса
* **Безопасность памяти** — без исключений из-за null-указателей и утечек памяти
* **Детерминированная производительность** — стабильная задержка без накладных расходов JVM/Python
* **Оптимизации на этапе компиляции** — SIMD, многопоточность и GPU-ядра оптимизируются во время сборки

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

* **Поддержка GGUF** — запускайте любую квантованную модель (Q4\_K\_M, Q8\_0 и т. д.)
* **ISQ (In-Situ Quantization)** — квантуйте на лету во время загрузки
* **PagedAttention** — эффективный KV-кэш с непрерывной пакетной обработкой
* **Визуально-языковые модели** — поддержка LLaVA, Phi-3 Vision, Idefics
* **Спекулятивное декодирование** — более быстрый инференс с черновыми моделями
* **X-LoRA** — масштабируемая поддержка дообученных адаптеров
* **REST API, совместимый с OpenAI** — замена без доработок

### Поддерживаемые семейства моделей

| Семейство       | Формат            | Движок    |
| --------------- | ----------------- | --------- |
| Llama 2/3       | GGUF, SafeTensors | Rust CUDA |
| Mistral/Mixtral | GGUF, SafeTensors | Rust CUDA |
| Phi-2/3         | GGUF, SafeTensors | Rust CUDA |
| Gemma           | GGUF, SafeTensors | Rust CUDA |
| Qwen 2          | GGUF, SafeTensors | Rust CUDA |
| Starcoder 2     | GGUF              | Rust CUDA |
| LLaVA 1.5/1.6   | SafeTensors       | Vision    |
| Phi-3 Vision    | SafeTensors       | Vision    |

***

## Быстрый старт на Clore.ai

### Шаг 1: найдите GPU-сервер

На [маркетплейсе clore.ai](https://clore.ai) маркетплейс:

* **Минимум:** 8 ГБ VRAM (для 7B Q4 моделей)
* **Рекомендуется:** RTX 3090/4090 (24 ГБ) для более крупных моделей
* Требуется CUDA 11.8+

### Шаг 2: Разверните Docker Mistral.rs

```
Docker-образ: ghcr.io/ericlbuehler/mistral.rs:cuda
```

**Сопоставление портов:**

| Порт контейнера | Назначение      |
| --------------- | --------------- |
| `22`            | SSH-доступ      |
| `8080`          | Сервер REST API |

**Доступные варианты образов:**

```bash
# CUDA (большинство серверов Clore.ai)
ghcr.io/ericlbuehler/mistral.rs:cuda

# Только CPU
ghcr.io/ericlbuehler/mistral.rs:cpu

# Metal (Apple Silicon — не для Clore.ai)
ghcr.io/ericlbuehler/mistral.rs:metal
```

### Шаг 3: Подключитесь и проверьте

```bash
ssh root@<clore-node-ip> -p <ssh-port>

# Проверьте бинарник mistral.rs
mistralrs-server --help
```

***

## Запуск сервера

### Быстрый старт с моделью GGUF

```bash
# Запуск модели GGUF напрямую из HuggingFace
mistralrs-server \\
  --port 8080 \\
  --log info \\
  gguf \\
  -m TheBloke/Llama-2-7B-Chat-GGUF \\
  -f llama-2-7b-chat.Q4_K_M.gguf
```

### Запуск Mistral 7B (SafeTensors)

```bash
mistralrs-server \\
  --port 8080 \\
  plain \\
  -m mistralai/Mistral-7B-Instruct-v0.3 \\
  --isq Q4K
```

### Запуск с In-Situ Quantization (ISQ)

ISQ квантует модель во время загрузки — предварительно квантизованная модель не нужна:

```bash
# Загрузить Llama 3 8B и квантувать в Q4K на лету
mistralrs-server \\
  --port 8080 \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K

# Доступные варианты ISQ:
# Q4_0, Q4_1, Q5_0, Q5_1, Q8_0
# Q2K, Q3K, Q4K, Q5K, Q6K, Q8K
# HQQ4, HQQ8 (полуквадратичная квантизация)
```

### Визуально-языковая модель

```bash
mistralrs-server \\
  --port 8080 \\
  vision-plain \\
  -m llava-hf/llava-1.5-7b-hf \\
  --isq Q4K
```

### Спекулятивное декодирование

```bash
# Используйте маленькую черновую модель, чтобы ускорить генерацию
mistralrs-server \\
  --port 8080 \\
  speculative \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K \\
  -d meta-llama/Meta-Llama-3-1B-Instruct \\
  --draft-isq Q4K \\
  -n 5  # Спекулятивные токены
```

{% hint style="success" %}
**Спекулятивное декодирование** может дать **ускорение в 2–3 раза** для большинства диалоговых нагрузок, где маленькая черновая модель точно предсказывает следующие токены.
{% endhint %}

***

## Использование API

### OpenAI-совместимые эндпоинты

| Конечная точка           | Метод | Описание                         |
| ------------------------ | ----- | -------------------------------- |
| `/v1/chat/completions`   | POST  | Завершения чата                  |
| `/v1/completions`        | POST  | Завершения текста                |
| `/v1/models`             | GET   | Список моделей                   |
| `/v1/images/generations` | POST  | Генерация изображений (VLM)      |
| `/v1/re_isq`             | POST  | Переквантуйте загруженную модель |
| `/health`                | GET   | Проверка состояния               |

### Пример на Python

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # Аутентификация по умолчанию не требуется
)

# Завершение чата
response = client.chat.completions.create(
    model="llama-3-8b",  # Имя модели можно менять
    messages=[
        {"role": "system", "content": "Вы полезный помощник по программированию."},
        {"role": "user", "content": "Напишите функцию Python для разворота связного списка"}
    ],
    temperature=0.1,  # Низкая температура для генерации кода
    max_tokens=1024
)
print(response.choices[0].message.content)
```

### Потоковый ответ

```python
with client.chat.completions.create(
    model="llama-3-8b",
    messages=[{"role": "user", "content": "Расскажи мне историю о роботе."}],
    stream=True,
    max_tokens=512
) as stream:
    for chunk in stream:
        delta = chunk.choices[0].delta
        if hasattr(delta, 'content') and delta.content:
            print(delta.content, end="", flush=True)
print()
```

### Входные данные Vision/изображение

```python
import base64
from pathlib import Path

# Загрузить изображение
image_data = base64.b64encode(Path("photo.jpg").read_bytes()).decode()

response = client.chat.completions.create(
    model="llava-1.5-7b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Что вы видите на этом изображении?"
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)
```

### Примеры cURL

```bash
# Базовый чат
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Что такое Rust?"}],
    "temperature": 0.7,
    "max_tokens": 256
  }'

# Список моделей
curl http://localhost:8080/v1/models

# Проверка состояния
curl http://localhost:8080/health
```

***

## Параметры конфигурации

### Флаги сервера

```bash
mistralrs-server \\
  --port 8080 \                    # Порт API (по умолчанию: 1234)
  --host 0.0.0.0 \                 # Адрес привязки
  --log info \                     # Уровень логирования: off/error/warn/info/debug/trace
  --token-source env:HF_TOKEN \    # Источник токена HuggingFace
  --max-seqs 16 \                  # Максимум одновременных последовательностей
  --no-paged-attn \                # Отключить PagedAttention (для отладки)
  --prefix-cache-n 16 \            # Элементы кэша префиксов
  plain \                          # Подкоманда типа модели
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K
```

### Справочник по квантизации ISQ

| Параметр ISQ | Биты | Качество | VRAM (7B) |
| ------------ | ---- | -------- | --------- |
| `Q2K`        | 2    | ★★☆☆☆    | \~2.5 ГБ  |
| `Q3K`        | 3    | ★★★☆☆    | \~3.5 ГБ  |
| `Q4_0`       | 4    | ★★★★☆    | \~4.5 ГБ  |
| `Q4K`        | 4    | ★★★★☆    | \~4.5 ГБ  |
| `Q5K`        | 5    | ★★★★★    | \~5.5 ГБ  |
| `Q6K`        | 6    | ★★★★★    | \~6.5 ГБ  |
| `Q8_0`       | 8    | ★★★★★    | \~8 ГБ    |
| `HQQ4`       | 4    | ★★★★☆    | \~4.5 ГБ  |
| `HQQ8`       | 8    | ★★★★★    | \~8 ГБ    |

{% hint style="info" %}
**HQQ (полуквадратичная квантизация)** часто обеспечивает лучшее качество, чем GGUF Q4 на том же битовом уровне, особенно для задач следования инструкциям.
{% endhint %}

***

## Расширенные возможности

### X-LoRA (смесь адаптеров LoRA)

Запускайте несколько дообученных адаптеров, динамически выбираемых для каждого токена:

```bash
mistralrs-server \\
  --port 8080 \\
  x-lora-plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K \\
  -x ./xlora-config.json
```

### Переквантизация во время выполнения

```bash
# Измените квантизацию без перезапуска
curl http://localhost:8080/v1/re_isq \\
  -H "Content-Type: application/json" \\
  -d '{"isq_type": "Q8_0"}'
```

### Логирование запросов

```bash
# Включите логирование запросов в файл
mistralrs-server \\
  --port 8080 \\
  --log info \\
  --request-logging-file ./requests.jsonl \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K
```

***

## Тонкая настройка производительности

### Оптимизация под пропускную способность

```bash
# Большее max-seqs для одновременных запросов
mistralrs-server \\
  --port 8080 \\
  --max-seqs 32 \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K
```

### Оптимизация под низкую задержку

```bash
# Меньшее max-seqs, отключите совместное использование prefix cache
mistralrs-server \\
  --port 8080 \\
  --max-seqs 4 \\
  --prefix-cache-n 0 \\
  plain \\
  -m meta-llama/Meta-Llama-3-8B-Instruct \\
  --isq Q4K
```

### Мониторинг производительности

```bash
# Следите за использованием GPU во время инференса
watch -n 1 nvidia-smi

# Профилируйте с помощью nvtop
apt-get install nvtop && nvtop
```

***

## Docker Compose

```yaml
version: '3.8'
services:
  mistral-rs:
    image: ghcr.io/ericlbuehler/mistral.rs:cuda
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - HF_TOKEN=${HUGGING_FACE_HUB_TOKEN}
    ports:
      - "8080:8080"
    volumes:
      - hf-cache:/root/.cache/huggingface
    command: >
      mistralrs-server
      --port 8080
      --host 0.0.0.0
      --log info
      --max-seqs 16
      --token-source env:HF_TOKEN
      plain
      -m meta-llama/Meta-Llama-3-8B-Instruct
      --isq Q4K
    restart: unless-stopped

volumes:
  hf-cache:
```

***

## Сборка из исходников

Если Docker-образ не соответствует вашей версии CUDA:

```bash
# Установите Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Клонируйте и соберите
git clone https://github.com/EricLBuehler/mistral.rs.git
cd mistral.rs

# Соберите с поддержкой CUDA
cargo build --release --features cuda

# Расположение бинарника
./target/release/mistralrs-server --help
```

{% hint style="warning" %}
**Время сборки:** Компиляция Rust выполняется медленно. На полную сборку рассчитывайте на 10–20 минут. Используйте `sccache` чтобы ускорить инкрементальные сборки: `cargo install sccache && RUSTC_WRAPPER=sccache cargo build --release --features cuda`
{% endhint %}

***

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

### Библиотека CUDA не найдена

```bash
# Проверьте библиотеки CUDA
ldconfig -p | grep libcuda
ls /usr/local/cuda/lib64/

# Укажите путь к библиотекам
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
```

### Сбой загрузки модели

```bash
# Установите токен HuggingFace
export HF_TOKEN=your_token_here

# Или используйте флаг --token-source
mistralrs-server \\
  --token-source env:HF_TOKEN \\
  ...

# Или сначала загрузите вручную
huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --local-dir ./llama3-8b
mistralrs-server ... plain -m ./llama3-8b --isq Q4K
```

### Порт 8080 занят

```bash
# Найдите и завершите процесс
fuser -k 8080/tcp

# Используйте другой порт
mistralrs-server --port 9090 ...
```

### Недостаточно памяти во время квантизации

```bash
# ISQ квантует на GPU — сначала уменьшите использование GPU другими задачами
# Или переключитесь на GGUF (предварительно квантизованный, с меньшим пиковым расходом памяти)
mistralrs-server \\
  gguf \\
  -m TheBloke/Llama-2-7B-Chat-GGUF \\
  -f llama-2-7b-chat.Q4_K_M.gguf
```

{% hint style="danger" %}
**ISQ против GGUF:** ISQ квантует при загрузке, используя память GPU (временный всплеск). Если у вас мало VRAM, используйте предварительно квантизованные файлы GGUF от TheBloke или аналогичные — во время загрузки они требуют меньшего пикового объёма памяти.
{% endhint %}

***

## Рекомендации по GPU для Clore.ai

Mistral.rs — это движок с нативной поддержкой Rust: его низкие накладные расходы означают, что вы получаете больше пропускной способности на каждый доллар за GPU по сравнению с серверами на Python.

| GPU        | VRAM  | Цена Clore.ai                               | Рекомендуемое применение                                           | Пропускная способность (Mistral 7B Q4) |
| ---------- | ----- | ------------------------------------------- | ------------------------------------------------------------------ | -------------------------------------- |
| RTX 3090   | 24 ГБ | $0.07–0.21/ч                                | Лучший бюджетный вариант — 7B Q4/Q8, визуальные модели             | \~120 ток/с                            |
| RTX 4090   | 24 ГБ | $0.14–0.42/ч                                | Высокая пропускная способность 7B–34B, спекулятивное декодирование | \~200 ток/с                            |
| A100 40 ГБ | 40 ГБ | [голое железо](https://clore.ai/bare-metal) | Продакшен-обслуживание 34B–70B Q4                                  | \~160 tok/s                            |
| A100 80 ГБ | 80 ГБ | [голое железо](https://clore.ai/bare-metal) | Полноточные 70B, мультимодельный режим                             | \~185 tok/s                            |

**Почему RTX 3090 здесь особенно хороша:** Ядра Rust CUDA в Mistral.rs обходят накладные расходы Python GIL и паузы на сборку мусора, которые мешают Python-серверам. RTX 3090, запускающая Mistral 7B Q4\_K\_M, выдаёт около \~120 tok/s — сопоставимо с vLLM на том же оборудовании, но за часть стоимости ($0.07–0.21/ч против облачных провайдеров, которые берут $0.07–0.21/ч).

**Спекулятивное декодирование:** Сочетайте большую модель (34B) с маленькой черновой моделью (3B) для ускорения в 2–3 раза без потери качества. RTX 4090 идеально подходит для этого сценария.

***

## Ресурсы

* 🐙 **GitHub:** [github.com/EricLBuehler/mistral.rs](https://github.com/EricLBuehler/mistral.rs)
* 📦 **Реестр контейнеров:** [ghcr.io/ericlbuehler/mistral.rs](https://ghcr.io/ericlbuehler/mistral.rs)
* 📚 **Документация:** [ericlbuehler.github.io/mistral.rs](https://ericlbuehler.github.io/mistral.rs/mistralrs/)
* 💬 **Discord:** [discord.gg/SZrecqK8qw](https://discord.gg/SZrecqK8qw)
* 🤗 **Модели GGUF:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke)


---

# 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-rs.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.