SGLang-Schnellstart: LLMs installieren, konfigurieren und über die OpenAI-API bereitstellen

Dienen Sie Open-Modelle schnell mit SGLang.

Inhaltsverzeichnis

SGLang ist ein leistungsfähiges Bereitstellungsframework für große Sprachmodelle und multimodale Modelle, das entwickelt wurde, um Inferenz mit geringer Latenz und hohem Durchsatz von einzelnen GPUs bis hin zu verteilten Clustern zu ermöglichen.

Für einen umfassenderen Vergleich von Self-Hosted- und Cloud-Hosting-Optionen für LLMs – einschließlich Ollama, vLLM, llama-swap, LocalAI und verwalteten Cloud-Anbietern – siehe den LLM-Hosting-Leitfaden für 2026.

Wenn Sie bereits Anwendungen haben, die an die OpenAI-API-Schnittstelle angebunden sind, ist SGLang besonders attraktiv, da es OpenAI-kompatible Endpunkte für Chat-Vervollständigungen und Vervollständigungen bereitstellen kann. Dies erleichtert die Migration von gehosteten APIs zu selbst gehosteten Modellen mit minimalen Änderungen auf Client-Seite. Wenn Sie Anfragen über mehrere Backends (llama.cpp, vLLM, SGLang usw.) mit Hot-Swap- und TTL-basiertem Unloading routen müssen, bietet llama-swap eine transparente Proxy-Ebene, die eine einzelne /v1-URL stabil hält, während die Upstreams bei Bedarf ausgetauscht werden.

sglang-infografik

Dieser Schnellstart führt durch die Installation (mehrere Methoden), praktische Konfigurationsmuster und einen sauberen Arbeitsablauf “installieren → bereitstellen → verifizieren → integrieren → optimieren”, mit funktionierenden Beispielen sowohl für HTTP-Bereitstellung als auch für Offline-Batch-Inferenz.

Wenn Sie Unterstützung für Multimodalität (Text, Embeddings, Bilder, Audio) mit einer integrierten Benutzeroberfläche und maximaler Kompatibilität als Drop-in für die OpenAI-API benötigen, bietet LocalAI eine breitere Funktionalität mit Unterstützung für mehr Modellformate.

Was ist SGLang für das High-Throughput-Hosting von LLMs und multimodalen Modellen?

Im Kern ist SGLang für effiziente Inferenz und skalierbare Bereitstellung konzipiert. Der Stack für die “schnelle Laufzeit” umfasst RadixAttention für Prefix-Caching, einen CPU-Scheduler ohne Overhead, spekulatives Decodieren, kontinuierliches Batching, paginierte Aufmerksamkeit, mehrere Parallelisierungsstrategien (Tensor-, Pipeline-, Experten-, Datenparallelität), strukturierte Ausgaben, chunked Prefill und mehrere Quantisierungsoptionen (zum Beispiel FP4, FP8, INT4, AWQ, GPTQ).

Es zielt auf eine breite Plattformbereitstellung ab: NVIDIA-GPUs, AMD-GPUs, Intel-Xeon-CPUs, Google-TPUs, Ascend-NPUs und mehr.

PyPI erfordert Python >= 3.10. Stand 20. März 2026 umfasste die veröffentlichte Version 0.5.9 (veröffentlicht am 23. Februar 2026) – koppeln Sie die Version oder prüfen Sie die aktuellen Versionen bei der Installation.

So installieren Sie SGLang auf Linux-GPU-Hosts mit uv pip, Quellcode-Compilierung oder Docker

Die Installationsmöglichkeiten umfassen uv oder pip, Kompilierung aus dem Quellcode, Docker-Images, Kubernetes-Manifeste, Docker Compose, SkyPilot und AWS SageMaker. Die meisten Anleitungen gehen von gängigen NVIDIA-GPU-Setups aus; andere Beschleuniger haben eigene Einrichtungshinweise an anderer Stelle.

Installieren Sie SGLang schnell mit uv oder pip unter Python 3.10+

Für eine unkomplizierte lokale Installation ist uv in der Regel der schnellste Weg:

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

Hinweise zu CUDA 13

Für CUDA 13 vermeidet Docker Fehlabstimmungen von PyTorch/CUDA auf Host-Ebene. Ohne Docker: Installieren Sie einen PyTorch-Build für CUDA 13, dann sglang und anschließend das passende sglang-kernel-Rad aus den veröffentlichten Rad-Veröffentlichungen (die Version muss mit dem Stack übereinstimmen).

# 1) Installieren Sie PyTorch mit CUDA 13-Unterstützung (ersetzen Sie X.Y.Z bei Bedarf)
uv pip install torch==X.Y.Z torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130

# 2) Installieren Sie SGLang
uv pip install sglang

# 3) Installieren Sie das passende CUDA 13 sglang-kernel-Rad (ersetzen Sie 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"

Installieren und ausführen von SGLang mit Docker Hub-Images

Für containerisierte Bereitstellungen – oder um die Paarung von CUDA/PyTorch auf dem Host zu umgehen – verwenden Sie die veröffentlichten Docker Hub-Images. Ein typischer docker run-Befehl mountet den Hugging Face-Cache und übergibt HF_TOKEN, wenn geschützte Modelle abgerufen werden.

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 produktionsähnliche Images latest-runtime entfernt Build-Tools und Entwicklungssabhängigkeiten, sodass das Image viel kleiner bleibt als die Standardvariante 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

Installation aus dem Quellcode und andere Bereitstellungsmethoden

Um an SGLang zu entwickeln oder lokale Patches vorzunehmen, klonen Sie eine Release-Zweig und installieren Sie das Python-Paket im bearbeitbaren Modus:

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 die Orchestrierung enthält das Repository Kubernetes-Manifeste (Single- und Multi-Node) und ein minimales Docker Compose-Layout – sinnvolle Ausgangspunkte vor individueller Verkabelung.

So konfigurieren Sie SGLang-Server-Argumente mit YAML-Konfigurationsdateien und Umgebungsvariablen

Die SGLang-Konfiguration wird durch Serverargumente und Umgebungsvariablen gesteuert. Flags decken die Modellauswahl, Parallelität, Speicher und Optimierungsoptionen ab; die vollständige Liste wird mit python3 -m sglang.launch_server --help angezeigt.

Umgebungsvariablen verwenden zwei Präfixe: SGL_ und SGLANG_ (viele Flags akzeptieren entweder die CLI- oder die Umgebungsvariablenform – launch_server --help zeigt die Zuordnung).

Zu den häufig relevanten Umgebungsvariablen gehören Host- und Port-Steuerungen wie SGLANG_HOST_IP und SGLANG_PORT.

Verwenden Sie eine YAML-Konfigurationsdatei für reproduzierbare SGLang-Serverstarts

Für wiederholbare Bereitstellungen und kürzere Befehlszeilen übergeben Sie eine YAML-Datei mit --config. CLI-Argumente überschreiben Werte aus der Datei, wenn beide dieselbe Option festlegen.

# config.yaml erstellen
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

# Server mit Konfigurationsdatei starten
python -m sglang.launch_server --config config.yaml

Einige wichtige Konfigurations- und Optimierungselemente im Gedächtnis behalten:

Der --model-path von SGLang kann auf einen lokalen Ordner oder eine Hugging Face-Repo-ID zeigen, was den Wechsel zwischen lokalen Gewichten und auf dem Hub gehosteten Modellen ohne Änderung des Bereitstellungscode einfach macht.

Für Multi-GPU aktivieren Sie die Tensor-Parallelität mit --tp. Wenn der Start mit der Fehlermeldung „peer access is not supported between these two devices" fehlschlägt, fügen Sie --enable-p2p-check hinzu.

Wenn die Bereitstellung einen OOM-Fehler (Out of Memory) auslöst, reduzieren Sie den KV-Cache-Druck mit einem kleineren --mem-fraction-static (Standard ist 0.9).

Wenn lange Prompts während des Prefills einen OOM-Fehler auslösen, senken Sie --chunked-prefill-size.

So führen Sie einen OpenAI-kompatiblen SGLang-Server aus und rufen ihn vom OpenAI-Python-Client auf

Ein praktischer Arbeitsablauf für den “Happy Path” sieht wie folgt aus:

  1. SGLang installieren (uv/pip oder Docker).
  2. Den Server mit dem gewünschten Modell und Port starten.
  3. Die grundlegende Bereitstellung über OpenAI-kompatible Endpunkte überprüfen.
  4. Ihre Anwendung integrieren, indem Sie das OpenAI-SDK base_url auf den lokalen Server zeigen.
  5. Durchsatz und Speicher mit Serverargumenten optimieren, sobald echter Datenverkehr vorliegt.

Senden einer lokalen Chat-Vervollständigungsanfrage an SGLang mit dem OpenAI-SDK

Für die OpenAI-kompatible Nutzung sind zwei Details wichtig:

Der Server implementiert die OpenAI-HTTP-Oberfläche und wendet, wenn der Tokenizer eine Vorlage bereitstellt, die Hugging Face-Chat-Vorlage automatisch an. Überschreiben Sie dies bei Bedarf mit --chat-template beim Start.

Richten Sie einen OpenAI-Client auf das /v1-Präfix des Servers aus (base_url → http://<host>:<port>/v1) und rufen Sie dann client.chat.completions.create(...) wie üblich auf.

Starten Sie den Server mit einem der beiden Einstiegspunkte: python -m sglang.launch_server funktioniert immer noch, aber sglang serve ist der bevorzugte CLI-Einstiegspunkt.

# Empfohlener CLI-Einstiegspunkt
sglang serve --model-path qwen/qwen2.5-0.5b-instruct --host 0.0.0.0 --port 30000

# Immer noch unterstützt
python3 -m sglang.launch_server --model-path qwen/qwen2.5-0.5b-instruct --host 0.0.0.0 --port 30000

Rufen Sie es dann mit dem OpenAI-Python-Client auf:

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": "Liste 3 Länder und ihre Hauptstädte."}],
    temperature=0,
    max_tokens=64,
)

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

So führen Sie Batch-Inferenz mit der SGLang Offline Engine API und nativen Endpunkten aus

SGLang unterstützt mehrere “API-Oberflächen” je nach Ihrem Anwendungsfall:

Der /generate-Endpunkt ist die Low-Level-Laufzeit-API. Bevorzugen Sie /v1/...-OpenAI-kompatible Routen, wenn Sie Chat-Vorlagen und das übliche Client-Ökosystem automatisch handhaben möchten.

Ohne HTTP-Server führt die Offline Engine die Inferenz im Prozess aus: Geeignet für Batch-Jobs und benutzerdefinierte Dienste. Sie unterstützt synchrone/asynchrone und Streaming/Non-Streaming-Kombinationen – wählen Sie den Modus, der dem Aufrufmuster entspricht.

Beispiel mit dem nativen /generate-Endpunkt

Minimales Muster: Starten Sie einen Server und senden Sie dann einen POST an /generate mit temperature und max_new_tokens (und allen anderen Sampling-Feldern, die Sie benötigen).

import requests

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Die Hauptstadt von Frankreich ist",
        "sampling_params": {
            "temperature": 0,
            "max_new_tokens": 32,
        },
    },
)

print(response.json())

temperature = 0 ist eine gierige Stichprobenziehung; höhere Werte erhöhen die Vielfalt.

Beispiel mit der Offline Engine API für Batch-Inferenz im Prozess

Typischer Ablauf: Konstruktion von sgl.Engine(model_path=...), Ausführung von llm.generate(...) über eine Batch von Prompts und dann llm.shutdown(), um GPU und andere Ressourcen freizugeben.

import sglang as sgl

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

prompts = [
    "Schreiben Sie eine knappe Selbsteinführung.",
    "Erklären Sie, was Prefix-Caching ist, in einem Absatz.",
]

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()