vLLM vs SGLang en 2026: Serví LLMs Más Rápido

1. El Problema: El Benchmark Decía 29%, Tu p99 No Se Movió

Cada pocas semanas un post nuevo dice que un motor supera al otro por 29% — los equipos migran, debuggean conflictos de kernels a la medianoche y ven que la latencia p99 quedó exactamente igual. Ambos motores se pasan uno al otro en cada release, así que un delta de leaderboard es ruido. Lo que realmente decide al ganador es la forma de tus prompts: prompts únicos no se comportan nada como loops de RAG donde cada request comparte un system prompt de 4k.

El objetivo de esta guía: entender las dos filosofías de caché, servir el mismo modelo en ambos motores con comandos verificados, pegarle a ambos con código idéntico y salir con una regla de decisión que puedas defender en una design review.

2. Conceptos Mínimos que Realmente Necesitás

Cuatro ideas explican casi todos los benchmarks que vas a leer este año. Con esto, los números de abajo se leen solos.

3. Tutorial: Un Modelo en Ambos Motores, Paso a Paso

Vamos a servir Llama 3.1 8B Instruct en vLLM (:8000) y SGLang (:30000) en el mismo host con GPU, probar ambos, llamarlos con Python idéntico, forzar JSON en ambos y correr una comparación de carga de 5 minutos. Seis pasos, solo comandos oficiales.

pip install vllm openai

vllm serve meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 --port 8000 \
  --enable-prefix-caching \
  --gpu-memory-utilization 0.9

pip install sglang openai

python3 -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 --port 30000 \
  --mem-fraction-static 0.9

curl http://localhost:8000/v1/models
curl http://localhost:30000/v1/models

from openai import OpenAI

SYSTEM = 'You are a concise release-notes writer for developer tools.'
USER = 'Summarize these changes in 3 bullets: faster KV cache, new tokenizer, fixed streaming.'

def ask(base_url):
    client = OpenAI(base_url=base_url, api_key='EMPTY')
    r = client.chat.completions.create(
        model='meta-llama/Llama-3.1-8B-Instruct',
        messages=[{'role': 'system', 'content': SYSTEM},
                  {'role': 'user', 'content': USER}],
        temperature=0, max_tokens=128,
    )
    return r.choices[0].message.content

print('vLLM:  ', ask('http://localhost:8000/v1'))
print('SGLang:', ask('http://localhost:30000/v1'))

schema = {'type': 'object', 'properties': {
    'title': {'type': 'string'}, 'bullets': {'type': 'array', 'items': {'type': 'string'}}},
    'required': ['title', 'bullets']}

# vLLM: JSON con gramática
vllm = OpenAI(base_url='http://localhost:8000/v1', api_key='EMPTY')
r1 = vllm.chat.completions.create(model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': USER}],
    extra_body={'guided_json': schema}, max_tokens=256)

# SGLang: modo JSON estilo OpenAI
sgl = OpenAI(base_url='http://localhost:30000/v1', api_key='EMPTY')
r2 = sgl.chat.completions.create(model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': USER}],
    response_format={'type': 'json_object'}, max_tokens=256)

import asyncio, time
from openai import AsyncOpenAI

PROMPTS = [USER] * 32  # reemplazá con TUS prompts de producción

async def bench(base_url, conc=16):
    client = AsyncOpenAI(base_url=base_url, api_key='EMPTY')
    sem = asyncio.Semaphore(conc)
    async def one(p):
        async with sem:
            r = await client.chat.completions.create(
                model='meta-llama/Llama-3.1-8B-Instruct',
                messages=[{'role': 'system', 'content': SYSTEM},
                          {'role': 'user', 'content': p}],
                max_tokens=128)
            return len(r.choices[0].message.content.split())
    t0 = time.time()
    toks = sum(await asyncio.gather(*[one(p) for p in PROMPTS]))
    dt = time.time() - t0
    return toks / dt

for conc in (1, 8, 32):
    v = await bench('http://localhost:8000/v1', conc)
    s = await bench('http://localhost:30000/v1', conc)
    print(f'conc={conc:3d}  vLLM={v:7.1f} tok/s  SGLang={s:7.1f} tok/s')

4. Errores Comunes que Invalidan tu Comparación

Ya revisé suficientes shootouts de motores para oler los failure modes de lejos. Evitá estos cinco y tus números van a sobrevivir al contacto con producción.

Conclusión

En H100s de 2026 el resumen honesto entra en una línea: SGLang gana el serving con prefijos compartidos en modelos chicos por hasta ~29%, empata en modelos grandes y prompts únicos, y ambos hablan APIs compatibles con OpenAI así que migrar cuesta un cambio de config más una auditoría de flags.

Corré los seis pasos de arriba con tus prompts de producción esta semana. Si la curva de concurrencia se dobla hacia SGLang, migrá los servicios con prefijos y dejá el resto en vLLM — las flotas heterogéneas son normales y ambos motores conviven detrás del mismo load balancer.

Fuentes

• Techsy — vLLM vs SGLang 2026: H100 Benchmarks (1 Sep 2026)
• ComputingForGeeks — SGLang vs vLLM: Install and Benchmark (RTX 4090, jul 2026)
• Docs vLLM — Automatic Prefix Caching (diseño por hash)
• Docs vLLM — Disaggregated Prefilling (experimental)
• Docs SGLang — OpenAI-compatible Chat Completions API
• VIPS Learn — Comparativa SGLang vs vLLM (abr 2026)