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

# SGLang

SGLang (Structured Generation Language) — это высокопроизводительный фреймворк для обслуживания LLM, разработанный командой LMSYS, известной своей работой над Vicuna и Chatbot Arena. Он включает RadixAttention для совместного использования KV-кэша, эффективную поддержку MoE (Mixture of Experts) и API, совместимый с OpenAI, — что делает его одним из самых быстрых open-source движков инференса, доступных на GPU-серверах CLORE.AI.

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

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

| Параметр | Минимум                    | Рекомендуется        |
| -------- | -------------------------- | -------------------- |
| RAM      | 16 ГБ                      | 32 ГБ+               |
| VRAM     | 8 ГБ                       | 24 ГБ+               |
| Диск     | 50 ГБ                      | 200 ГБ+              |
| GPU      | NVIDIA Turing+ (RTX 2000+) | A100, H100, RTX 4090 |

{% hint style="info" %}
SGLang достигает наилучшей производительности на GPU Ampere+ при включенном FlashInfer. Для моделей MoE, таких как Mixtral или DeepSeek, рекомендуется конфигурация с несколькими GPU.
{% endhint %}

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

**Docker-образ:** `lmsysorg/sglang:latest`

**Порты:** `22/tcp`, `30000/http`

**Переменные среды:**

| Переменная             | Пример      | Описание                                              |
| ---------------------- | ----------- | ----------------------------------------------------- |
| `HF_TOKEN`             | `hf_xxx...` | Токен HuggingFace для моделей с ограниченным доступом |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | Используемые GPU                                      |

## Пошаговая настройка

### 1. Арендуйте GPU-сервер на CLORE.AI

Перейдите на [маркетплейс CLORE.AI](https://clore.ai/marketplace) и выберите сервер:

* **Модели 7B**: минимум 16 ГБ VRAM (RTX 4080, A10)
* **Модели 13B**: 24 ГБ VRAM (RTX 3090, RTX 4090, A5000)
* **Модели 70B**: 80 ГБ+ VRAM (A100 80GB) или несколько GPU
* **Модели MoE (Mixtral 8x7B)**: 48 ГБ VRAM или 2×24 ГБ

### 2. Подключитесь к серверу по SSH

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Скачайте Docker-образ SGLang

```bash
docker pull lmsysorg/sglang:latest
```

### 4. Запустите сервер SGLang

**Базовый запуск (Llama 3.1 8B):**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000
```

**С токеном HuggingFace:**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --dtype bfloat16
```

**Qwen2.5 72B на нескольких GPU:**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --tp 2 \
    --dtype bfloat16
```

**DeepSeek-V2 (модель MoE):**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path deepseek-ai/DeepSeek-V2-Lite-Chat \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --tp 1
```

### 5. Проверьте работоспособность сервера

```bash
# Просмотр журналов
docker logs -f sglang

# Проверка работоспособности (подождите ~2–3 минуты, пока модель загрузится)
curl http://localhost:30000/health

# Получить информацию о модели
curl http://localhost:30000/get_model_info
```

### 6. Доступ извне через прокси CLORE.AI

В вашей панели CLORE.AI есть `http_pub` URL для порта 30000:

```
https://<order-id>-30000.clore.ai/
```

Используйте этот URL как базовый URL в любом клиенте, совместимом с OpenAI.

***

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

### Пример 1: Chat Completions, совместимые с OpenAI

```bash
curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "Вы — полезный ассистент по программированию."},
      {"role": "user", "content": "Напишите реализацию быстрой сортировки на Python."}
    ],
    "max_tokens": 512,
    "temperature": 0.2
  }'
```

### Пример 2: Потоковый ответ

```bash
curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Объясните, как работает attention в трансформере."}
    ],
    "max_tokens": 800,
    "stream": true
  }' \
  --no-buffer
```

### Пример 3: Python OpenAI-клиент

```python
from openai import OpenAI

# Укажите ваш сервер SGLang на CLORE.AI
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang по умолчанию не требует аутентификации
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "Вы — эксперт по науке о данных."},
        {"role": "user", "content": "Что такое градиентный бустинг?"},
    ],
    max_tokens=400,
    temperature=0.7,
)

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

### Пример 4: Пакетный инференс с нативным API SGLang

Нативный API SGLang предоставляет дополнительные возможности управления:

```python
import requests

# Генерация ответов
response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Будущее ИИ — это",
        "sampling_params": {
            "max_new_tokens": 200,
            "temperature": 0.8,
            "top_p": 0.95,
        },
    },
)
print(response.json()["text"])
```

### Пример 5: Ограниченный вывод JSON

SGLang поддерживает генерацию структурированного вывода:

```python
import requests

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"},
    },
    "required": ["name", "age", "city"],
}

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Извлеките информацию: Джон Смит, 35 лет, живет в Нью-Йорке.",
        "sampling_params": {
            "max_new_tokens": 100,
            "temperature": 0.0,
        },
        "json_schema": schema,
    },
)
print(response.json()["text"])
# Вывод: {"name": "John Smith", "age": 35, "city": "New York"}
```

***

## Конфигурация

### Ключевые параметры запуска

| Параметр                | По умолчанию    | Описание                                                   |
| ----------------------- | --------------- | ---------------------------------------------------------- |
| `--model-path`          | обязательно     | ID модели HuggingFace или локальный путь                   |
| `--host`                | `127.0.0.1`     | Хост привязки (используйте `0.0.0.0` для внешнего доступа) |
| `--port`                | `30000`         | Порт сервера                                               |
| `--tp`                  | `1`             | Степень тензорного параллелизма (число GPU)                |
| `--dp`                  | `1`             | Степень параллелизма данных                                |
| `--dtype`               | `auto`          | `float16`, `bfloat16`, `float32`                           |
| `--mem-fraction-static` | `0.88`          | Доля VRAM для KV-кэша                                      |
| `--max-prefill-tokens`  | auto            | Максимум токенов за один шаг prefill                       |
| `--context-length`      | максимум модели | Переопределить максимальную длину контекста                |
| `--trust-remote-code`   | false           | Разрешить пользовательский код модели                      |
| `--quantization`        | нет             | `awq`, `gptq`, `fp8`                                       |
| `--load-format`         | `auto`          | `auto`, `pt`, `safetensors`                                |
| `--tokenizer-path`      | как у модели    | Путь к пользовательскому токенизатору                      |

### Параметры квантования

**AWQ (рекомендуется для скорости):**

```bash
python3 -m sglang.launch_server \
  --model-path casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000
```

**FP8 (для H100/A100):**

```bash
python3 -m sglang.launch_server \
  --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
  --quantization fp8 \
  --host 0.0.0.0 \
  --port 30000
```

***

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

### 1. RadixAttention — ключевое преимущество

RadixAttention в SGLang автоматически повторно использует KV-кэш для общих префиксов промптов. Это особенно полезно для:

* Чат-ботов с длинными системными промптами
* RAG-приложений с повторяющимся контекстом
* Пакетных API-вызовов с общим префиксом

Дополнительная настройка не требуется — это всегда включено.

### 2. Увеличьте размер KV-кэша

```bash
--mem-fraction-static 0.90  # Используйте 90% VRAM для KV-кэша
```

Будьте осторожны, не завышайте слишком сильно — оставьте место для весов модели.

### 3. Разбиение prefill на чанки для длинных контекстов

```bash
--chunked-prefill-size 4096  # Обрабатывайте длинные промпты по частям
```

### 4. Включите бэкенд FlashInfer

SGLang автоматически использует FlashInfer, когда он доступен (GPU Ampere+):

```bash
--attention-backend flashinfer
```

### 5. Тензорный параллелизм на нескольких GPU

Для моделей, которые не помещаются на одной GPU:

```bash
--tp 4  # Используйте 4 GPU
```

На каждой GPU должно быть достаточно VRAM для части модели.

### 6. Настройка под пропускную способность и задержку

**Низкая задержка (один пользователь):**

```bash
--max-running-requests 4
```

**Высокая пропускная способность (много пользователей):**

```bash
--max-running-requests 64 \
--schedule-policy lpm  # Планирование по longest prefix match
```

***

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

### Проблема: "torch.cuda.OutOfMemoryError"

```
torch.cuda.OutOfMemoryError: недостаточно памяти CUDA
```

**Решение:** Уменьшите долю памяти или используйте квантование:

```bash
--mem-fraction-static 0.80
# или
--quantization awq
```

### Проблема: сервер не запускается (зависает на загрузке)

```bash
# Проверьте доступность CUDA
docker exec -it sglang nvidia-smi

# Проверьте прогресс загрузки модели
docker logs -f sglang 2>&1 | tail -50
```

### Проблема: требуется "trust\_remote\_code"

Добавьте `--trust-remote-code` в команду запуска для моделей с пользовательской архитектурой (DeepSeek, Falcon и т. д.).

### Проблема: медленная генерация на моделях MoE

Модели MoE (Mixtral, DeepSeek) ограничены пропускной способностью памяти. Убедитесь, что вы используете:

```bash
--dtype bfloat16  # Лучше, чем float16, для MoE
--tp 2            # Разделите по GPU, если они доступны
```

### Проблема: ошибки длины контекста

```bash
# Переопределите длину контекста
--context-length 32768
```

### Проблема: порт 30000 недоступен

Проверьте, что порт открыт в конфигурации вашего заказа CLORE.AI. Проверяйте URL http\_pub в панели заказа, а не localhost.

***

## Ссылки

* [GitHub](https://github.com/sgl-project/sglang)
* [Документация](https://sgl-project.github.io/start/install.html)
* [Docker Hub](https://hub.docker.com/r/lmsysorg/sglang)
* [Поддерживаемые модели](https://github.com/sgl-project/sglang?tab=readme-ov-file#supported-models)
* [маркетплейс CLORE.AI](https://clore.ai/marketplace)

***

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

| Сценарий использования  | Рекомендуемый GPU | Оценочная стоимость на Clore.ai |
| ----------------------- | ----------------- | ------------------------------- |
| Разработка/тестирование | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                |
| Продакшн (7B–13B)       | RTX 4090 (24 ГБ)  | $0.14–0.42/гпу/ч                |
| Крупные модели (70B+)   | A100 80GB / H100  | \~$1.04/гпу/ч                   |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

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