SGLang: control fino sobre la ejecución de LLM

SGLang (Structured Generation Language) es un framework que va más allá de “servir LLM” — propone un lenguaje de programación sobre LLMs con control fino de branching, constraints y paralelismo. Bajo el hood, un runtime optimizado (basado en vLLM fork) con RadixAttention para cache compartido entre requests. Para casos complejos como agents multi-step, structured output y prompt chains, es ventaja real.

Qué problema resuelve

Servir un LLM con vLLM o TGI es eficiente para requests independientes. SGLang aborda:

• Requests con prompt prefix compartido: cache de KV entre requests.
• Generación estructurada compleja: JSON, XML con templates explícitos.
• Branching y paralelismo dentro de una “programa” LLM.
• Tool use integrado.

DSL ejemplo

import sglang as sgl

@sgl.function
def multi_turn(s, question):
    s += sgl.user(question)
    s += sgl.assistant(sgl.gen("answer", max_tokens=256))
    s += sgl.user("Explica más.")
    s += sgl.assistant(sgl.gen("detail", max_tokens=256))

runtime = sgl.Runtime(model_path="meta-llama/Llama-3-8B-Instruct")
sgl.set_default_backend(runtime)

state = multi_turn.run(question="¿Qué es RAG?")
print(state["answer"], state["detail"])

El estado se mantiene y el runtime optimiza la ejecución.

RadixAttention

Feature diferenciadora: RadixAttention indexa KV cache en un trie, permitiendo que múltiples requests compartan prefixes.

Useful para:

• Chat sessions con system prompt largo.
• Few-shot prompts repetidos.
• Agent loops con context acumulado.

Hasta 5x speedup medido en workloads con prefix sharing significativo.

Constrained generation

@sgl.function
def extract(s, text):
    s += f"Extrae datos de: {text}"
    s += sgl.gen("name", regex=r"[A-Z][a-z]+")
    s += sgl.gen("age", regex=r"\d{1,3}")

Usa outlines-like constraints built-in, sin setup extra.

Branching paralelo

@sgl.function
def compare_options(s, topic):
    s += f"Analiza {topic}:"

    # 3 branches en paralelo
    forks = s.fork(3)
    forks[0] += "Pros: " + sgl.gen("pros")
    forks[1] += "Cons: " + sgl.gen("cons")
    forks[2] += "Costes: " + sgl.gen("costs")
    forks.join()

Ejecuta 3 generaciones en paralelo y las combina. Útil para agentes con multiple perspectivas.

SGLang vs vLLM

vLLM es mejor para servicio API genérico. SGLang es mejor cuando quieres programar sobre LLMs de forma compleja.

Casos de uso

Donde SGLang brilla:

• Agents multi-step con estado.
• Structured output complejo: JSON anidado.
• Prompt programming con branching.
• Batch procesamiento con prefixes compartidos.
• Research en LLM control.

Menos ventaja:

• API simple request/response.
• Chatbot básico.
• Cuando ya integraste vLLM y funciona.

Performance

Con workloads adecuados:

• Prefix-heavy: 3-5x más rápido que vLLM.
• Generic single requests: similar.
• Structured output: 20-40% más rápido con built-in constraints.

Instalación

pip install "sglang[all]"

Require GPU con CUDA, similar a vLLM. Ollama-style minimalismo no es su objetivo.

Server mode

SGLang también tiene un server OpenAI-compatible:

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

Compatible con OpenAI SDK estándar. Usable como drop-in sin el DSL.

Limitaciones

• Menos madurez que vLLM o TGI.
• Comunidad más pequeña.
• API cambia: releases frecuentes con breaking changes.
• Solo algunos modelos tienen soporte optimizado.

Conclusión

SGLang ocupa un nicho específico: programación avanzada sobre LLMs con optimizaciones serias. Para casos complejos con estado, branching, o prefix sharing significativo, puede ser 3-5x más eficiente que vLLM plain. Para servicio API genérico, vLLM sigue siendo el default. Vale la pena conocerlo cuando construyes agents sofisticados o structured data extraction masiva. La curva de aprendizaje del DSL es real pero paga dividendos en los casos correctos.

Síguenos en jacar.es para más sobre LLM serving, inferencia optimizada y agents.