SGLang-Start: Installera, konfigurera och servera LLM via OpenAI API

Servera öppna modeller snabbt med SGLang.

Sidinnehåll

SGLang är ett högpresterande ramverk för servering av stora språkmodeller och multimodala modeller, byggt för att leverera inferens med låg latens och hög genomströmning över allt från en enda GPU till distribuerade kluster.

För en bredare jämförelse av alternativ för självhöstade och molnbaserade LLM-placeringar – inklusive Ollama, vLLM, llama-swap, LocalAI och hanterade molnleverantörer – se Guiden för LLM-hospitering 2026.

Om du redan har apparater anslutna till OpenAI:s API-gränssnitt är SGLang särskilt attraktivt eftersom det kan exponera OpenAI-kompatibla slutpunkter för chattkompletteringar och kompletteringar, vilket underlättar migration från hanterade API:er till självhöstade modeller med minimala ändringar på klientsidan. När du behöver dirigera förfrågningar över flera bakändar (llama.cpp, vLLM, SGLang etc.) med het-växling och TTL-baserad urladdning, erbjuder llama-swap en transparent proxylager som håller en enda /v1-URL stabil medan det byter uppströmsserver efter behov.

sglang infographic

Denna snabbstart guidar genom installation (flera metoder), praktiska konfigurationsmönster och en ren arbetsflödesmodell “installera → servera → verifiera → integrera → optimera”, med fungerande exempel för både HTTP-servering och avskiljd batchinferens.

Om du behöver multimodal stöd (text, inbäddningar, bilder, ljud) med en inbyggd webbgränssnitt och maximal drop-in-kompatibilitet med OpenAI API, erbjuder LocalAI ett bredare funktionsuppsättning med stöd för fler modellformat.

Vad är SGLang för högpresterande servering av LLM och multimodala modeller

I grunden är SGLang designat för effektiv inferens och skalbar servering. Stacken för “snabb körning” inkluderar RadixAttention för prefixcaching, en CPU-schedulera utan overhead, speculativ dekodering, kontinuerlig batching, paginerad uppmärksamhet, flera parallelliseringsstrategier (tensor, pipeline, expert, dataparallellism), strukturerade utdata, chunkad prefill och flera kvantiseringsalternativ (till exempel FP4, FP8, INT4, AWQ, GPTQ).

Det riktar sig mot bred plattformsspridning: NVIDIA GPU:er, AMD GPU:er, Intel Xeon CPU:er, Google TPUs, Ascend NPUs och mer.

PyPI kräver Python >= 3.10. Per 20 mars 2026 inkluderade publicerade versionen 0.5.9 (släppt 23 februari 2026) – lås eller kontrollera aktuella versioner vid installation.

Hur man installerar SGLang på Linux GPU-värdar med uv pip, källkodsbyggnader eller Docker

Installationsalternativ inkluderar uv eller pip, källkodsbyggnader, Docker-bilder, Kubernetes-manifest, Docker Compose, SkyPilot och AWS SageMaker. De flesta genomgångar antar vanliga NVIDIA GPU-uppsättningar; andra acceleratorer har sina egna installationsanteckningar på andra ställen.

Installera SGLang snabbt med uv eller pip på Python 3.10+

För en rak lokal installation är uv oftast den snabbaste vägen:

pip install --upgrade pip
pip install uv
uv pip install sglang

Noteringar för CUDA 13

För CUDA 13 undviker Docker felaktiga parningar mellan PyTorch/CUDA på värdmaskinen. Utan Docker: installera en PyTorch-byggd version för CUDA 13, sedan sglang, och sedan den matchande sglang-kernel-hjulet från de publicerade hjulsläppen (versionen måste matcha stacken).

# 1) Installera PyTorch med CUDA 13-stöd (ersätt X.Y.Z vid behov)
uv pip install torch==X.Y.Z torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130

# 2) Installera SGLang
uv pip install sglang

# 3) Installera det matchande CUDA 13 sglang-kernel-hjulet (ersätt X.Y.Z)
uv pip install "https://github.com/sgl-project/whl/releases/download/vX.Y.Z/sglang_kernel-X.Y.Z+cu130-cp310-abi3-manylinux2014_x86_64.whl"

Installera och kör SGLang med Docker Hub-bilder

För containeriserade deployment – eller för att undvika parning av CUDA/PyTorch på värdmaskinen – använd de publicerade Docker Hub-bilderna. En typisk docker run monterar Hugging Face-cachen och skickar HF_TOKEN när hämtning av skyddade modeller sker.

docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=<secret>" \
  --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

För produktionsliknande bilder minskar latest-runtime byggverktyg och utvecklingsberoenden, så att bilden blir mycket mindre än standardvarianten latest.

docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=<secret>" \
  --ipc=host \
  lmsysorg/sglang:latest-runtime \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000

Installera från källkod och andra deploymentsmetoder

För att utveckla mot SGLang eller bära med sig lokala patchar, klonar du en release-gren och installerar Python-paketet i redigerbart läge:

git clone -b v0.5.9 https://github.com/sgl-project/sglang.git
cd sglang

pip install --upgrade pip
pip install -e "python"

För orkestrering inkluderar repositoriet Kubernetes-manifest (en- och flernod) och en minimal Docker Compose-layout – rimliga startpunkter innan anpassad kabeldragnings.

Hur man konfigurerar SGLang-serverargument med YAML-konfigurationsfiler och miljövariabler

SGLang-konfiguration drivs av serverargument och miljövariabler. Flaggor täcker modellval, parallellism, minne och optimeringsknappar; den fulla uppsättningen listas med python3 -m sglang.launch_server --help.

Miljövariabler använder två prefix: SGL_ och SGLANG_ (många flaggor accepterar antingen CLI- eller miljöform – launch_server --help visar mappningen).

Några vanligt relevanta miljövariabler inkluderar kontroll för värd och port såsom SGLANG_HOST_IP och SGLANG_PORT.

Använd en YAML-konfigurationsfil för reproducerbara SGLang-serverstartar

För upprepbara deployment och kortare kommandorader, skicka en YAML-fil med --config. CLI-argument överskriver värden från filen när båda sätter samma alternativ.

# Skapa config.yaml
cat > config.yaml << 'EOF'
model-path: meta-llama/Meta-Llama-3-8B-Instruct
host: 0.0.0.0
port: 30000
tensor-parallel-size: 2
enable-metrics: true
log-requests: true
EOF

# Starta servern med konfigurationsfil
python -m sglang.launch_server --config config.yaml

Några konfigurations- och optimeringsgrundläggande att tänka på:

SGLangs --model-path kan peka på en lokal mapp eller ett Hugging Face-repo-ID, vilket gör det enkelt att växla mellan lokala vikter och Hub-hostade modeller utan att ändra din serverkod.

För flera GPU:er, aktivera tensorparallellism med --tp. Om start misslyckas med “peer access is not supported between these two devices”, lägg till --enable-p2p-check.

Om servering träffar OOM, minska KV-cache-trycket med en mindre --mem-fraction-static (standard är 0.9).

Om långa prompts OOM under prefill, sänk --chunked-prefill-size.

Hur man kör en OpenAI-kompatibel SGLang-server och anropar den från OpenAI Python-klienten

En praktisk “lyckosam väg” arbetsflöde ser ut så här:

  1. Installera SGLang (uv/pip eller Docker).
  2. Starta servern med din valda modell och port.
  3. Verifiera grundläggande servering via OpenAI-kompatibla slutpunkter.
  4. Integrera din applikation genom att peka OpenAI SDK:s base_url mot den lokala servern.
  5. Optimera genomströmning och minne med serverargument när du har riktig trafik.

Skicka en lokal chattkompletteringsförfrågan till SGLang med OpenAI SDK

För OpenAI-kompatibel användning är två detaljer viktiga:

Servern implementerar OpenAI:s HTTP-yta och, när tokenisatorn tillhandahåller en, tillämpar Hugging Face-chattmallen automatiskt. Överskriv med --chat-template vid start om nödvändigt.

Peeka en OpenAI-klient mot serverns /v1-prefix (base_url → http://<host>:<port>/v1), och anropa sedan client.chat.completions.create(...) som vanligt.

Starta servern med antingen ingångspunkt: python -m sglang.launch_server fungerar fortfarande, men sglang serve är det föreslagna CLI:et.

# Rekommenderad CLI-ingångspunkt
sglang serve --model-path qwen/qwen2.5-0.5b-instruct --host 0.0.0.0 --port 30000

# Fortfarande stödd
python3 -m sglang.launch_server --model-path qwen/qwen2.5-0.5b-instruct --host 0.0.0.0 --port 30000

Anropa sedan det med OpenAI Python-klienten:

import openai

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

response = client.chat.completions.create(
    model="qwen/qwen2.5-0.5b-instruct",
    messages=[{"role": "user", "content": "List 3 länder och deras huvudstäder."}],
    temperature=0,
    max_tokens=64,
)

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

Hur man kör batchinferens med SGLang Offline Engine API och inbyggda slutpunkter

SGLang stöder flera “API-ytor” beroende på vad du bygger:

Slutpunkten /generate är den lågnivå-runtime-API. Föredra /v1/... OpenAI-kompatibla rutter när du vill ha chattmallar och det vanliga klientekosystemet hanterat åt dig.

Utan någon HTTP-server kör Offline Engine inferens in-process: lämpad för batchjobb och anpassade tjänster. Den stöder synk/asynk och strömmande/icke-strömmande kombinationer – välj läget som matchar anropsmönstret.

Exempel som använder den inbyggda /generate-slutpunkten

Minimalt mönster: kör en server, sedan POST /generate med temperature och max_new_tokens (och vilka andra samplingsfält du behöver).

import requests

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Huvudstaden i Frankrike är",
        "sampling_params": {
            "temperature": 0,
            "max_new_tokens": 32,
        },
    },
)

print(response.json())

temperature = 0 är girig sampling; högre värden ökar mångfalden.

Exempel som använder Offline Engine API för in-process batchinferens

Typiskt flöde: konstruera sgl.Engine(model_path=...), kör llm.generate(...) över en batch av prompts, och sedan llm.shutdown() för att frigöra GPU och andra resurser.

import sglang as sgl

llm = sgl.Engine(model_path="qwen/qwen2.5-0.5b-instruct")

prompts = [
    "Skriv en koncis självbiografi.",
    "Förklara vad prefixcaching är i en stycke.",
]

sampling_params = {"temperature": 0.2, "top_p": 0.9}

outputs = llm.generate(prompts, sampling_params)
for prompt, output in zip(prompts, outputs):
    print("PROMPT:", prompt)
    print("OUTPUT:", output["text"])
    print()

llm.shutdown()