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

# vLLM

Высокопроизводительный сервер инференса LLM для рабочих нагрузок в продакшене на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Текущая версия: v0.7.x** — Это руководство охватывает vLLM v0.7.3+. Новые функции включают поддержку DeepSeek-R1, структурированные выходные данные с автоматическим выбором инструмента, обслуживание нескольких LoRA и повышенную эффективность использования памяти.
{% endhint %}

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

| Параметр      | Минимум    | Рекомендуется |
| ------------- | ---------- | ------------- |
| ОЗУ           | **16 ГБ**  | 32 ГБ+        |
| VRAM          | 16 ГБ (7B) | 24 ГБ+        |
| Сеть          | 500 Мбит/с | 1 Гбит/с+     |
| Время запуска | 5–15 минут | -             |

{% hint style="info" %}
Нужен подходящий GPU? [RTX 4090 (24 ГБ)](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=vllm) легко справляется с 7B–13B; для моделей 70B+ [H100 (80 ГБ)](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=vllm) — самый безопасный выбор.
{% endhint %}

{% hint style="danger" %}
**Важно:** vLLM требует значительных объёмов ОЗУ и VRAM. Серверы с менее чем 16 ГБ ОЗУ не смогут запустить даже 7B-модели.
{% endhint %}

{% hint style="warning" %}
**Время запуска:** При первом запуске модель загружается с HuggingFace (5–15 минут в зависимости от размера модели и скорости сети). HTTP 502 в это время — это нормально.
{% endhint %}

## Почему vLLM?

* **Максимальная пропускная способность** - PagedAttention для увеличения пропускной способности в 24 раза
* **Готово для продакшена** - API, совместимый с OpenAI, из коробки
* **Непрерывная пакетная обработка** - Эффективное обслуживание нескольких пользователей
* **Потоковая передача** - Генерация токенов в реальном времени
* **Несколько GPU** - Тензорный параллелизм для больших моделей
* **Несколько LoRA** - Одновременное обслуживание нескольких дообученных адаптеров (v0.7+)
* **Структурированные выходные данные** - Поддержка JSON Schema и вызова инструментов (v0.7+)

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

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

```
vllm/vllm-openai:v0.7.3
```

**Порты:**

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

**Команда:**

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 --host 0.0.0.0 --port 8000
```

### Проверьте, что всё работает

После развёртывания найдите ваш `http_pub` URL в **Мои заказы**:

```bash
# Проверка состояния (при первом запуске может занять 5–15 мин)
curl https://your-http-pub.clorecloud.net/health

# Список моделей (работает только после загрузки модели)
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Если HTTP 502 сохраняется более 15 минут, проверьте:

1. На сервере есть 16 ГБ+ ОЗУ
2. На сервере достаточно VRAM для модели
3. Для закрытых моделей задан токен HuggingFace
   {% endhint %}

## Доступ к вашему сервису

При развёртывании на CLORE.AI обращайтесь к vLLM через `http_pub` URL:

```bash
# Chat completion
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

{% hint style="info" %}
Все `localhost:8000` примеры ниже работают при подключении через SSH. Для внешнего доступа замените на ваш `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Установка

### Использование Docker (рекомендуется)

```bash
docker run -d --gpus all \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:v0.7.3 \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0
```

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

```bash
pip install vllm==0.7.3

# Запуск сервера
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2
```

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

| Модель                        | Параметры | Требуемая VRAM       | Требуемая ОЗУ |
| ----------------------------- | --------- | -------------------- | ------------- |
| Mistral 7B                    | 7B        | 14 ГБ                | 16 ГБ+        |
| Llama 3.1 8B                  | 8B        | 16 ГБ                | 16 ГБ+        |
| Llama 3.1 70B                 | 70B       | 140 ГБ (или 2x80 ГБ) | 64 ГБ+        |
| Mixtral 8x7B                  | 47B       | 90 ГБ                | 32 ГБ+        |
| Qwen2.5 7B                    | 7B        | 14 ГБ                | 16 ГБ+        |
| Qwen2.5 72B                   | 72B       | 145 ГБ               | 64 ГБ+        |
| DeepSeek-V3                   | 236B MoE  | Несколько GPU        | 128 ГБ+       |
| DeepSeek-R1-Distill-Qwen-7B   | 7B        | 14 ГБ                | 16 ГБ+        |
| DeepSeek-R1-Distill-Qwen-32B  | 32B       | 64 ГБ                | 32 ГБ+        |
| DeepSeek-R1-Distill-Llama-70B | 70B       | 140 ГБ               | 64 ГБ+        |
| Phi-4                         | 14B       | 28 ГБ                | 32 ГБ+        |
| Gemma 2 9B                    | 9B        | 18 ГБ                | 16 ГБ+        |
| CodeLlama 34B                 | 34B       | 68 ГБ                | 32 ГБ+        |

## Параметры сервера

### Базовый сервер

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000
```

### Продакшен-сервер

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 256 \
    --enable-prefix-caching
```

### С квантизацией (меньше VRAM)

```bash
# Квантованная модель AWQ (использует меньше VRAM)
vllm serve TheBloke/Mistral-7B-Instruct-v0.2-AWQ \
    --host 0.0.0.0 \
    --quantization awq
```

### Структурированные выходные данные и вызов инструментов (v0.7+)

Включите автоматический выбор инструмента и структурированные JSON-выходы:

```bash
vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral
```

Использование в Python:

```python
from openai import OpenAI
import json

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Получить текущую погоду для города",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Название города"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Какая погода в Париже?"}],
    tools=tools,
    tool_choice="auto"
)

# Разбор вызова инструмента
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(f"Инструмент: {tool_call.function.name}, Аргументы: {args}")
```

Структурированный JSON-вывод через формат ответа:

```python
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Извлеки: John Smith, 30 лет, software engineer"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)
print(response.choices[0].message.content)
```

### Обслуживание нескольких LoRA (v0.7+)

Обслуживайте базовую модель с несколькими LoRA-адаптерами одновременно:

```bash
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --enable-lora \
    --lora-modules \
        sql-adapter=path/to/sql-lora \
        code-adapter=path/to/code-lora \
        chat-adapter=path/to/chat-lora \
    --max-lora-rank 64
```

Запрос к определённому LoRA-адаптеру по имени модели:

```python
# Использовать SQL-адаптер
response = client.chat.completions.create(
    model="sql-adapter",
    messages=[{"role": "user", "content": "Напиши SQL-запрос, чтобы найти 10 лучших клиентов"}]
)

# Использовать кодовый адаптер
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "Напиши функцию Python для сортировки списка"}]
)
```

## Поддержка DeepSeek-R1 (v0.7+)

vLLM v0.7+ имеет нативную поддержку distill-моделей DeepSeek-R1. Эти модели рассуждений выводят `<think>` теги, показывающие процесс их рассуждения.

### DeepSeek-R1-Distill-Qwen-7B (один GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384
```

### DeepSeek-R1-Distill-Qwen-32B (два GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### DeepSeek-R1-Distill-Llama-70B (четыре GPU)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768
```

### Запрос к DeepSeek-R1

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[
        {
            "role": "user",
            "content": "Реши: если поезд проезжает 120 км за 1,5 часа, какова его скорость в м/с?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# Ответ включает блок рассуждений <think>...</think>, за которым следует ответ
print(content)
```

Разбор тегов think:

```python
import re

def parse_deepseek_r1_response(content: str) -> dict:
    """Извлечь рассуждение и ответ из ответа DeepSeek-R1."""
    think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
    return {"thinking": thinking, "answer": answer}

result = parse_deepseek_r1_response(content)
print("Рассуждение:", result["thinking"][:200], "...")
print("Ответ:", result["answer"])
```

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

### Chat Completions (совместимо с OpenAI)

```python
from openai import OpenAI

# Для внешнего доступа используйте ваш http_pub URL:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="not-needed"
)

# Или через SSH-туннель:
# client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "Объясни квантовые вычисления"}
    ],
    max_tokens=500,
    temperature=0.7
)

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

### Потоковая передача

```python
stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Напиши стихотворение"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

### cURL

```bash
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'
```

### Текстовые дополнения

```bash
curl https://your-http-pub.clorecloud.net/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Столица Франции —",
    "max_tokens": 50
  }'
```

## Полная документация API

vLLM предоставляет совместимые с OpenAI конечные точки, а также дополнительные служебные конечные точки.

### Стандартные конечные точки

| Конечная точка         | Метод | Описание                                        |
| ---------------------- | ----- | ----------------------------------------------- |
| `/v1/models`           | GET   | Список доступных моделей                        |
| `/v1/chat/completions` | POST  | Chat completion                                 |
| `/v1/completions`      | POST  | Текстовое дополнение                            |
| `/health`              | GET   | Проверка состояния (может вернуть пустой ответ) |

### Дополнительные конечные точки

| Конечная точка | Метод | Описание                     |
| -------------- | ----- | ---------------------------- |
| `/tokenize`    | POST  | Токенизировать текст         |
| `/detokenize`  | POST  | Преобразовать токены в текст |
| `/version`     | GET   | Получить версию vLLM         |
| `/docs`        | GET   | Документация Swagger UI      |
| `/metrics`     | GET   | Метрики Prometheus           |

#### Токенизация текста

Полезно для подсчёта токенов перед отправкой запросов:

```bash
curl https://your-http-pub.clorecloud.net/tokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Hello world"
  }'
```

Ответ:

```json
{"count": 2, "max_model_len": 32768, "tokens": [9707, 1879]}
```

#### Детокенизация

Преобразование идентификаторов токенов обратно в текст:

```bash
curl https://your-http-pub.clorecloud.net/detokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "tokens": [9707, 1879]
  }'
```

Ответ:

```json
{"prompt": "Hello world"}
```

#### Получить версию

```bash
curl https://your-http-pub.clorecloud.net/version
```

Ответ:

```json
{"version": "0.7.3"}
```

#### Документация Swagger

Откройте в браузере для интерактивной документации API:

```
https://your-http-pub.clorecloud.net/docs
```

#### Метрики Prometheus

Для мониторинга:

```bash
curl https://your-http-pub.clorecloud.net/metrics
```

{% hint style="info" %}
**Модели рассуждений:** DeepSeek-R1 и похожие модели включают `<think>` теги в ответах, показывающие процесс рассуждения модели перед финальным ответом.
{% endhint %}

## Бенчмарки

### Пропускная способность (токенов/с на пользователя)

| Модель             | RTX 3090 | RTX 4090 | A100 40 ГБ | A100 80 ГБ |
| ------------------ | -------- | -------- | ---------- | ---------- |
| Mistral 7B         | 100      | 170      | 210        | 230        |
| Llama 3.1 8B       | 95       | 150      | 200        | 220        |
| Llama 3.1 8B (AWQ) | 130      | 190      | 260        | 280        |
| Mixtral 8x7B       | -        | 45       | 70         | 85         |
| Llama 3.1 70B      | -        | -        | 25 (2x)    | 45 (2x)    |
| DeepSeek-R1 7B     | 90       | 145      | 190        | 210        |
| DeepSeek-R1 32B    | -        | -        | 40         | 70 (2x)    |

*Бенчмарки обновлены в январе 2026 года.*

### Длина контекста vs VRAM

| Модель   | 4K ctx | 8K ctx | 16K ctx | 32K ctx |
| -------- | ------ | ------ | ------- | ------- |
| 8B FP16  | 18 ГБ  | 22 ГБ  | 30 ГБ   | 46 ГБ   |
| 8B AWQ   | 8 ГБ   | 10 ГБ  | 14 ГБ   | 22 ГБ   |
| 70B FP16 | 145 ГБ | 160 ГБ | 190 ГБ  | 250 ГБ  |
| 70B AWQ  | 42 ГБ  | 50 ГБ  | 66 ГБ   | 98 ГБ   |

## Аутентификация Hugging Face

Для закрытых моделей (Llama и т. д.):

```bash
# Установить токен в команде
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --env HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

Или задать как переменную окружения:

```bash
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

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

| Модель | Мин. VRAM | Мин. ОЗУ  | Рекомендуется         |
| ------ | --------- | --------- | --------------------- |
| 7-8B   | 16 ГБ     | **16 ГБ** | 24 ГБ VRAM, 32 ГБ ОЗУ |
| 13B    | 26 ГБ     | 32 ГБ     | 40 ГБ VRAM            |
| 34B    | 70 ГБ     | 32 ГБ     | 80 ГБ VRAM            |
| 70B    | 140 ГБ    | 64 ГБ     | 2x80 ГБ               |

## Оценка стоимости

Типичные ставки на маркетплейсе CLORE.AI:

| GPU      | VRAM  | Цена/день  | Лучше всего для |
| -------- | ----- | ---------- | --------------- |
| RTX 3090 | 24 ГБ | $0.30–1.00 | моделей 7-8B    |
| RTX 4090 | 24 ГБ | $0.50–2.00 | 7-13B, быстро   |
| A100     | 40 ГБ | $1.50–3.00 | моделей 13-34B  |
| A100     | 80 ГБ | $2.00–4.00 | моделей 34-70B  |

*Цены указаны в USD/день. Ставки зависят от провайдера — проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

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

### HTTP 502 длительное время

1. **Проверьте ОЗУ:** На сервере должно быть 16 ГБ+ ОЗУ
2. **Проверьте VRAM:** Должно хватать для модели
3. **Загрузка модели:** При первом запуске выполняется загрузка с HuggingFace (5–15 мин)
4. **HF Token:** Для закрытых моделей требуется аутентификация

### Нехватка памяти

```bash
# Уменьшить использование памяти
--gpu-memory-utilization 0.8
--max-model-len 4096
--max-num-seqs 64

# Или используйте квантизацию
--quantization awq
```

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

```bash
# Проверьте токен HF
echo $HUGGING_FACE_HUB_TOKEN

# Предварительно загрузите модель
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.2
```

## vLLM против других

| Функция                | vLLM       | llama.cpp   | Ollama      |
| ---------------------- | ---------- | ----------- | ----------- |
| Пропускная способность | Лучший     | Хороший     | Хороший     |
| Использование VRAM     | Высокое    | Низкое      | Среднее     |
| Удобство использования | Среднее    | Среднее     | Легко       |
| Время запуска          | 5–15 мин   | 1–2 мин     | 30 сек      |
| Несколько GPU          | Нативно    | Ограниченно | Ограниченно |
| Вызов инструментов     | Да (v0.7+) | Ограниченно | Ограниченно |
| Несколько LoRA         | Да (v0.7+) | Нет         | Нет         |

**Используйте vLLM, когда:**

* Высокая пропускная способность — приоритет
* Обслуживание нескольких пользователей
* Достаточно VRAM и RAM
* Развертывание в production
* Нужен вызов инструментов / структурированные ответы

**Используйте Ollama, когда:**

* Нужна быстрая настройка
* Один пользователь
* Доступно меньше ресурсов

## Следующие шаги

* [Ollama](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) - Более простая альтернатива с более быстрым запуском
* [DeepSeek-R1](/guides/guides_v2-ru/yazykovye-modeli/deepseek-r1.md) - Руководство по модели для рассуждений
* [DeepSeek-V3](/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3.md) - Лучшая универсальная модель
* [Qwen2.5](/guides/guides_v2-ru/yazykovye-modeli/qwen25.md) - Многоязычные модели
* [Llama.cpp](/guides/guides_v2-ru/yazykovye-modeli/llamacpp-server.md) - Вариант с меньшим использованием VRAM


---

# 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/vllm.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.
