Быстрый старт с vLLM: высокопроизводительный сервис для LLM — 2026

vLLM — это высокопроизводительный, экономичный по памяти движок для вывода и развертывания больших языковых моделей (LLM), разработанный лабораторией Sky Computing Калифорнийского университета в Беркли.

Благодаря революционному алгоритму PagedAttention, vLLM обеспечивает в 14-24 раза более высокую пропускную способность по сравнению с традиционными методами развертывания, что делает его выбором номер один для производственного использования LLM. Чтобы узнать, как vLLM соотносится с Ollama, Docker Model Runner, LocalAI и облачными провайдерами — включая компромиссы стоимости и инфраструктуры, — ознакомьтесь с LLM Hosting: Local, Self-Hosted & Cloud Infrastructure Compared.

Что такое vLLM?

vLLM (virtual LLM) — это библиотека с открытым исходным кодом для быстрого вывода и развертывания LLM, которая быстро стала отраслевым стандартом для производственных развертываний. Выпущенная в 2023 году, она представила PagedAttention — новаторскую технологию управления памятью, которая радикально улучшает эффективность обслуживания.

Ключевые возможности

Высокая пропускная способность: vLLM обеспечивает в 14-24 раза более высокую пропускную способность по сравнению с HuggingFace Transformers при том же оборудовании. Этот значительный прирост производительности достигается за счет непрерывного батчинга, оптимизированных CUDA-ядр и алгоритма PagedAttention, который устраняет фрагментацию памяти.

Совместимость с API OpenAI: vLLM включает встроенный сервер API, полностью совместимый с форматом OpenAI. Это позволяет бесшовно мигрировать с OpenAI на самохостинговую инфраструктуру без изменения кода приложения. Просто укажите API-клиент на конечную точку vLLM, и всё будет работать прозрачно.

Алгоритм PagedAttention: Ключевая инновация, лежащая в основе производительности vLLM, — это PagedAttention, который применяет концепцию виртуальной памяти к механизмам внимания. Вместо выделения непрерывных блоков памяти для KV-кэшей (что приводит к фрагментации), PagedAttention разделяет память на блоки фиксированного размера, которые могут выделяться по требованию. Это снижает потери памяти до 4 раз и позволяет использовать гораздо более крупные батчи.

Непрерывный батчинг: В отличие от статического батчинга, где вы ждете завершения всех последовательностей, vLLM использует непрерывный (скользящий) батчинг. Как только одна последовательность завершается, в батч может быть добавлена новая. Это максимизирует использование GPU и минимизирует задержку для входящих запросов.

Поддержка нескольких GPU: vLLM поддерживает тензорный параллелизм и конвейерный параллелизм для распределения больших моделей между несколькими GPU. Она может эффективно обслуживать модели, которые не помещаются в память одного GPU, поддерживая конфигурации от 2 до 8+ GPU.

Широкая поддержка моделей: Совместима с популярными архитектурами моделей, включая LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma и многими другими. Поддерживает как модели с инструкциями, так и базовые модели из HuggingFace Hub.

Когда использовать vLLM

vLLM превосходит в специфических сценариях, где её преимущества проявляются наиболее ярко:

Производственные API-сервисы: Когда вам нужно обслуживать LLM для многих одновременных пользователей через API, высокая пропускная способность и эффективный батчинг vLLM делают её лучшим выбором. Компании, работающие с чат-ботами, помощниками по коду или сервисами генерации контента, выигрывают от её способности обрабатывать сотни запросов в секунду.

Нагрузки с высокой конкуренцией: Если ваше приложение имеет множество одновременных пользователей, отправляющих запросы, непрерывный батчинг и PagedAttention vLLM позволяют обслуживать больше пользователей с тем же оборудованием по сравнению с альтернативами.

Оптимизация затрат: Когда стоимость GPU является проблемой, превосходная пропускная способность vLLM означает, что вы можете обслуживать тот же трафик с меньшим количеством GPU, что напрямую снижает затраты на инфраструктуру. Эффективность памяти в 4 раза от PagedAttention также позволяет использовать более мелкие и дешевые инстансы GPU.

Развертывание в Kubernetes: Безсостоячный дизайн и архитектура, дружественная к контейнерам, vLLM идеально подходит для кластеров Kubernetes. Её стабильная производительность под нагрузкой и простое управление ресурсами отлично интегрируются с облачной нативной инфраструктурой.

Когда НЕ использовать vLLM: Для локальной разработки, экспериментов или сценариев с одним пользователем инструменты, такие как Ollama или llama.cpp предоставляют лучший пользовательский опыт с более простой настройкой. Сложность vLLM оправдана, когда вам нужны её преимущества производительности для производственных нагрузок.

Как установить vLLM

Предварительные требования

Перед установкой vLLM убедитесь, что ваша система соответствует следующим требованиям:

• GPU: NVIDIA GPU с вычислительной мощностью 7.0+ (V100, T4, A10, A100, H100, RTX 20/30/40 серии)
• CUDA: Версия 11.8 или выше
• Python: 3.8 — 3.11
• VRAM: Минимум 16 ГБ для моделей 7B, 24 ГБ+ для 13B, 40 ГБ+ для более крупных моделей
• Драйвер: NVIDIA драйвер 450.80.02 или новее

Установка через pip

Самый простой метод установки — использование pip. Это работает на системах с CUDA 11.8 или новее:

# Создайте виртуальное окружение (рекомендуется)
python3 -m venv vllm-env
source vllm-env/bin/activate

# Установите vLLM
pip install vllm

# Проверьте установку
python -c "import vllm; print(vllm.__version__)"

Для систем с другими версиями CUDA установите соответствующий wheel:

# Для CUDA 12.1
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# Для CUDA 11.8
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Установка с помощью Docker

Docker обеспечивает наиболее надежный метод развертывания, особенно для производства:

# Загрузите официальный образ vLLM
docker pull vllm/vllm-openai:latest

# Запустите vLLM с поддержкой GPU
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

Флаг --ipc=host важен для конфигураций с несколькими GPU, так как он обеспечивает правильную межпроцессную коммуникацию.

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

Для новейших функций или кастомных модификаций соберите из исходного кода:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

Быстрый старт vLLM

Запуск вашей первой модели

Запустите vLLM с моделью с помощью командной строки:

# Загрузите и обслуживайте Mistral-7B с API, совместимым с OpenAI
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM автоматически загрузит модель из HuggingFace Hub (если она не кэширована) и запустит сервер. Вы увидите вывод, указывающий на готовность сервера:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

Отправка API-запросов

После запуска сервера вы можете отправлять запросы, используя Python-клиент OpenAI или curl:

Используя curl:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Объясните, что такое vLLM, в одном предложении:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

Используя клиент OpenAI Python:

from openai import OpenAI

# Укажите на ваш сервер vLLM
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM не требует аутентификации по умолчанию
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Объясните, что такое vLLM, в одном предложении:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

API чат-завершений:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "Вы полезный помощник."},
        {"role": "user", "content": "Что такое PagedAttention?"}
    ],
    max_tokens=200
)

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

Расширенная конфигурация

vLLM предлагает множество параметров для оптимизации производительности:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # Использовать 95% памяти GPU
    --max-model-len 8192 \            # Максимальная длина последовательности
    --tensor-parallel-size 2 \        # Использовать 2 GPU с тензорным параллелизмом
    --dtype float16 \                 # Использовать точность FP16
    --max-num-seqs 256                # Максимальный размер батча

Объяснение ключевых параметров:

• --gpu-memory-utilization: Какую часть памяти GPU использовать (0.90 = 90%). Более высокие значения позволяют использовать большие батчи, но оставляют меньше запаса для скачков памяти.
• --max-model-len: Максимальная длина контекста. Уменьшение этого значения экономит память для более крупных батчей.
• --tensor-parallel-size: Количество GPU для разделения модели.
• --dtype: Тип данных для весов (float16, bfloat16 или float32). FP16 обычно оптимален.
• --max-num-seqs: Максимальное количество последовательностей для обработки в батче.

Сравнение vLLM и Ollama

Обе vLLM и Ollama являются популярными вариантами для локального размещения LLM, но они предназначены для разных сценариев использования. Понимание того, когда использовать каждый инструмент, может значительно повлиять на успех вашего проекта.

Производительность и пропускная способность

vLLM создана для максимальной пропускной способности в сценариях с множеством пользователей. Её PagedAttention и непрерывный батчинг позволяют эффективно обслуживать сотни одновременных запросов. Бенчмарки показывают, что vLLM достигает в 14-24 раза более высокой пропускной способности, чем стандартные реализации, и в 2-4 раза выше, чем у Ollama при высокой конкуренции.

Ollama оптимизирована для интерактивного использования одним пользователем с акцентом на низкую задержку для отдельных запросов. Хотя она не достигает пропускной способности vLLM для множества пользователей, она обеспечивает отличную производительность для разработки и личного использования с более быстрым временем холодного старта и меньшим потреблением ресурсов в простое.

Простота использования

Ollama выигрывает в простоте. Установка — это одна команда (curl | sh), а запуск моделей так же прост, как ollama run llama2. Она включает библиотеку моделей с квантованными версиями, оптимизированными для различных профилей оборудования. Пользовательский опыт напоминает Docker — загрузите, запустите и работайте.

vLLM требует больше настройки: управление средой Python, установка CUDA, понимание параметров обслуживания и указание моделей вручную. Кривая обучения круче, но вы получаете тонкий контроль над оптимизацией производительности. Эта сложность оправдана для производственных развертываний, где вам нужно выжать максимум производительности из вашего оборудования.

API и интеграция

vLLM предоставляет API REST, совместимые с OpenAI, «из коробки», что делает её готовой заменой API OpenAI в существующих приложениях. Это критично для миграции производственных сервисов от облачных провайдеров к самохостинговой инфраструктуре без изменений в коде.

Ollama предлагает более простой REST API и выделенную Python/JavaScript библиотеку. Хотя она функциональна, она не совместима с OpenAI, что требует изменений в коде при интеграции с приложениями, ожидающими формат OpenAI. Однако проекты сообщества, такие как адаптеры Ollama-OpenAI, закрывают этот разрыв.

Управление памятью

Алгоритм PagedAttention vLLM обеспечивает превосходную эффективность памяти для одновременных запросов. Она может обслуживать в 2-4 раза больше одновременных пользователей с тем же объемом VRAM по сравнению с наивными реализациями. Это напрямую переводится в экономию средств при производственных развертываниях.

Ollama использует более простое управление памятью, подходящее для сценариев с одним пользователем. Она автоматически управляет загрузкой/выгрузкой моделей в зависимости от активности, что удобно для разработки, но не оптимально для высококонкурентного производственного использования.

Поддержка нескольких GPU

vLLM превосходит в работе с нативным тензорным и конвейерным параллелизмом, эффективно распределяя модели между 2-8+ GPU. Это необходимо для обслуживания больших моделей, таких как LLM с 70B параметрами, которые не помещаются в память одного GPU.

Ollama в настоящее время имеет ограниченную поддержку нескольких GPU, работая лучше всего с одним GPU. Это делает её менее подходящей для очень больших моделей, требующих распределенного вывода.

Рекомендации по сценариям использования

Выберите vLLM, когда:

• Обслуживание производственных API для многих одновременных пользователей
• Оптимизация стоимости на запрос в облачных развертываниях
• Запуск в Kubernetes или платформах оркестрации контейнеров
• Необходима совместимость с API OpenAI для существующих приложений
• Обслуживание больших моделей, требующих поддержки нескольких GPU
• Производительность и пропускная способность являются критическими требованиями

Выберите Ollama, когда:

• Локальная разработка и эксперименты
• Интерактивное использование одним пользователем (личные помощники, чат-боты)
• Быстрое прототипирование и оценка моделей
• Изучение LLM без сложности инфраструктуры
• Запуск на персональных рабочих станциях или ноутбуках
• Простота и удобство использования являются приоритетами

Многие команды используют оба инструмента: Ollama для разработки и экспериментов, затем vLLM для производственного развертывания. Эта комбинация обеспечивает производительность разработчика, сохраняя производственную производительность.

vLLM против Docker Model Runner

Docker недавно представила Model Runner (ранее GenAI Stack) как свое официальное решение для локального развертывания AI-моделей. Как она сравнивается с vLLM?

Философия архитектуры

Docker Model Runner стремится стать «Docker для AI» — простым, стандартизированным способом запуска AI-моделей локально с той же простотой, что и запуск контейнеров. Она абстрагирует сложность и предоставляет согласованный интерфейс для различных моделей и фреймворков.

vLLM — это специализированный движок вывода, сфокусированный исключительно на обслуживании LLM с максимальной производительностью. Это инструмент более низкого уровня, который вы контейнеризируете с помощью Docker, а не полноценная платформа.

Настройка и начало работы

Установка Docker Model Runner проста для пользователей Docker:

docker model pull llama3:8b
docker model run llama3:8b

Эта схожесть с workflow изображений Docker делает её мгновенно знакомой разработчикам, уже использующим контейнеры.

vLLM требует более начальной настройки (Python, CUDA, зависимости) или использования предварительно собранных Docker-образов:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <model-name>

Характеристики производительности

vLLM обеспечивает превосходную пропускную способность для сценариев с множеством пользователей благодаря PagedAttention и непрерывному батчингу. Для производственных API-сервисов, обрабатывающих сотни запросов в секунду, оптимизации vLLM обеспечивают в 2-5 раза лучшую пропускную способность, чем общие подходы к обслуживанию.

Docker Model Runner фокусируется на простоте использования, а не на максимальной производительности. Она подходит для локальной разработки, тестирования и умеренных нагрузок, но не реализует расширенную оптимизацию, которая делает vLLM выдающейся в масштабе.

Поддержка моделей

Docker Model Runner предоставляет курируемую библиотеку моделей с доступом к популярным моделям в одну команду. Она поддерживает несколько фреймворков (не только LLM), включая Stable Diffusion, Whisper и другие AI-модели, делая её более универсальной для различных AI-нагрузок.

vLLM специализируется на выводе LLM с глубокой поддержкой языковых моделей на основе трансформеров. Она поддерживает любые совместимые с HuggingFace LLM, но не расширяется на другие типы AI-моделей, такие как генерация изображений или распознавание речи.

Производственное развертывание

vLLM проверена в производстве такими компаниями, как Anthropic, Replicate и многими другими, обслуживающими миллиарды токенов ежедневно. Её характеристики производительности и стабильность под тяжелой нагрузкой делают её де-факто стандартом для производственного обслуживания LLM.

Docker Model Runner новее и позиционируется скорее для разработки и локального тестирования. Хотя она может обслуживать производственный трафик, она не имеет проверенной истории и оптимизаций производительности, необходимых для производственных развертываний.

Экосистема интеграции

vLLM интегрируется с инструментами производственной инфраструктуры: операторами Kubernetes, метриками Prometheus, Ray для распределенного обслуживания и обширной совместимостью с API OpenAI для существующих приложений.

Docker Model Runner естественно интегрируется с экосистемой Docker и Docker Desktop. Для команд, уже стандартизированных на Docker, эта интеграция обеспечивает согласованный опыт, но с меньшим количеством специализированных функций обслуживания LLM.

Когда использовать каждый

Используйте vLLM для:

• Производственных API-сервисов LLM
• Развертываний с высокой пропускной способностью и множеством пользователей
• Затратных облачных развертываний, требующих максимальной эффективности
• Сред Kubernetes и облачно-нативных сред
• Когда вам нужна доказанная масштабируемость и производительность

Используйте Docker Model Runner для:

• Локальной разработки и тестирования
• Запуска различных типов AI-моделей (не только LLM)
• Команд, сильно инвестирующих в экосистему Docker
• Быстрых экспериментов без настройки инфраструктуры
• Обучения и образовательных целей

Гибридный подход: Многие команды разрабатывают с помощью Docker Model Runner локально для удобства, затем развертывают с помощью vLLM в производстве для производительности. Образы Docker Model Runner также могут использоваться для запуска контейнеров vLLM, объединяя оба подхода.

Лучшие практики производственного развертывания

Развертывание Docker

Создайте конфигурацию Docker Compose, готовую к производству:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

Развертывание Kubernetes

Разверните vLLM в Kubernetes для масштабирования производства:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Мониторинг и наблюдаемость

vLLM экспортирует метрики Prometheus для мониторинга:

import requests

# Получите метрики
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Ключевые метрики для мониторинга:

• vllm:num_requests_running - Активные запросы
• vllm:gpu_cache_usage_perc - Использование KV-кэша
• vllm:time_to_first_token - Метрика задержки
• vllm:time_per_output_token - Скорость генерации

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

Оптимизируйте использование памяти GPU: Начните с --gpu-memory-utilization 0.90 и корректируйте на основе наблюдаемого поведения. Более высокие значения позволяют использовать большие батчи, но рискуют вызвать ошибки OOM во время скачков трафика.

Настройте максимальную длину последовательности: Если ваш сценарий не требует полной длины контекста, уменьшите --max-model-len. Это освободит память для более крупных батчей. Например, если вам нужна только 4K контекстная длина, установите --max-model-len 4096 вместо использования максимального значения модели (часто 8K-32K).

Выберите подходящую квантование: Для моделей, поддерживающих это, используйте квантованные версии (8-бит, 4-бит), чтобы уменьшить память и увеличить пропускную способность:

--quantization awq  # Для квантованных AWQ моделей
--quantization gptq # Для квантованных GPTQ моделей

Включите кэширование префиксов: Для приложений с повторяющимися промптами (например, чат-боты с системными сообщениями) включите кэширование префиксов:

--enable-prefix-caching

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

Устранение распространенных проблем

Ошибки переполнения памяти

Симптомы: Сервер падает с ошибками CUDA out of memory.

Решения:

• Уменьшите --gpu-memory-utilization до 0.85 или 0.80
• Уменьшите --max-model-len, если ваш сценарий позволяет
• Уменьшите --max-num-seqs, чтобы уменьшить размер батча
• Используйте квантованную версию модели
• Включите тензорный параллелизм для распределения между большим количеством GPU

Низкая пропускная способность

Симптомы: Сервер обрабатывает меньше запросов, чем ожидается.

Решения:

• Увеличьте --max-num-seqs, чтобы разрешить большие батчи
• Повысьте --gpu-memory-utilization, если у вас есть запас
• Проверьте, не является ли CPU узким местом с помощью htop — рассмотрите более быстрые CPU
• Проверьте использование GPU с помощью nvidia-smi — должно быть 95%+
• Включите FP16, если используете FP32: --dtype float16

Медленное время первого токена

Симптомы: Высокая задержка перед началом генерации.

Решения:

• Используйте более маленькие модели для приложений, критичных к задержке
• Включите кэширование префиксов для повторяющихся промптов
• Уменьшите --max-num-seqs, чтобы приоритизировать задержку над пропускной способностью
• Рассмотрите спекулятивное декодирование для поддерживаемых моделей
• Оптимизируйте конфигурацию тензорного параллелизма

Ошибки загрузки модели

Симптомы: Сервер не запускается, не может загрузить модель.

Решения:

• Проверьте, что имя модели точно соответствует формату HuggingFace
• Проверьте сетевое подключение к HuggingFace Hub
• Убедитесь в достаточном дисковом пространстве в ~/.cache/huggingface
• Для закрытых моделей установите переменную окружения HF_TOKEN
• Попробуйте вручную загрузить с помощью huggingface-cli download <model>

Расширенные функции

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

vLLM поддерживает спекулятивное декодирование, где меньшая модель-черновик предлагает токены, которые большая целевая модель проверяет. Это может ускорить генерацию в 1.5-2 раза:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

Адаптеры LoRA

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

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./path/to/sql-adapter \
                   code-lora=./path/to/code-adapter

Затем укажите, какой адаптер использовать для каждого запроса:

response = client.completions.create(
    model="sql-lora",  # Используйте SQL-адаптер
    prompt="Преобразуйте это в SQL: Покажите всех пользователей, созданных в этом месяце"
)

Множественное обслуживание LoRA

Множественное обслуживание LoRA vLLM позволяет размещать десятки донастроенных адаптеров с минимальными накладными расходами памяти. Это идеально подходит для обслуживания вариантов моделей, специфичных для клиентов или задач:

# Запрос с конкретным адаптером LoRA
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "Напишите SQL-запрос"}],
    extra_body={"lora_name": "sql-lora"}
)

Кэширование префиксов

Включите автоматическое кэширование префиксов, чтобы избежать пересчета KV-кэша для повторяющихся префиксов промптов:

--enable-prefix-caching

Это особенно эффективно для:

• Чат-ботов с фиксированными системными промптами
• Приложений RAG с согласованными шаблонами контекста
• Промптов few-shot обучения, повторяемых в запросах

Кэширование префиксов может сократить время до первого токена на 50-80% для запросов, разделяющих префиксы промптов.

Примеры интеграции

Интеграция с LangChain

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("Объясните PagedAttention простыми терминами")
print(response)

Интеграция с LlamaIndex

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("Что такое vLLM?")
print(response)

Приложение FastAPI

from fastapi import FastAPI
from openai import AsyncOpenAI

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

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

Бенчмарки производительности

Данные реальной производительности помогают проиллюстрировать преимущества vLLM:

Сравнение пропускной способности (Mistral-7B на GPU A100):

• vLLM: ~3,500 токенов/секунду с 64 одновременными пользователями
• HuggingFace Transformers: ~250 токенов/секунду с той же конкуренцией
• Ollama: ~1,200 токенов/секунду с той же конкуренцией
• Результат: vLLM обеспечивает улучшение в 14 раз по сравнению с базовыми реализациями

Эффективность памяти (LLaMA-2-13B):

• Стандартная реализация: 24 ГБ VRAM, 32 одновременные последовательности
• vLLM с PagedAttention: 24 ГБ VRAM, 128 одновременных последовательностей
• Результат: В 4 раза больше одновременных запросов с той же памятью

Задержка под нагрузкой (Mixtral-8x7B на 2xA100):

• vLLM: Латентность P50 180 мс, P99 420 мс при 100 req/s
• Стандартное обслуживание: Латентность P50 650 мс, P99 3,200 мс при 100 req/s
• Результат: vLLM сохраняет согласованную задержку под высокой нагрузкой

Эти бенчмарки демонстрируют, почему vLLM стала де-факто стандартом для производственного обслуживания LLM, где производительность имеет значение.

Анализ затрат

Понимание стоимостных последствий выбора vLLM:

Сценарий: Обслуживание 1 млн запросов в день

Со стандартным обслуживанием:

• Требуется: 8x GPU A100 (80 ГБ)
• Стоимость AWS: ~$32/час × 24 × 30 = $23,040/месяц
• Стоимость за 1 млн токенов: ~$0.75

С vLLM:

• Требуется: 2x GPU A100 (80 ГБ)
• Стоимость AWS: ~$8/час × 24 × 30 = $5,760/месяц
• Стоимость за 1 млн токенов: ~$0.19
• Экономия: $17,280/месяц (снижение на 75%)

Это преимущество в стоимости растет с масштабом. Организации, обслуживающие миллиарды токенов ежемесячно, экономят сотни тысяч долларов, используя оптимизированное обслуживание vLLM вместо наивных реализаций.

Соображения безопасности

Аутентификация

vLLM не включает аутентификацию по умолчанию. Для производства реализуйте аутентификацию на уровне обратного прокси:

# Конфигурация Nginx
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

Или используйте API-шлюзы, такие как Kong, Traefik или AWS API Gateway для корпоративной аутентификации и ограничения скорости.

Сетевая изоляция

Запускайте vLLM в частных сетях, не подвергая его напрямую интернету:

# Пример Kubernetes NetworkPolicy
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

Ограничение скорости

Реализуйте ограничение скорости, чтобы предотвратить злоупотребления:

# Пример использования Redis для ограничения скорости
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    
    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # 60-секундное окно
    
    if requests > 60:  # 60 запросов в минуту
        raise HTTPException(status_code=429, detail="Превышено ограничение скорости")
    
    return await call_next(request)

Контроль доступа к моделям

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

ALLOWED_MODELS = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # Все модели
}

def verify_model_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

Руководство по миграции

От OpenAI к vLLM

Миграция с OpenAI на самохостинг vLLM проста благодаря совместимости API:

До (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Привет"}]
)

После (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://your-vllm-server.com/v1",
    api_key="your-internal-key"  # Если вы добавили аутентификацию
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Привет"}]
)

Необходимо только два изменения: обновите base_url и имя model. Весь остальной код остается идентичным.

От Ollama к vLLM

Ollama использует другой формат API. Вот конвертация:

API Ollama:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'llama2',
        'prompt': 'Почему небо голубое?'
    })

Эквивалент vLLM:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="Почему небо голубое?"
)

Вам придется обновить вызовы API во всем коде, но библиотеки клиента OpenAI обеспечивают лучшую обработку ошибок и функции.

От HuggingFace Transformers к vLLM

Миграция прямого использования Python:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Hello", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Hello", sampling_params)
result = outputs[0].outputs[0].text

Python API vLLM проще и намного быстрее для пакетного вывода.

Будущее vLLM

vLLM продолжает быстрое развитие с захватывающими функциями в дорожной карте:

Разделенное обслуживание: Разделение префилла (обработка промпта) и декодирования (генерация токенов) на разные GPU для оптимизации использования ресурсов. Префилл вычислительно ограничен, в то время как декодирование ограничено памятью, поэтому запуск их на специализированном оборудовании повышает эффективность.

Множественный узел вывода: Распределение очень больших моделей (100B+ параметров) между несколькими машинами, позволяя обслуживать модели, слишком большие для одноузловых настроек.

Улучшенное квантование: Поддержка новых форматов квантования, таких как GGUF (используется в llama.cpp) и улучшенная интеграция AWQ/GPTQ для лучшей производительности с квантованными моделями.

Улучшения спекулятивного декодирования: Более эффективные модели-черновики и адаптивные стратегии спекуляции для достижения более высоких ускорений без потери точности.

Оптимизации внимания: FlashAttention 3, кольцевое внимание для чрезвычайно длинных контекстов (100K+ токенов) и другие передовые механизмы внимания.

Лучшее покрытие моделей: Расширение поддержки мультимодальных моделей (модели зрения-языка), аудио-моделей и специализированных архитектур по мере их появления.

Проект vLLM поддерживает активное развитие с вкладом от UC Berkeley, Anyscale и более широкого сообщества с открытым исходным кодом. Поскольку развертывание LLM становится все более критичным для производственных систем, роль vLLM как стандарта производительности продолжает расти. Для более широкого сравнения vLLM с другими локальными и облачными инфраструктурами LLM, ознакомьтесь с нашим LLM Hosting: Local, Self-Hosted & Cloud Infrastructure Compared.

Полезные ссылки

Статьи на этом сайте

• Local LLM Hosting: Complete 2026 Guide - Ollama, vLLM, LocalAI, Jan, LM Studio & More - Всеобъемлющее сравнение 12+ локальных инструментов размещения LLM, включая подробный анализ vLLM вместе с Ollama, LocalAI, Jan, LM Studio и другими. Охватывает зрелость API, поддержку вызова инструментов, совместимость GGUF и производительность бенчмарков для выбора правильного решения.

• Ollama Cheatsheet - Полное справочное руководство и cheatsheet команд Ollama, охватывающее установку, управление моделями, использование API и лучшие практики для локального развертывания LLM. Необходимо для разработчиков, использующих Ollama вместе с vLLM или вместо него.

• llama.cpp Quickstart with CLI and Server - Легковесный вывод C/C++ для моделей GGUF с llama-cli и OpenAI-совместимым llama-server. Идеально, когда вам нужен тонкий контроль, оффлайн развертывание или минимальный стек без Python.

• Docker Model Runner vs Ollama: Which to Choose? - Подробное сравнение Model Runner от Docker и Ollama для локального развертывания LLM, анализирующее производительность, поддержку GPU, совместимость API и сценарии использования. Помогает понять конкурентный ландшафт, в котором работает vLLM.

• Docker Model Runner Cheatsheet: Commands & Examples - Практический cheatsheet Docker Model Runner с командами и примерами для развертывания AI-моделей. Полезен для команд, сравнивающих подход Docker со специализированными возможностями обслуживания LLM vLLM.

Внешние ресурсы и документация

• vLLM GitHub Repository - Официальный репозиторий vLLM с исходным кодом, всеобъемлющей документацией, руководствами по установке и активными обсуждениями сообщества. Необходимый ресурс для обновления по новейшим функциям и устранения проблем.

• vLLM Documentation - Официальная документация, охватывающая все аспекты vLLM от базовой настройки до расширенной конфигурации. Включает ссылки на API, руководства по настройке производительности и лучшие практики развертывания.

• PagedAttention Paper - Академическая статья, представляющая алгоритм PagedAttention, который питает эффективность vLLM. Необходимое чтение для понимания технических инноваций за преимуществом vLLM в производительности.

• vLLM Blog - Официальный блог vLLM, содержащий объявления о выпусках, бенчмарки производительности, технические подробности и кейс-стадии сообщества из производственных развертываний.

• HuggingFace Model Hub - Всеобъемлющий репозиторий открытых-source LLM, работающих с vLLM. Ищите модели по размеру, задаче, лицензии и характеристикам производительности, чтобы найти правильную модель для вашего сценария использования.

• Ray Serve Documentation - Документация фреймворка Ray Serve для построения масштабируемых, распределенных развертываний vLLM. Ray предоставляет расширенные функции, такие как автомасштабирование, обслуживание нескольких моделей и управление ресурсами для производственных систем.

• NVIDIA TensorRT-LLM - TensorRT-LLM от NVIDIA для высокооптимизированного вывода на GPU NVIDIA. Альтернатива vLLM с разными стратегиями оптимизации, полезная для сравнения и понимания ландшафта оптимизации вывода.

• OpenAI API Reference - Официальная документация API OpenAI, с которой совместим API vLLM. Используйте этот справочник при построении приложений, которые должны работать как с OpenAI, так и с самохостинговыми конечными точками vLLM взаимозаменяемо.