SGLang

LLM と VLM のための高性能サービング フレームワーク。自動プリフィックス キャッシング用の RadixAttention を備えています。

SGLang を使用する場合

以下の場合に SGLang を使用してください:

• 構造化された出力（JSON、正規表現、文法）が必要
• 繰り返しプリフィックス（システム プロンプト、ツール）を持つエージェントを構築している
• 関数呼び出しを伴うエージェント ワークフロー
• 共有コンテキストを持つマルチターン会話
• より高速な JSON デコード（標準比 3×）が必要

代わりに vLLM を使用する場合:

• 構造がない単純なテキスト生成
• プリフィックス キャッシングが不要
• 成熟した、広くテストされた本番システムが必要

代わりに TensorRT-LLM を使用する場合:

• 単一リクエストの最大遅延（バッチ処理不要）
• NVIDIA のみのデプロイ
• H100 での FP8/INT4 量子化が必要

クイック スタート

インストール

# pip install （推奨）
pip install "sglang[all]"

# FlashInfer を使用（より高速、CUDA 11.8/12.1）
pip install sglang[all] flashinfer -i https://flashinfer.ai/whl/cu121/torch2.4/

# ソースからインストール
git clone https://github.com/sgl-project/sglang.git
cd sglang
pip install -e "python[all]"

サーバー起動

# 基本的なサーバー（Llama 3-8B）
python -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3-8B-Instruct \
    --port 30000

# RadixAttention 付き（自動プリフィックス キャッシング）
python -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3-8B-Instruct \
    --port 30000 \
    --enable-radix-cache  # デフォルト: 有効

# マルチ GPU（テンソル並列化）
python -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3-70B-Instruct \
    --tp 4 \
    --port 30000

基本的な推論

import sglang as sgl

# バックエンドを設定
sgl.set_default_backend(sgl.OpenAI("http://localhost:30000/v1"))

# シンプルな生成
@sgl.function
def simple_gen(s, question):
    s += "Q: " + question + "\n"
    s += "A:" + sgl.gen("answer", max_tokens=100)

# 実行
state = simple_gen.run(question="What is the capital of France?")
print(state["answer"])
# 出力: "The capital of France is Paris."

構造化 JSON 出力

import sglang as sgl

@sgl.function
def extract_person(s, text):
    s += f"Extract person information from: {text}\n"
    s += "Output JSON:\n"

    # 制約付き JSON 生成
    s += sgl.gen(
        "json_output",
        max_tokens=200,
        regex=r'\{"name": "[^"]+", "age": \d+, "occupation": "[^"]+"\}'
    )

# 実行
state = extract_person.run(
    text="John Smith is a 35-year-old software engineer."
)
print(state["json_output"])
# 出力: {"name": "John Smith", "age": 35, "occupation": "software engineer"}

RadixAttention （主要な革新）

機能: リクエスト全体で共通のプリフィックスを自動的にキャッシュして再利用します。

パフォーマンス:

• 共有システム プロンプトを持つエージェント ワークロードで 5× 高速化
• 繰り返しのある例を含む少数ショット プロンプティングで 10× 高速化
• 設定不要 - 自動的に動作

動作方法:

1. すべての処理済みトークンの Radix ツリーを構築
2. 共有プリフィックスを自動的に検出
3. マッチするプリフィックスの KV キャッシュを再利用
4. 新しいトークンのみを計算

例（システム プロンプト付きエージェント）:

リクエスト 1: [SYSTEM_PROMPT] + "What's the weather?"
→ フル プロンプトを計算（1000 トークン）

リクエスト 2: [SAME_SYSTEM_PROMPT] + "Book a flight"
→ システム プロンプト KV キャッシュを再利用（998 トークン）
→ 2 つの新しいトークンのみを計算
→ 5× 高速化！

構造化生成パターン

JSON スキーマ付き

@sgl.function
def structured_extraction(s, article):
    s += f"Article: {article}\n\n"
    s += "Extract key information as JSON:\n"

    # JSON スキーマ制約
    schema = {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "author": {"type": "string"},
            "summary": {"type": "string"},
            "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]}
        },
        "required": ["title", "author", "summary", "sentiment"]
    }

    s += sgl.gen("info", max_tokens=300, json_schema=schema)

state = structured_extraction.run(article="...")
print(state["info"])
# 出力: スキーマに一致する有効な JSON

正規表現制約付き生成

@sgl.function
def extract_email(s, text):
    s += f"Extract email from: {text}\n"
    s += "Email: "

    # メール正規表現パターン
    s += sgl.gen(
        "email",
        max_tokens=50,
        regex=r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    )

state = extract_email.run(text="Contact john.doe@example.com for details")
print(state["email"])
# 出力: "john.doe@example.com"

文法ベースの生成

@sgl.function
def generate_code(s, description):
    s += f"Generate Python code for: {description}\n"
    s += "```python\n"

    # Python 用の EBNF 文法
    python_grammar = """
    ?start: function_def
    function_def: "def" NAME "(" [parameters] "):" suite
    parameters: parameter ("," parameter)*
    parameter: NAME
    suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
    """

    s += sgl.gen("code", max_tokens=200, grammar=python_grammar)
    s += "\n```"

関数呼び出しを使用したエージェント ワークフロー

import sglang as sgl

# ツールを定義
tools = [
    {
        "name": "get_weather",
        "description": "Get weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string"}
            }
        }
    },
    {
        "name": "book_flight",
        "description": "Book a flight",
        "parameters": {
            "type": "object",
            "properties": {
                "from": {"type": "string"},
                "to": {"type": "string"},
                "date": {"type": "string"}
            }
        }
    }
]

@sgl.function
def agent_workflow(s, user_query, tools):
    # システム プロンプト（RadixAttention でキャッシュ）
    s += "You are a helpful assistant with access to tools.\n"
    s += f"Available tools: {tools}\n\n"

    # ユーザー クエリ
    s += f"User: {user_query}\n"
    s += "Assistant: "

    # 関数呼び出しで生成
    s += sgl.gen(
        "response",
        max_tokens=200,
        tools=tools,  # SGLang がツール呼び出し形式を処理
        stop=["User:", "\n\n"]
    )

# 複数のクエリがシステム プロンプトを再利用
state1 = agent_workflow.run(
    user_query="What's the weather in NYC?",
    tools=tools
)
# 最初の呼び出し: フル システム プロンプトを計算

state2 = agent_workflow.run(
    user_query="Book a flight to LA",
    tools=tools
)
# 2 番目の呼び出し: システム プロンプトを再利用（5× 高速化）

パフォーマンス ベンチマーク

RadixAttention 高速化

少数ショット プロンプティング（プロンプト内 10 個の例）:

• vLLM: 2.5 秒/リクエスト
• SGLang: 0.25 秒/リクエスト（10× 高速化）
• スループット: 4× 高い

エージェント ワークフロー（1000 トークン システム プロンプト）:

• vLLM: 1.8 秒/リクエスト
• SGLang: 0.35 秒/リクエスト（5× 高速化）

JSON デコード:

• 標準: 45 tok/s
• SGLang: 135 tok/s（3× 高速化）

スループット（Llama 3-8B、A100）

ワークロード	vLLM	SGLang	高速化
シンプル生成	2500 tok/s	2800 tok/s	1.12×
少数ショット（10 例）	500 tok/s	5000 tok/s	10×
エージェント（ツール呼び出し）	800 tok/s	4000 tok/s	5×
JSON 出力	600 tok/s	2400 tok/s	4×

マルチターン会話

@sgl.function
def multi_turn_chat(s, history, new_message):
    # システム プロンプト（常にキャッシュ）
    s += "You are a helpful AI assistant.\n\n"

    # 会話履歴（成長に伴いキャッシュ）
    for msg in history:
        s += f"{msg['role']}: {msg['content']}\n"

    # 新しいユーザー メッセージ（新しい部分のみ）
    s += f"User: {new_message}\n"
    s += "Assistant: "
    s += sgl.gen("response", max_tokens=200)

# ターン 1
history = []
state = multi_turn_chat.run(history=history, new_message="Hi there!")
history.append({"role": "User", "content": "Hi there!"})
history.append({"role": "Assistant", "content": state["response"]})

# ターン 2（ターン 1 の KV キャッシュを再利用）
state = multi_turn_chat.run(history=history, new_message="What's 2+2?")
# 新しいメッセージのみを計算（大幅に高速化！）

# ターン 3（ターン 1 + ターン 2 の KV キャッシュを再利用）
state = multi_turn_chat.run(history=history, new_message="Tell me a joke")
# 履歴が増えるにつれ徐々に高速化

高度な機能

推測デコーディング

# ドラフト モデルで起動（2～3× 高速化）
python -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3-70B-Instruct \
    --speculative-model meta-llama/Meta-Llama-3-8B-Instruct \
    --speculative-num-steps 5

マルチモーダル（ビジョン モデル）

@sgl.function
def describe_image(s, image_path):
    s += sgl.image(image_path)
    s += "Describe this image in detail: "
    s += sgl.gen("description", max_tokens=200)

state = describe_image.run(image_path="photo.jpg")
print(state["description"])

バッチ処理と並列リクエスト

# 自動バッチ処理（継続的バッチ処理）
states = sgl.run_batch(
    [
        simple_gen.bind(question="What is AI?"),
        simple_gen.bind(question="What is ML?"),
        simple_gen.bind(question="What is DL?"),
    ]
)

# 3 つすべてが単一バッチで処理される（効率的）

OpenAI 互換 API

# OpenAI API でサーバーを起動
python -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3-8B-Instruct \
    --port 30000

# OpenAI クライアントで使用
curl http://localhost:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "default",
    "messages": [
      {"role": "system", "content": "You are helpful"},
      {"role": "user", "content": "Hello"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'

# OpenAI Python SDK で動作
from openai import OpenAI
client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="default",
    messages=[{"role": "user", "content": "Hello"}]
)

サポートされているモデル

テキスト モデル:

• Llama 2、Llama 3、Llama 3.1、Llama 3.2
• Mistral、Mixtral
• Qwen、Qwen2、QwQ
• DeepSeek-V2、DeepSeek-V3
• Gemma、Phi-3

ビジョン モデル:

• LLaVA、LLaVA-OneVision
• Phi-3-Vision
• Qwen2-VL

HuggingFace の 100+ モデル

ハードウェア サポート

NVIDIA: A100、H100、L4、T4（CUDA 11.8 以上） AMD: MI300、MI250（ROCm 6.0 以上） Intel: GPU 付き Xeon（近日公開） Apple: MPS 経由 M1/M2/M3（実験的）

参考資料

• 構造化生成ガイド - JSON スキーマ、正規表現、文法、検証
• RadixAttention ディープ ダイブ - 動作方法、最適化、ベンチマーク
• 本番デプロイ - マルチ GPU、監視、オートスケーリング

リソース

• GitHub: https://github.com/sgl-project/sglang
• ドキュメント: https://sgl-project.github.io/
• 論文: RadixAttention（arXiv:2312.07104）
• Discord: https://discord.gg/sglang