vLLM — 高性能 LLM 推理服务引擎

GitHub: vllm-project/vllm
Stars: 82,900+ | Language: Python (84.4%) | License: Apache-2.0
官网: docs.vllm.ai

目录

1. 项目速览
2. 功能概述
3. 适用场景
4. 快速上手
5. 源码架构
6. 实操 Demo
7. 同类对比
8. 参考资源

项目速览

vLLM 是 UC Berkeley 研究团队发起的高性能 LLM 推理服务框架，由 Sky Computing Lab 的 Woosuk Kwon 等人主导开发。其核心创新 PagedAttention 算法发表于 SOSP 2023（系统领域顶会），论文《Efficient Memory Management for Large Language Model Serving with PagedAttention》从根本上解决了 LLM 推理中 KV Cache 内存碎片化的问题，在吞吐量上相比传统方案提升 2-4 倍。

截至 2026 年 6 月，项目在 GitHub 上已获得 82,900+ Star，社区贡献者超过 800 人，支持 200+ 模型架构，涵盖纯文本 LLM、MoE 模型、多模态模型和 Embedding/检索模型。vLLM 已成为行业内部署 LLM 服务的首选方案之一，被 AWS、Google Cloud、Anyscale 等平台广泛采用。项目完全兼容 OpenAI API 协议，开发者在切换到 vLLM 后端时无需修改任何上层代码。

功能概述

PagedAttention — KV Cache 分页管理

PagedAttention 是 vLLM 最核心的创新。传统 LLM 推理中，每个请求的 KV Cache 需要预分配一块连续内存，导致严重的碎片化问题（类比操作系统的内部碎片）和低内存利用率。PagedAttention 借鉴操作系统虚拟内存的分页思想，将 KV Cache 切分为固定大小的”页”（block），以非连续方式动态分配和回收。这样，内存浪费从传统方案的 60-80% 降至不到 4%，显著提升了并发处理能力。

实际效果：在相同硬件上，vLLM 的吞吐量可达 HuggingFace Transformers 的 24 倍（基于 OPT-13B 模型测试），这得益于 PagedAttention 带来的更高并发度和更小的内存占用。

Continuous Batching — 持续批处理

传统推理服务采用”静态批处理”（static batching），即等待一批请求全部完成后再处理下一批，导致先完成的请求浪费等待时间。vLLM 实现了 continuous batching（也称为 iteration-level scheduling）：在每个推理迭代中动态调整批处理组合，当某个请求生成完毕立即将其移出批次，同时接受新的请求加入。这种调度策略将 GPU 利用率提升至接近 100%，有效降低 P50/P99 延迟。

与此配合的还有 chunked prefill 技术：将长 prompt 的 prefill 阶段拆分为多个 chunk 与 decode 迭代交替执行，避免单个长 prompt 阻塞整个批次。

丰富的量化支持

vLLM 支持几乎所有主流量化方案，无需开发者自行转换模型格式：

• 权重量化：AWQ、GPTQ（INT4）、FP8（NVIDIA H100/Ada 原生支持）、MXFP8/MXFP4、NVFP4、INT8
• KV Cache 量化：FP8 KV Cache，进一步降低显存占用
• GGUF 支持：可直接加载 llama.cpp 生态的 GGUF 格式模型
• TorchAO、ModelOpt：支持 PyTorch 原生的量化方案
• compressed-tensors：支持稀疏化权重

通过 --quantization 参数即可启用：

vllm serve meta-llama/Llama-3.1-70B-Instruct --quantization awq

OpenAI 兼容 API 与多协议支持

vLLM 启动后默认在 http://localhost:8000 提供与 OpenAI 完全兼容的 API，端点包括 /v1/completions、/v1/chat/completions、/v1/embeddings。可以直接使用 openai Python SDK 调用：

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="token-abc123")
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "什么是 PagedAttention？"}]
)
print(response.choices[0].message.content)

此外还支持 Anthropic Messages API 和 gRPC 协议，适配更多客户端场景。

高级推理优化

vLLM 集成了大量前沿推理加速技术：

• Speculative Decoding：使用草稿模型（draft model）进行推测性解码，支持 n-gram、suffix、EAGLE、DFlash 等多种变体，在低延迟场景下可实现 2-3 倍加速
• Prefix Caching：自动缓存公共前缀的 KV Cache（如 System Prompt），多用户共享同一系统提示时避免重复计算
• Multi-LoRA：支持批量并发推理多个 LoRA 适配器，单个部署即可服务数千个微调变体
• Structured Outputs：通过 xgrammar 或 guidance 实现 JSON 模式约束生成，确保输出符合预定义格式
• 注意力后端：支持 FlashAttention、FlashInfer、TRTLLM-GEN、FlashMLA、Triton 等 10+ 种注意力内核

全硬件平台覆盖

vLLM 不仅支持 NVIDIA GPU（从消费级 RTX 到数据中心 H100/B200），还适配了 AMD GPU（ROCm）、Intel Gaudi、Google TPU、x86/ARM/PowerPC CPU，甚至是 Apple Silicon（M 系列芯片通过 Metal 加速）。这意味着同一套代码可以在不同硬件上无需修改地运行。

适用场景

生产级 LLM API 服务

vLLM 的 OpenAI 兼容 API 和 production-ready 设计使其成为构建 LLM API 网关的理想选择。使用 vLLM 可以将开源模型包装为 OpenAI 兼容接口，无缝替代 OpenAI 后端。

高并发在线推理

对于需要处理数百个并发请求的场景（如在线客服、教育辅导），PagedAttention 的内存效率和 continuous batching 的调度优化可以将 GPU 利用率推至极限，在有限硬件上支持更多用户。

批量离线推理

vLLM 的离线推理模式可以直接作为 Python 库在脚本中调用，适合批量处理文本（如数据标注、语料生成、评测打分）。离线模式共享与在线服务相同的优化内核。

多模态应用服务

vLLM 支持 LLaVA、Qwen2-VL、InternVL2、Phi-3-Vision 等多模态模型，可以部署支持图像理解、视频分析的视觉语言模型服务，API 格式与纯文本服务一致。

多租户多模型平台

借助 Multi-LoRA 和模型并行能力，单个 vLLM 集群可以同时托管多个基础模型和数千个 LoRA 变体，适合 MLOps 平台和模型超市场景。

快速上手

环境要求

• NVIDIA GPU（Compute Capability 7.0+ 推荐）或 AMD GPU / CPU
• CUDA 12.1+（NVIDIA GPU）
• Python 3.9+

安装

推荐使用 uv（pip 也可）：

# 使用 uv（推荐，速度更快）
uv pip install vllm

# 或使用 pip
pip install vllm

如需从源码构建（开发场景）：

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

启动 API 服务

# 启动 OpenAI 兼容 API 服务器（默认端口 8000）
vllm serve meta-llama/Llama-3.1-8B-Instruct

# 指定端口、GPU 显存利用率
vllm serve mistralai/Mistral-7B-Instruct-v0.3 \
    --port 8080 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 8192

# 使用量化模型
vllm serve Qwen/Qwen2.5-7B-Instruct-AWQ --quantization awq

# 多 GPU 张量并行
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4

Python 客户端调用

from openai import OpenAI

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

# 单轮对话
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "你好！请用三句话介绍你自己。"}],
    temperature=0.7,
    max_tokens=256,
)
print(response.choices[0].message.content)

# 流式输出
stream = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "写一首关于AI的五言绝句"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

离线推理（作为 Python 库）

from vllm import LLM, SamplingParams

llm = LLM(model="meta-llama/Llama-3.1-8B-Instruct")

prompts = [
    "用一句话解释什么是机器学习。",
    "写一个冒泡排序的 Python 实现。",
]
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=256)
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt}")
    print(f"Response: {generated_text}")
    print("---")

源码架构

vLLM 仓库核心目录结构：

vllm/
├── vllm/
│   ├── entrypoints/          # API 入口层
│   │   ├── openai/           # OpenAI 兼容 API 路由（chat/completions/embeddings）
│   │   └── llm.py            # LLM 类（离线推理入口）
│   ├── engine/               # 推理引擎核心
│   │   ├── llm_engine.py     # LLMEngine：请求调度与生命周期管理
│   │   └── async_llm_engine.py  # AsyncLLMEngine：异步引擎（用于 API 服务）
│   ├── core/                 # 调度器
│   │   ├── scheduler.py      # Scheduler：核心调度器，实现 continuous batching
│   │   └── block_manager.py  # BlockSpaceManager：PagedAttention 内存管理
│   ├── attention/            # 注意力层
│   │   ├── backends/         # 多种注意力后端（FlashAttention/FlashInfer/Triton）
│   │   └── ops/              # PagedAttention 操作实现
│   ├── worker/               # 工作节点
│   │   ├── worker.py         # Worker：单个 GPU 的设备级执行器
│   │   └── model_runner.py   # ModelRunner：模型加载与前向传播
│   ├── model_executor/       # 模型执行器
│   │   ├── models/           # 200+ 模型架构实现
│   │   └── layers/           # 模型层（Attention/MLP/MoE等）
│   ├── lora/                 # LoRA 适配器支持
│   ├── quantization/         # 量化后端（AWQ/GPTQ/FP8/GGUF等）
│   └── config.py             # 全局配置管理
├── csrc/                     # C++/CUDA 扩展（自定义算子）
├── benchmarks/               # 性能基准测试
├── tests/                    # 测试套件
├── docs/                     # 文档
└── examples/                 # 使用示例

核心模块说明：

• LLMEngine：推理引擎的顶层抽象，负责接收请求、协调调度器和 Worker。维护请求队列，将请求分发给 Scheduler 进行调度，管理生成结果的生命周期。
• Scheduler：实现 continuous batching 的核心调度逻辑。在每个推理步（step）中决定哪些请求参与本轮计算，分配 block 资源，管理 prefill 和 decode 阶段的切换。
• BlockSpaceManager：PagedAttention 的页面管理器。将每个序列的 KV Cache 映射为一组固定大小的 block，支持 COW（写时复制）机制实现高效的内存共享（如 beam search）。
• Worker 和 ModelRunner：Worker 是单 GPU 的执行单元，ModelRunner 负责实际加载模型权重并执行前向传播。支持张量并行模式下多 GPU 通信（基于 NCCL）。
• attention/backends：注意力计算的后端抽象层，支持 FlashAttention v2/v3、FlashInfer、Triton 等多种实现，根据硬件能力和模型需求自动选择最优后端。

实操 Demo

完整部署示例：从安装到生产级 API 服务

以下演示部署一个 Qwen2.5-7B-Instruct 模型，提供 OpenAI 兼容 API，并使用量化以降低显存需求。

1. 安装 vLLM

pip install vllm

2. 下载模型（可选，不指定则自动从 HF Hub 拉取）

huggingface-cli download Qwen/Qwen2.5-7B-Instruct --local-dir ./models/Qwen2.5-7B-Instruct

3. 启动 API 服务

# 单 GPU 部署（7B 模型约需 16GB 显存）
vllm serve Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 4096 \
    --dtype auto

服务启动后，访问 http://localhost:8000/docs 查看 Swagger UI。控制台会打印类似输出：

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

4. 测试 Chat Completions（Python）

import time
from openai import OpenAI

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

# 测试普通对话
def chat(prompt: str, stream: bool = False):
    response = client.chat.completions.create(
        model="Qwen/Qwen2.5-7B-Instruct",
        messages=[
            {"role": "system", "content": "你是一个精通计算机科学的中文技术助手。"},
            {"role": "user", "content": prompt},
        ],
        temperature=0.7,
        max_tokens=512,
        stream=stream,
    )
    if stream:
        for chunk in response:
            if chunk.choices[0].delta.content:
                print(chunk.choices[0].delta.content, end="", flush=True)
        print()
    else:
        print(response.choices[0].message.content)
    return response

# 测试并发性能：同时发送 10 个请求
import concurrent.futures

prompts = [f"请用 {i+1} 句话解释什么是 PagedAttention" for i in range(10)]

start = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
    futures = [executor.submit(chat, p) for p in prompts]
    concurrent.futures.wait(futures)
elapsed = time.time() - start

print(f"\n10 个并发请求总耗时: {elapsed:.2f}秒")
print(f"平均每个请求耗时: {elapsed/10:.2f}秒")

# 测试 Embeddings API
embedding_response = client.embeddings.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    input=["什么是深度学习？", "What is deep learning?"],
)
print(f"\nEmbedding 维度: {len(embedding_response.data[0].embedding)}")

5. 测试 Chat Completions（curl）

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "messages": [
      {"role": "user", "content": "用 Rust 写一个 hello world"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }' | jq '.choices[0].message.content'

6. 使用离线引擎批量处理

from vllm import LLM, SamplingParams

# 加载模型（使用量化以降低显存）
llm = LLM(
    model="Qwen/Qwen2.5-7B-Instruct",
    quantization="awq",  # 如使用 AWQ 量化版模型
    gpu_memory_utilization=0.9,
    max_model_len=4096,
)

# 准备批量数据
texts = [
    "用中文写一个二分查找的 Python 实现。",
    "解释 Transformer 架构中的 Self-Attention 机制。",
    "什么是 CAP 定理？请用通俗语言解释。",
    "比较 SQL 和 NoSQL 数据库的优缺点。",
    "用 Markdown 绘制一个软件项目开发流程图。",
]

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512,
    stop=["\n\n\n"],  # 遇到三个连续换行停止
)

# 批量生成
outputs = llm.generate(texts, sampling_params)

for i, output in enumerate(outputs):
    print(f"=== 问题 {i+1} ===")
    print(f"Prompt: {output.prompt[:50]}...")
    print(f"回答: {output.outputs[0].text.strip()}")
    print(f"Token 数: {len(output.outputs[0].token_ids)}")
    print()

7. Structured Output（JSON 约束生成）

from openai import OpenAI

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

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": "生成3个中国城市及其人口和著名景点信息"}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "cities_info",
            "schema": {
                "type": "object",
                "properties": {
                    "cities": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "population": {"type": "integer"},
                                "attractions": {
                                    "type": "array",
                                    "items": {"type": "string"}
                                }
                            },
                            "required": ["name", "population", "attractions"]
                        }
                    }
                },
                "required": ["cities"]
            }
        }
    },
    max_tokens=512,
)

import json
result = json.loads(response.choices[0].message.content)
for city in result["cities"]:
    print(f"{city['name']}: 人口 {city['population']} 万, 著名景点: {', '.join(city['attractions'])}")

同类对比

特性	vLLM	SGLang	TGI	Ollama	llama.cpp
核心优化	PagedAttention	RadixAttention (Prefix Cache)	Tensor Parallelism	零配置一键运行	纯 C/C++ 无依赖
吞吐量	极高（2-24x HF）	极高（部分场景 5x）	高	中等	中等（CPU/边缘）
内存效率	极高（KV Cache 分页）	高（前缀缓存）	中等	依赖 llama.cpp	高（量化极致）
部署复杂度	中等（pip install）	中等（pip install）	较高（需要 Docker）	极低	低（make 编译）
OpenAI API 兼容	完整支持	完整支持	完整支持	REST API（非标准）	完整支持（llama-server）
量化支持	AWQ/GPTQ/FP8/GGUF 等	AWQ/GPTQ/FP8/INT4 等	GPT-Q/AWQ/bitsandbytes	自动 Q4_0	Q2-Q8, 1.5-bit, IQ 系列
硬件支持	Nvidia/AMD/TPU/CPU/Apple	Nvidia/AMD/TPU/CPU	Nvidia/AMD/Intel/TPU	Nvidia/AMD/Apple	全平台
多 GPU	张量/流水线并行	张量/流水线/专家并行	张量并行（NCCL）	不支持	部分支持（rpc）
适用规模	企业级集群	企业级集群	企业级	个人/小团队	个人/边缘设备
Star	82.9k	29k	10.9k	174k	117k

选型建议：

• vLLM 是生产环境通用首选，开箱即用、文档完善、社区活跃，适合大多数 API 服务部署场景。
• SGLang 在长 system prompt 场景下优势显著（RadixAttention 前缀缓存），适合复杂 Agent 系统或 prompt 模板较长的应用。
• TGI 由 HuggingFace 官方维护，与 HF Hub 集成最紧密，但已进入维护模式，新项目建议选择 vLLM 或 SGLang。
• Ollama 适合开发者本地快速体验模型，一条命令即可运行，不适合生产环境。
• llama.cpp 适合边缘设备、无 GPU 环境或极致量化需求，也是 Ollama 的底层引擎。

参考资源

• 官方文档: https://docs.vllm.ai
• GitHub 仓库: https://github.com/vllm-project/vllm
• PagedAttention 论文 (SOSP’23): https://arxiv.org/abs/2309.06180
• 支持模型列表: https://docs.vllm.ai/en/latest/models/supported_models/
• Blog (vLLM 博客): https://blog.vllm.ai