vLLM을 넘어선 새로운 왕좌: SGLang이 LLM 인퍼런스의 판도를 바꾸는 5가지 이유

[요청 A] System Prompt(500 tokens) + User Query A(50 tokens)
[요청 B] System Prompt(500 tokens) + User Query B(80 tokens)
[요청 C] System Prompt(500 tokens) + User Query C(30 tokens)

RadixAttention KV Cache Tree 구조
=================================

                          [ROOT]
                            |
                +-----------+-----------+
                |                       |
        [System Prompt]           [Few-shot Prefix]
        "You are a helpful       "Translate the following
         AI assistant..."         examples..."
         (KV: 500 tokens)         (KV: 800 tokens)
                |                       |
        +-------+-------+        +-----+-----+
        |               |        |           |
   [User A]        [User B]  [Example 1]  [Example 2]
   "What is       "Explain   "Hello->     "Good->
    Docker?"      K8s pods"   안녕하세요"    좋은"
   (KV: 50 tok)  (KV: 80 tok) (KV: 30 tok) (KV: 25 tok)
        |               |
   [Turn 2-A]     [Turn 2-B]
   "How to       "What about
    install?"     services?"
   (KV: 40 tok)  (KV: 60 tok)
        |
   [Turn 3-A]
   "Configure
    networking"
   (KV: 45 tok)

새 요청: "You are a helpful AI assistant... What is Kubernetes?"

Radix Tree 탐색:
  [ROOT] → [System Prompt] ✅ 매칭! (500 tokens 재사용)
                 → [User A: "What is Docker?"] ❌ 불일치
                 → [User B: "Explain K8s pods"] ❌ 불일치
                 → 새 분기 생성 필요

결과: 500 tokens의 KV 캐시 재사용, 나머지 50 tokens만 새로 계산

LRU Eviction 과정:
=================
메모리 부족 발생!

1. 리프 노드 중 가장 오래 접근되지 않은 노드 선택
   → [Turn 3-A] (마지막 접근: 30분 전)

2. 해당 노드의 KV 캐시 해제 (45 tokens 회수)

3. 부모 노드 검사: [Turn 2-A]의 다른 자식이 있는가?
   → 없음: 부모도 퇴거 후보로 승격
   → 있음: 부모 유지

4. 메모리 충분? → 아니면 다음 LRU 리프 노드로 반복

에이전트 실행 흐름 (10단계 추론):
================================
[Step 1] System + Tools + Query               → 1000 tokens (새로 계산)
[Step 2] System + Tools + Query + Obs1         → 1000 재사용 + 200 새로 계산
[Step 3] System + Tools + Query + Obs1 + Obs2  → 1200 재사용 + 200 새로 계산
...
[Step 10] System + Tools + Query + Obs1~Obs9   → 2800 재사용 + 200 새로 계산

RadixAttention: 총 새 연산 = 1000 + 200*9 = 2,800 tokens
PagedAttention: 총 새 연산 = 1000 + 1200 + 1400 + ... + 2800 = 19,000 tokens

절감률: 약 85%

Cache-Aware Load Balancing:

요청: "System Prompt A + User Query X"

Instance 1: Radix Tree에 "System Prompt A" 캐시 존재 ← 여기로 라우팅!
Instance 2: Radix Tree에 "System Prompt B" 캐시 존재
Instance 3: Radix Tree에 "System Prompt A" 캐시 없음

결과: 캐시 히트율 최대화 → 1.9x 처리량 향상, 3.8x 캐시 히트율 향상

vLLM Architecture (Simplified):
================================
[Request] → [Scheduler] → [Executor Interface]
                              ↓
                    [Backend Abstraction Layer]
                              ↓
                    [Attention Backend Plugin]
                              ↓
                    [FlashInfer / FlashAttention / ...]
                              ↓
                          [GPU Kernel]

SGLang Architecture (Simplified):
=================================
[Request] → [Zero-Overhead Scheduler]
                    ↓
            [Direct FlashInfer Integration]
                    ↓
            [TMA-Optimized GPU Kernel]
                    ↓
                [GPU HBM]

기존 방식 (Sequential):
========================
Time →  [CPU: Batch N 준비] [GPU: Batch N 연산] [CPU: Batch N+1 준비] [GPU: Batch N+1 연산]
                                ↑ GPU idle                              ↑ GPU idle

SGLang Zero-Overhead (Pipelined):
==================================
Time →  [CPU: Batch N 준비] [CPU: Batch N+1 준비] [CPU: Batch N+2 준비] [CPU: Batch N+3 준비]
        [                 ] [GPU: Batch N 연산  ] [GPU: Batch N+1 연산] [GPU: Batch N+2 연산]
                             ↑ No GPU idle!        ↑ No GPU idle!       ↑ No GPU idle!

# SGLang 스케줄러의 핵심 루프 (개념적 의사 코드)
class ZeroOverheadScheduler:
    def run_event_loop(self):
        while True:
            # 1. GPU에서 이전 배치 결과 비동기 수신 (non-blocking)
            completed = self.recv_from_gpu(blocking=False)
            if completed:
                self.process_completed_tokens(completed)

            # 2. 다음 배치 구성 (CPU에서 수행)
            next_batch = self.schedule_next_batch()

            # 3. Radix Tree에서 프리픽스 매칭 (CPU에서 수행)
            self.match_prefixes(next_batch)

            # 4. GPU 메모리 할당 (CPU에서 수행)
            self.allocate_kv_cache(next_batch)

            # 5. GPU로 배치 전송 (non-blocking)
            self.send_to_gpu(next_batch)

            # GPU는 이 모든 과정 동안 이전 배치를 처리 중!

기존 Static Batching:
=====================
Batch: [Req A(100 tok), Req B(50 tok), Req C(200 tok)]

Step 1-50:   A, B, C 모두 처리
Step 51-100: A, C 처리 (B 완료, 슬롯 낭비)
Step 101-200: C만 처리 (A도 완료, 2슬롯 낭비)

SGLang Iterative Scheduling:
============================
Step 1-50:   [A, B, C] 처리
Step 51:     B 완료 → 즉시 [A, C, D] (새 요청 D 삽입)
Step 101:    A 완료 → 즉시 [C, D, E, F] (새 요청 E, F 삽입)

→ GPU 활용률 극대화!

Micro-Batching Event Loop (PP=2):
==================================
GPU Stage 0: [Fwd mb0] [Fwd mb2] [Fwd mb4] ...
GPU Stage 1:           [Fwd mb0] [Fwd mb2] [Fwd mb4] ...
P2P Comm:      [Send mb0→S1] [Send mb2→S1] ...
CPU:         [Sched mb2] [Sched mb4] [Sched mb6] ...

mb = micro-batch, S = Stage, Fwd = Forward Pass
→ 모든 자원이 동시에 활성화!

동일 GPU에서 시분할 처리:
========================
Time → [Prefill Req A] [Decode Batch 1-5] [Prefill Req B] [Decode Batch 1-8]
                          ↑                                   ↑
                   Decode 지연 시간 불규칙           새 Prefill이 기존 Decode 방해
                   (Prefill이 GPU 점유)             (TPOT 스파이크 발생)

PD Disaggregation Architecture:
================================

   ┌─────────────────────────────────────────────────────┐
   │                    Router / Gateway                  │
   │           (요청 수신 및 Prefill 서버로 분배)            │
   └──────────────────┬──────────────────────────────────┘
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
   ┌──────────────┐      ┌──────────────┐
   │  Prefill GPU  │      │  Prefill GPU  │
   │   Group #1    │      │   Group #2    │
   │  (H100 x4)   │      │  (H100 x4)   │
   │              │      │              │
   │ Compute-     │      │ Compute-     │
   │ Optimized    │      │ Optimized    │
   └──────┬───────┘      └──────┬───────┘
          │ NIXL/RDMA            │ NIXL/RDMA
          │ KV Cache Transfer    │ KV Cache Transfer
          ▼                       ▼
   ┌──────────────┐      ┌──────────────┐
   │  Decode GPU   │      │  Decode GPU   │
   │   Group #1    │      │   Group #2    │
   │  (H100 x4)   │      │  (H100 x4)   │
   │              │      │              │
   │ Bandwidth-   │      │ Bandwidth-   │
   │ Optimized    │      │ Optimized    │
   └──────────────┘      └──────────────┘

NIXL KV Cache Transfer Flow:
============================

1. Bootstrap: Decode → Prefill에 bootstrap_room ID 전달
2. Memory Alloc: Decode가 GPU 메모리 페이지 사전 할당
3. Prefill Exec: Prefill Worker가 프롬프트 처리 → KV Cache 생성
4. RDMA Write: Prefill이 RDMA를 통해 Decode GPU 메모리에 직접 쓰기
                (CPU 우회, Zero-Copy)
5. Completion: Decode가 전송 완료 폴링 → 즉시 Decode 시작

NVLink 전송 대역폭: ~900 GB/s (GB200 NVL72)
InfiniBand 전송 대역폭: ~400 Gb/s (HDR)

트래픽 패턴에 따른 스케일링:

[시나리오 1: 긴 프롬프트, 짧은 응답 (문서 요약)]
→ Prefill GPU: 8대  /  Decode GPU: 2대

[시나리오 2: 짧은 프롬프트, 긴 응답 (코드 생성)]
→ Prefill GPU: 2대  /  Decode GPU: 8대

[시나리오 3: 균등 부하 (일반 챗봇)]
→ Prefill GPU: 4대  /  Decode GPU: 4대

JSON Schema 예시:
{
  "name": string,
  "age": integer,
  "city": string
}

일반 FSM (토큰별 전이):
========================
S0 →'{' → S1 →'"' → S2 →'n' → S3 →'a' → S4 →'m' → S5 →'e' → S6 →'"' → S7 →':' → S8

각 전이마다 GPU forward pass 필요 → 8번의 forward pass

Compressed FSM (점프 포워드):
=============================
S0 → '{"name":' → S8  (Singular transitions 압축!)

감지: S0에서 S8까지 각 상태에서 가능한 전이가 딱 하나뿐
→ 1번의 forward pass로 8 토큰 생성!

Jump-Forward Decoding 과정:
===========================

1. FSM 사전 분석:
   - 각 상태에서 가능한 전이 수 계산
   - Singular path 구간 식별 및 압축

2. 디코딩 실행:
   State S0: 가능한 전이 = {'{'} (singular!)
   → Jump: '{"name":"' 직접 삽입 (forward pass 불필요)

   State S8: 가능한 전이 = {any string token} (multiple)
   → Normal decode: GPU forward pass 수행 → "Alice"

   State S9: 가능한 전이 = {'","age":'} (singular!)
   → Jump: '","age":' 직접 삽입

   State S10: 가능한 전이 = {0-9 tokens} (multiple)
   → Normal decode: GPU forward pass 수행 → "30"

   State S11: 가능한 전이 = {'","city":"'} (singular!)
   → Jump: '","city":"' 직접 삽입

   ...계속

import openai

client = openai.Client(base_url="http://127.0.0.1:30000/v1", api_key="EMPTY")

# JSON Schema를 통한 구조화된 출력
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Generate a user profile for Alice who is 30 years old."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "user_profile",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "city": {"type": "string"},
                    "hobbies": {
                        "type": "array",
                        "items": {"type": "string"}
                    }
                },
                "required": ["name", "age", "city", "hobbies"]
            }
        }
    },
    max_tokens=256
)

print(response.choices[0].message.content)
# 출력: {"name": "Alice", "age": 30, "city": "San Francisco", "hobbies": ["reading", "hiking", "coding"]}

# Regex 기반 구조화된 생성
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Generate a valid email address for John."}
    ],
    extra_body={"regex": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"},
    max_tokens=64
)

# Python 3.9+ 필요, CUDA 12.x 권장
pip install --upgrade pip
pip install "sglang[all]"

# 또는 uv를 사용한 빠른 설치
pip install uv
uv pip install "sglang[all]"

git clone https://github.com/sgl-project/sglang.git
cd sglang
pip install -e "python[all]"

# 공식 Docker 이미지 사용
docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=${HF_TOKEN}" \
  --ipc=host \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000

# docker-compose.yml
version: '3.8'
services:
  sglang:
    image: lmsysorg/sglang:latest
    ports:
      - '30000:30000'
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HF_TOKEN=${HF_TOKEN}
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    ipc: host
    shm_size: '32g'
    command: >
      python3 -m sglang.launch_server
      --model-path meta-llama/Llama-3.1-8B-Instruct
      --host 0.0.0.0
      --port 30000

docker compose up -d

# 기본 서버 실행 (단일 GPU)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000

# 또는 sglang serve 명령어 사용
sglang serve meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000

# 서버 헬스 체크
curl http://localhost:30000/health

# 모델 정보 확인
curl http://localhost:30000/v1/models

# 서버 메트릭 확인
curl http://localhost:30000/get_server_info

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer EMPTY" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "You are a helpful AI assistant."},
      {"role": "user", "content": "Kubernetes의 Pod과 Deployment의 차이를 설명해주세요."}
    ],
    "max_tokens": 512,
    "temperature": 0.7,
    "top_p": 0.9
  }'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY"  # SGLang은 기본적으로 인증 불필요
)

# 일반 Chat Completion
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "당신은 클라우드 네이티브 전문가입니다."},
        {"role": "user", "content": "Helm chart와 Kustomize의 장단점을 비교해주세요."}
    ],
    max_tokens=1024,
    temperature=0.7
)

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

# Streaming 응답
stream = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Python으로 간단한 웹 서버를 작성해주세요."}
    ],
    max_tokens=1024,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

curl http://127.0.0.1:30000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "prompt": "The capital of France is",
    "max_tokens": 32,
    "temperature": 0
  }'

import requests
import json

# 네이티브 SGLang 배치 엔드포인트
batch_requests = [
    {
        "text": "Translate to Korean: Hello, how are you?",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    },
    {
        "text": "Translate to Korean: The weather is nice today.",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    },
    {
        "text": "Translate to Korean: I love programming.",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    }
]

# 비동기 요청으로 처리량 극대화
import asyncio
import aiohttp

async def send_requests(requests_data):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for req in requests_data:
            task = session.post(
                "http://localhost:30000/generate",
                json=req
            )
            tasks.append(task)
        responses = await asyncio.gather(*tasks)
        results = [await r.json() for r in responses]
        return results

results = asyncio.run(send_requests(batch_requests))
for r in results:
    print(r["text"])

import sglang as sgl

# SGLang 프론트엔드 함수 정의
@sgl.function
def multi_turn_qa(s, question1, question2):
    s += sgl.system("You are a helpful AI assistant specialized in cloud computing.")
    s += sgl.user(question1)
    s += sgl.assistant(sgl.gen("answer1", max_tokens=256))
    s += sgl.user(question2)
    s += sgl.assistant(sgl.gen("answer2", max_tokens=256))

# 런타임 엔드포인트 설정
sgl.set_default_backend(sgl.RuntimeEndpoint("http://localhost:30000"))

# 실행
state = multi_turn_qa.run(
    question1="Kubernetes에서 HPA는 어떻게 동작하나요?",
    question2="VPA와의 차이점은 무엇인가요?"
)

print("Answer 1:", state["answer1"])
print("Answer 2:", state["answer2"])

@sgl.function
def parallel_analysis(s, topic):
    s += sgl.system("You are a technology analyst.")
    s += sgl.user(f"Analyze '{topic}' from three perspectives.")

    # Fork: 3개의 분석을 병렬로 생성
    forks = s.fork(3)

    forks[0] += sgl.user("Technical perspective:")
    forks[0] += sgl.assistant(sgl.gen("technical", max_tokens=200))

    forks[1] += sgl.user("Business perspective:")
    forks[1] += sgl.assistant(sgl.gen("business", max_tokens=200))

    forks[2] += sgl.user("User experience perspective:")
    forks[2] += sgl.assistant(sgl.gen("ux", max_tokens=200))

    # Join: 모든 결과 수집
    forks.join()

    # 종합
    s += sgl.user("Summarize the three analyses above:")
    s += sgl.assistant(sgl.gen("summary", max_tokens=300))

state = parallel_analysis.run(topic="SGLang inference engine")
print("Technical:", state["technical"])
print("Business:", state["business"])
print("UX:", state["ux"])
print("Summary:", state["summary"])

@sgl.function
def classify_sentiment(s, text):
    s += sgl.user(f"Classify the sentiment of the following text: '{text}'")
    s += sgl.assistant(
        "The sentiment is " + sgl.select("label", ["positive", "negative", "neutral"])
    )

state = classify_sentiment.run(text="SGLang is amazingly fast!")
print("Sentiment:", state["label"])  # "positive"

python -m sglang.launch_server \
  --model-path <model_name_or_path>    # HuggingFace 모델 이름 또는 로컬 경로
  --host 0.0.0.0                        # 바인딩 호스트
  --port 30000                          # 서비스 포트
  --tp-size 4                           # Tensor Parallelism 크기
  --dp-size 2                           # Data Parallelism 크기
  --pp-size 2                           # Pipeline Parallelism 크기
  --mem-fraction-static 0.88            # GPU 메모리 중 KV Cache 비율 (기본: 0.88)
  --max-running-requests 128            # 동시 처리 최대 요청 수
  --max-total-tokens 131072             # 최대 총 토큰 수
  --context-length 32768                # 컨텍스트 길이
  --chunked-prefill-size 8192           # Chunked Prefill 청크 크기
  --schedule-policy lpm                 # 스케줄링 정책 (lpm / fcfs / random)
  --quantization fp8                    # 양자화 방법 (fp8 / int4 / awq / gptq)
  --dtype auto                          # 데이터 타입 (auto / float16 / bfloat16)
  --trust-remote-code                   # 원격 코드 신뢰 허용
  --chat-template auto                  # 채팅 템플릿 (auto 또는 커스텀 경로)
  --log-level info                      # 로그 레벨
  --enable-metrics                      # Prometheus 메트릭 활성화
  --api-key "your-secret-key"           # API 키 인증 활성화

# GPU 메모리의 88%를 KV Cache에 할당 (기본값)
--mem-fraction-static 0.88

# 대규모 모델에서 메모리 부족 시 줄임
--mem-fraction-static 0.80

# KV Cache 최대 토큰 수 명시적 설정
--max-total-tokens 65536

# LPM (Longest Prefix Match): RadixAttention 캐시 히트율 극대화 (기본값)
--schedule-policy lpm

# FCFS (First Come First Served): 단순 선입선출
--schedule-policy fcfs

# Random: 무작위 선택
--schedule-policy random

# FP8 양자화 (Hopper+ GPU 필요)
--quantization fp8

# NVFP4 양자화 (Blackwell GPU 필요)
--quantization fp4

# INT4 AWQ 양자화
--quantization awq

# INT4 GPTQ 양자화
--quantization gptq

# CUDA 디바이스 선택
export CUDA_VISIBLE_DEVICES=0,1,2,3

# HuggingFace 토큰 (게이트 모델 접근)
export HF_TOKEN="hf_your_token_here"

# NCCL 설정 (멀티 GPU)
export NCCL_P2P_DISABLE=0
export NCCL_IB_DISABLE=0

# SGLang 로그 레벨
export SGLANG_LOG_LEVEL=info

# FlashInfer 워크스페이스 크기
export SGLANG_FLASHINFER_WORKSPACE_SIZE=2147483648  # 2GB

# Llama-3.1-8B를 단일 GPU에 배포
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000 \
  --mem-fraction-static 0.88

# 양자화를 적용하여 더 큰 모델을 단일 GPU에 배포
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000

# 4-GPU Tensor Parallelism (70B 모델)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --host 0.0.0.0 \
  --port 30000

# 2-GPU TP + 2-GPU DP = 4 GPU (8B 모델, 처리량 극대화)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --tp-size 2 \
  --dp-size 2 \
  --host 0.0.0.0 \
  --port 30000

# Node 0 (Master)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-405B-Instruct \
  --tp-size 16 \
  --nnodes 2 \
  --node-rank 0 \
  --dist-init-addr node0-ip:5000 \
  --host 0.0.0.0 \
  --port 30000

# Node 1 (Worker)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-405B-Instruct \
  --tp-size 16 \
  --nnodes 2 \
  --node-rank 1 \
  --dist-init-addr node0-ip:5000

# Prefill 서버 실행
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --disaggregation-mode prefill \
  --disaggregation-transfer-backend nixl \
  --host 0.0.0.0 \
  --port 30001

# Decode 서버 실행
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --disaggregation-mode decode \
  --disaggregation-transfer-backend nixl \
  --host 0.0.0.0 \
  --port 30002

# sglang-skypilot.yaml
resources:
  cloud: aws # 또는 gcp, azure
  accelerators: A100:4
  memory: 128+

envs:
  HF_TOKEN: <your-hf-token>
  MODEL_NAME: meta-llama/Llama-3.1-70B-Instruct

setup: |
  pip install "sglang[all]"

run: |
  python -m sglang.launch_server \
    --model-path ${MODEL_NAME} \
    --tp-size 4 \
    --host 0.0.0.0 \
    --port 30000

# SkyPilot으로 클러스터 생성 및 배포
pip install skypilot-nightly
sky launch -c sglang-cluster --env HF_TOKEN sglang-skypilot.yaml

# Base 모델 + 여러 LoRA 어댑터 동시 서빙
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --lora-paths \
    korean-chat=/path/to/korean-lora \
    code-gen=/path/to/code-lora \
    medical=/path/to/medical-lora \
  --max-loras-per-batch 4 \
  --host 0.0.0.0 \
  --port 30000

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "korean-chat",
    "messages": [{"role": "user", "content": "안녕하세요!"}],
    "max_tokens": 128
  }'

인퍼런스 비용 = GPU 시간당 비용 / 처리량 (tok/s)

H100 기준:
  vLLM:  $3.50/hr / 12,553 tok/s = $0.000279 / 1K tokens
  SGLang: $3.50/hr / 16,215 tok/s = $0.000216 / 1K tokens

→ SGLang은 동일 GPU에서 22.6% 비용 절감
→ 에이전트 시나리오 (캐시 히트율 포함): 최대 60-80% 비용 절감