SGLang — 高性能 LLM 推理与结构化生成框架

GitHub: sgl-project/sglang
Stars: 29,000+ | Language: Python (74.7%) | License: Apache-2.0
官网: sglang.ai

项目速览

SGLang 是由 LMSYS Org（Large Model Systems Organization，知名项目 Vicuna 和 Chatbot Arena 的发起组织）开发的高性能 LLM 服务框架。它提供两个维度的核心能力：后端（SGLang Runtime / SRT）是一个高效推理引擎，实现 RadixAttention 前缀缓存和零开销调度；前端（SGLang DSL）是一个嵌入式领域特定语言，允许程序员用 Python 代码直观地表达复杂的 LLM 调用工作流，包括并行生成、条件分支、结构化输出等。

截至 2026 年 6 月，项目在 GitHub 上已获得 29,000+ Star。SGLang 在业界已获得广泛采用：据官方数据，全球超过 400,000 张 GPU 运行着 SGLang，每天生成数万亿 token。采用方包括 xAI、AMD、NVIDIA、LinkedIn、Cursor、Oracle Cloud、Google Cloud、Microsoft Azure、AWS 和众多顶尖高校。

SGLang 的旗舰创新是 RadixAttention，在长 prefix 场景（如多轮对话共享 system prompt）下，相比 vLLM 可提供最高 5 倍推理加速。同时，其压缩有限状态机（compressed FSM）技术使 JSON 约束解码速度提升 3 倍。

功能概述

RadixAttention — 基数树前缀缓存

RadixAttention 是 SGLang 对 PagedAttention 的关键扩展。两者的根本区别在于 KV Cache 的组织方式：

PagedAttention 将 KV Cache 切分为固定大小的 block，解决内存碎片化
RadixAttention 在 PagedAttention 之上用 Radix Tree（基数树/前缀树） 组织所有请求的 KV Cache，自动识别和复用跨请求的公共前缀

实际效果：当 1000 个并发用户共享同一个 4096 token 的 system prompt 时，RadixAttention 只需计算一次 system prompt 的 KV Cache，后续请求直接复用，节省了相当于 999 * 4096 个 token 的重复 prefill 计算。这大幅降低了 Time to First Token（TTFT）延迟和 GPU 计算开销。

SGLang DSL — 结构化生成编程语言

SGLang 最独特的特性是其嵌入式 DSL。它不是 YAML 配置也不是 JSON 模板，而是纯正的 Python 代码，通过装饰器 @sgl.function 定义生成程序：

import sglang as sgl

@sgl.function
def multi_turn_agent(s, user_query):
    s += sgl.system("You are a helpful, creative assistant.")
    s += sgl.user(user_query)
    s += sgl.assistant(sgl.gen("answer", max_tokens=256))

DSL 支持的核心原语包括：

**sgl.gen()**：模型的生成操作，可以指定参数如 max_tokens、temperature、stop，以及结构化约束 regex 或 choices
**sgl.select()**：从选项中选择最优的，用于分类/路由
**sgl.fork() / sgl.join()**：并行触发多个生成分支，然后合并结果（如多方案并行评估）
**sgl.image()**：插入图像 token（多模态模型）
**sgl.assistant() / sgl.user() / sgl.system()**：角色标记

最重要的是，由于它是 Python 代码，你可以使用条件、循环、函数调用等所有 Python 语言特性来控制生成流程——这在 YAML/JSON 配置中几乎不可能优雅地实现。

Runtime API — OpenAI 兼容后端

SGLang Runtime（SRT）可以作为一个独立的高性能 OpenAI 兼容 API 服务器运行：

python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --port 30000

启动后，所有支持 /v1/chat/completions 和 /v1/completions 端点的客户端都可以直连，无需修改代码。SRT 在后端集成了 RadixAttention、continuous batching、chunked prefill、speculative decoding 等全部推理优化。

多维并行策略

SGLang 支持全面的分布式推理策略：

张量并行（Tensor Parallelism）：将单个 Transformer 层的权重和计算分布到多个 GPU
流水线并行（Pipeline Parallelism）：将模型的不同层分配给不同 GPU，形成流水线
专家并行（Expert Parallelism）：MoE 模型中不同 expert 分布到不同 GPU
数据并行（Data Parallelism）：多副本同时服务不同请求
Prefill-Decode 分离：将 prefill（计算密集）和 decode（访存密集）阶段分配到不同的 GPU 组

通过这些策略，SGLang 可以灵活适配从单 GPU 到数百 GPU 集群的部署规模。

结构化输出与约束生成

SGLang 在结构化输出方面有深厚积累，提供了多层级的约束机制：

JSON 模式：response_format={"type": "json_object"}（OpenAI 兼容）
JSON Schema：通过 json_schema 参数指定严格的结构定义
Regex 约束：通过 regex 参数用正则表达式约束生成内容
Choice 约束：通过 choices 参数限制输出为预定义选项列表
压缩 FSM：对经典 JSON 约束，使用预计算的压缩有限状态机，解码速度提升 3 倍

这些约束不是后处理过滤（那种做法浪费 token），而是在 token 采样阶段直接限制 logits——约束之外的 token 概率被置为负无穷，保证输出 100% 符合格式。

广泛模型和硬件支持

SGLang 支持 200+ 模型架构，包括 Llama、Qwen、DeepSeek、Kimi、GLM、GPT、Gemma、Mistral 等主流 LLM，以及多模态（视觉语言）、Embedding、Reward 模型和扩散模型（WAN、Qwen-Image）。

硬件方面支持 NVIDIA GPU（从消费级 RTX 到数据中心 H100/B200/GB200）、AMD GPU（MI355/MI300）、Intel Xeon CPU、Google TPU 和华为昇腾 NPU。

适用场景

Agent 系统推理后端

SGLang 的 RadixAttention 在长 system prompt（Agent 指令往往有数千 token）场景下优势显著。当数百个 Agent 实例共享同一 system prompt 时，RadixAttention 几乎消除了重复的 prefill 开销，使 Agent 响应更快、成本更低。

JSON 结构化生成

任何需要从 LLM 获取结构化数据的场景（信息抽取、API 参数生成、数据标注、分类路由），SGLang 的压缩 FSM 和 regex/choice 约束都能提供更快、更可靠的 JSON 输出。配合 DSL 的编程灵活性，可以构建复杂的分步抽取管线。

评估与 Benchmark 管线

SGLang 的 DSL 非常适合构建评估管道：使用 sgl.fork() 并行生成多个候选答案，然后用另一个 LLM 调用对候选进行评分，最后 sgl.select() 选出最优。这种 vote-and-select 模式在 LLM-as-Judge 评测中非常常见。

多方案并行生成

对于文案创作、创意生成等场景，DSL 的 fork/join 机制可以并行生成多个版本，然后通过评分或人工选择选出最佳。整个过程在单个程序中表达，无需复杂的编排代码。

高并发 API 服务

SGLang 作为 OpenAI 兼容的推理服务器，完全可以替代 vLLM 作为 API 后端。在长系统提示词的多轮对话场景下，SGLang 的吞吐量显著优于 vLLM。

快速上手

环境要求

Python 3.9+
NVIDIA GPU（Compute Capability 7.0+）推荐
CUDA 12.1+

安装

pip install "sglang[all]"

# 或从源码安装（开发场景）
git clone https://github.com/sgl-project/sglang.git
cd sglang
pip install -e "python[all]"

启动推理服务器

# 基础启动
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --port 30000

# 多 GPU 张量并行
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-70B-Instruct \
    --port 30000 \
    --tp 4

# 启用量化
python -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-7B-Instruct-AWQ \
    --port 30000 \
    --quantization awq

客户端调用

from openai import OpenAI

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

# Chat Completions
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "用三句话介绍SGLang"}
    ],
    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)

SGLang DSL 最简示例

import sglang as sgl

@sgl.function
def sentiment_classify(s, text):
    s += sgl.system("你是一个情感分析专家。")
    s += sgl.user(f"分析以下文本的情感: {text}")
    s += sgl.assistant(
        sgl.gen("sentiment", choices=["正面", "负面", "中性"])
    )

state = sentiment_classify.run(text="这个产品非常好用，我很喜欢！")
print(state["sentiment"])  # 输出: 正面

源码架构

SGLang 的代码主要分为 Runtime（后端）和 DSL（前端）两大部分：

sglang/
├── python/
│   └── sglang/
│       ├── srt/                       # SGLang Runtime — 后端推理引擎
│       │   ├── server.py              # API 服务器入口
│       │   ├── managers/              # 管理器层
│       │   │   ├── scheduler.py       # 请求调度器（continuous batching + prefix caching）
│       │   │   ├── tokenizer_manager.py  # 分词器管理
│       │   │   └── io_struct.py       # 输入输出数据结构
│       │   ├── model_executor/        # 模型执行器
│       │   │   ├── model_runner.py    # 模型加载与前向传播
│       │   │   └── layers/            # 模型层实现
│       │   ├── mem_cache/             # RadixAttention 内存缓存
│       │   │   ├── radix_cache.py     # 基数树缓存核心实现
│       │   │   └── memory_pool.py     # 内存池（PagedAttention block 管理）
│       │   ├── sampling/              # 采样策略
│       │   │   └── sampling_batch.py  # 批量采样 + 约束解码（FSM/regex/choices）
│       │   └── utils/                 # 工具函数
│       ├── lang/                      # SGLang DSL — 前端编程语言
│       │   ├── ir.py                  # 中间表示（IR）：将 DSL 编译为计算图
│       │   ├── interpreter.py         # 解释器：执行 IR 计算图
│       │   ├── api.py                 # DSL 原语 API（gen/select/fork/join）
│       │   └── tracer.py             # 函数追踪器（@sgl.function 装饰器）
│       └── __init__.py
├── sgl-kernel/                        # 自定义 CUDA 内核（Rust + CUDA）
├── sgl-model-gateway/                 # 模型网关（多模型路由）
├── benchmark/                         # 性能基准测试
├── examples/                          # 使用示例
├── docs/                              # 文档
├── docs_new/                          # 新版文档
├── test/                              # 测试
└── scripts/                           # 辅助脚本

核心模块说明：

srt/managers/scheduler.py：实现 continuous batching 调度，在每个 forward step 决策哪些请求参与计算。与 vLLM 的 Scheduler 不同之处在于，SGLang 的调度器集成了 RadixAttention 的 prefix matching 逻辑。
mem_cache/radix_cache.py：RadixAttention 的核心实现。用一个基数树（Radix Tree）管理所有活跃请求的 KV Cache block，每个节点代表一个 token 前缀。当新请求到达时，在树中查找最长匹配前缀，直接复用其 KV Cache，避免重复 prefill。
mem_cache/memory_pool.py：管理 PagedAttention 的物理 block 分配和回收。与 radix_cache 协同工作——radix_cache 确定哪些 block 可以共享，memory_pool 负责实际的物理内存分配。
sampling/sampling_batch.py：实现批量采样，包括标准 top-k/top-p 采样、以及压缩 FSM 约束采样。约束采样时，在每个 token 生成步骤构造允许的 token 集合，将禁止的 token 概率置零后重新归一化。
lang/api.py：DSL 原语定义。sgl.gen()、sgl.select()、sgl.fork() 等函数解析用户的调用，生成对应的 IR 节点。关键设计是这些原语返回”占位符”对象，允许在后续代码中引用生成结果。
lang/interpreter.py：执行 IR 计算图。管理多轮对话的状态（SGLang state），按拓扑顺序执行 IR 节点，处理 fork 分支的并行调度和 join 同步。与后端 Runtime 通信发送生成请求。

实操 Demo

完整示例：SGLang DSL 多步推理 Agent

1. 安装并启动 Runtime 服务

pip install "sglang[all]"

# 终端1：启动推理服务器（使用 Qwen2.5-7B）
python -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-7B-Instruct \
    --port 30000 \
    --mem-fraction-static 0.85

2. DSL 函数定义：多步智能分类与信息抽取

import sglang as sgl
import json

# 配置后端连接
sgl.set_default_backend(sgl.RuntimeEndpoint("http://localhost:30000"))

# 定义多步推理 agent
@sgl.function
def classify_and_extract(s, text):
    """第一步：判断用户意图类别"""
    s += sgl.system("你是一个智能助手。请严格按指令给出结果。")
    s += sgl.user(text)
    s += sgl.assistant(
        "类别: " + sgl.gen("category", choices=[
            "技术支持", "商务咨询", "投诉反馈", "闲聊"
        ])
    )
    # 第二步：根据类别做不同处理
    category = s["category"]
    if category == "技术支持":
        s += sgl.user("请提取技术问题、相关产品和紧急程度")
        s += sgl.assistant(sgl.gen(
            "info",
            regex=r'\{.*\}',  # 约束为 JSON 格式
            max_tokens=256
        ))
    elif category == "投诉反馈":
        s += sgl.user("请提取投诉要点和建议处理方案")
        s += sgl.assistant(sgl.gen("info", max_tokens=256))
    else:
        s += sgl.user("请给出简洁回复")
        s += sgl.assistant(sgl.gen("info", max_tokens=128))

# 运行示例
test_cases = [
    "我的订单号12345的包裹已经延迟3天了，请帮我查一下物流状态",
    "我非常不满意你们的服务！客服态度极差，等了半小时没人理！",
    "你好呀，今天天气真好",
]

for text in test_cases:
    state = classify_and_extract.run(text=text)
    print(f"\n输入: {text[:40]}...")
    print(f"类别: {state['category']}")
    print(f"结果: {state['info'][:100]}")

3. 并行 Fork/Join：多方案生成与投票

import sglang as sgl

sgl.set_default_backend(sgl.RuntimeEndpoint("http://localhost:30000"))

@sgl.function
def multi_draft_vote(s, brief):
    """为同一需求并行生成 3 个方案，然后选出最佳"""
    s += sgl.system("你是一个产品经理。请为给定需求设计方案。")
    s += sgl.user(brief)

    # Fork: 并行生成 3 个方案
    s += sgl.assistant("方案生成中...")
    forks = s.fork(3)
    for i, fork in enumerate(forks):
        fork += sgl.assistant(
            f"方案 {i+1}: " + sgl.gen(f"draft_{i}", max_tokens=200, temperature=0.9)
        )
    drafts = [fork[f"draft_{i}"] for i, fork in enumerate(forks)]
    s = forks[0]  # 合并后的状态

    # 第二步：对比评分
    s += sgl.user(
        "请从以下3个方案中选择最佳方案，给出理由：\n"
        + "\n".join([f"方案{i+1}: {d}" for i, d in enumerate(drafts)])
    )
    s += sgl.assistant(
        sgl.gen("verdict", max_tokens=256)
    )

    # 将结果存入状态
    for i, d in enumerate(drafts):
        s[f"draft_{i}"] = d

state = multi_draft_vote.run(
    brief="设计一个帮助用户管理每日饮水量的手机 App",
    temperature=0.8,
)
print("=== 方案1 ===")
print(state["draft_0"][:200])
print("\n=== 方案2 ===")
print(state["draft_1"][:200])
print("\n=== 方案3 ===")
print(state["draft_2"][:200])
print("\n=== 评审结果 ===")
print(state["verdict"])

4. 结构化 JSON 抽取

import sglang as sgl
import json

sgl.set_default_backend(sgl.RuntimeEndpoint("http://localhost:30000"))

@sgl.function
def extract_person_info(s, text):
    s += sgl.system("请从文本中提取个人信息，以JSON格式返回。")
    s += sgl.user(text)
    s += sgl.assistant(sgl.gen(
        "person",
        max_tokens=256,
        temperature=0.1,
    ))

# 使用后院（backend）的 JSON schema 约束
@sgl.function
def extract_with_schema(s, text):
    s += sgl.system("请从文本中提取个人信息。")
    s += sgl.user(text)
    s += sgl.assistant(
        sgl.gen(
            "person",
            max_tokens=256,
            temperature=0.0,
            # 使用 regex 约束确保返回合法 JSON
            regex=r'\{\s*"name":\s*"[^"]+",\s*"age":\s*\d+,\s*"city":\s*"[^"]+"\s*\}',
        )
    )

text = "我叫张三，今年28岁，来自北京。现在在字节跳动做软件工程师。"

state = extract_with_schema.run(text=text)
info = json.loads(state["person"])
print(f"姓名: {info['name']}")
print(f"年龄: {info['age']}")
print(f"城市: {info['city']}")

5. 通过 Runtime API 调用（OpenAI 兼容）

from openai import OpenAI

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

# 带 Structured Output 的调用
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "你是一个数据分析助手，始终以JSON格式回答。"},
        {"role": "user", "content": "列出3种常见的数据结构及其时间复杂度和应用场景"},
    ],
    response_format={"type": "json_object"},
    temperature=0.3,
    max_tokens=512,
)

import json
result = json.loads(response.choices[0].message.content)
print(json.dumps(result, ensure_ascii=False, indent=2))

# 并发性能测试
import concurrent.futures
import time

SYSTEM_PROMPT = "你是一个精通算法和数据结构的面试辅导专家。" * 20  # 模拟长 system prompt

def call_api(i):
    return client.chat.completions.create(
        model="Qwen/Qwen2.5-7B-Instruct",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"解释{['快速排序', '动态规划', 'BFS', '贪心算法'][i%4]}"}
        ],
        max_tokens=128,
    )

# RadixAttention 优势：所有请求共享长 system prompt
start = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
    results = list(executor.map(call_api, range(16)))
elapsed = time.time() - start
print(f"\n16请求/8并发: {elapsed:.2f}秒（得益于 RadixAttention 前缀共享）")

特性	SGLang	vLLM	Guidance	Outlines
KV Cache 优化	RadixAttention（前缀树）	PagedAttention（分页）	无独立实现	无独立实现
吞吐量	极高（长 prefix 场景 > vLLM）	极高（通用场景优）	N/A（非服务框架）	N/A（非服务框架）
DSL	Python 原生（条件/循环/fork）	无	Handlebars 模板	函数调用风格
结构化生成	FSM + regex + choices + JSON schema	xgrammar/guidance 集成	核心能力（语法约束）	核心能力（FSM 约束）
并行生成	fork/join 原生支持	不支持 DSL 层面	支持（gen parallel）	不支持
部署	pip install + launch_server	pip install + vllm serve	pip install（库）	pip install（库）
API 兼容	OpenAI 兼容	OpenAI 兼容 + Anthropic	非服务器	非服务器
多 GPU	TP/PP/EP/DP/分离	TP/PP	不支持	不支持
模型支持	200+	200+	依赖后端	依赖后端
Star	29k	82.9k	19k	10k+

参考资源

官方网站: https://sglang.ai
GitHub 仓库: https://github.com/sgl-project/sglang
文档: https://docs.sglang.io
RadixAttention 论文: https://arxiv.org/abs/2312.07104
LMSYS Org: https://lmsys.org

目录