LLM-Bereitstellung: Ollama vs vLLM vs TGI

Vergleiche vLLM vs SGLang vs Ollama vs TGI vs LocalAI für LLM-Bereitstellung

Wählen Sie die richtige LLM-Serving-Lösung für Ihre Anforderungen auf CLORE.AI.

Alle Optionen verfügbar auf CLORE.AI-Marktplatz.

Update 2025: SGLang hat sich als erstklassiges Framework etabliert, oft vLLM übertreffend bei Durchsatz- und TTFT-Benchmarks. Sowohl vLLM v0.7 als auch SGLang v0.4 werden für Produktions-Workloads empfohlen.

Kurzanleitung zur Entscheidung

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Anwendungsfall	Beste Wahl	Warum
Schnelles Testen & Chatten	Ollama	Einfachstes Setup, schnellster Start
Produktions-API (maximaler Durchsatz)	SGLang oder vLLM	Höchster Durchsatz im Jahr 2025
Reasoning-Modelle (DeepSeek-R1)	SGLang	Beste Unterstützung für Reasoning-Ketten
HuggingFace-Integration	TGI	Native HF-Unterstützung
Lokale Entwicklung	Ollama	Funktioniert überall
Hohe Parallelität	SGLang oder vLLM	Kontinuierliches Batching
Multimodal (TTS, STT, Embeddings)	LocalAI	All-in-one-Lösung
Streaming-Apps	vLLM oder SGLang	Beide hervorragend

Vergleich der Startzeiten

Lösung	Typischer Start	Hinweise
Ollama	30-60 Sekunden	Am schnellsten, leichtgewichtig
SGLang	3-8 Minuten	Lädt Modell von HF herunter
vLLM	5-15 Minuten	Lädt Modell von HF herunter
TGI	3-10 Minuten	Lädt Modell von HF herunter
LocalAI	5-10 Minuten	Lädt mehrere Modelle vorab

HTTP-502-Fehler während des Starts sind normal – der Dienst initialisiert noch.

---

Überblicksvergleich

Funktion	Ollama	vLLM	SGLang	TGI	LocalAI
Einfachheit der Einrichtung	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
Leistung	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
Modellunterstützung	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
API-Kompatibilität	Benutzerdefiniert + OpenAI	OpenAI	OpenAI	Benutzerdefiniert + OpenAI	OpenAI
Multi-GPU	Begrenzt	Hervorragend	Hervorragend	Gut	Begrenzt
Speichereffizienz	Gut	Hervorragend	Hervorragend	Sehr gut	Gut
Multimodal	Nur Vision	Nur Vision	Nur Vision	Nein	TTS, STT, Embeddings
Startzeit	30 Sek.	5-15 Min.	3-8 Min.	3-10 Min.	5-10 Min.
Reasoning-Modelle	Begrenzt	Gut	Hervorragend	Gut	Begrenzt
Am besten geeignet für	Entwicklung	Produktion	Produktion + Reasoning	HF-Ökosystem	Multimodal

---

Benchmarks 2025: DeepSeek-R1-32B

TTFT, TPOT & Durchsatz (A100 80 GB, Batch=32, Eingabe=512, Ausgabe=512)

Framework	TTFT (ms)	TPOT (ms/Token)	Durchsatz (Token/s)	Hinweise
SGLang v0.4	180	14	2,850	Insgesamt beste Wahl 2025
vLLM v0.7	240	17	2,400	Hervorragend, nahe an SGLang
llama.cpp	420	28	1,100	CPU+GPU, quantisiert
Ollama	510	35	820	Priorität auf Benutzerfreundlichkeit

TTFT = Time to First Token (Latenz). TPOT = Zeit pro Ausgabe-Token. Niedriger ist für beide besser.

Durchsatzvergleich (RTX 4090, Llama 3.1 8B, 10 gleichzeitige Benutzer)

Framework	Tokens/Sek.	Gleichzeitige Benutzer	Hinweise
SGLang v0.4	920	20-30	Radix-Attention-Caching
vLLM v0.7	870	20-30	PagedAttention
TGI	550	10-20
Ollama	160*	—	Standardmäßig sequenziell

*Ollama bedient Anfragen standardmäßig sequenziell

---

SGLang

Überblick

SGLang (Structured Generation Language) ist ein LLM-Serving-Framework mit hohem Durchsatz, das von Forschern der UC Berkeley und LMSYS entwickelt wurde. In den Benchmarks 2025 liegt es häufig gleichauf mit vLLM oder übertrifft es — insbesondere bei Reasoning-Modellen wie DeepSeek-R1.

Vorteile

• ✅ Häufig die schnellste TTFT und der höchste Durchsatz in Benchmarks 2025

• ✅ Radix-Attention für effiziente KV-Cache-Wiederverwendung

• ✅ Hervorragende Unterstützung für Reasoning-Modelle (DeepSeek-R1, QwQ)

• ✅ OpenAI-kompatible API

• ✅ Kontinuierliches Batching und Prefix-Caching

• ✅ Unterstützung für speculative decoding

• ✅ Tensor-Parallelität über mehrere GPUs

Nachteile

• ❌ Neueres Ökosystem, weniger Community-Ressourcen als vLLM

• ❌ Komplexeres Setup als Ollama

• ❌ Nur Linux

Schnellstart

pip install sglang[all]

# Modell bereitstellen
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \
    --port 8000

DeepSeek-R1 mit SGLang

python -m sglang.launch_server \\
    --model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \\
    --host 0.0.0.0 \
    --port 8000 \\
    --tp 2 \
    --reasoning-parser deepseek-r1

API-Nutzung

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'user', 'content': 'Erkläre Quantenverschränkung'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)

Multi-GPU

# 2 GPUs (Tensor-Parallelität)
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-70B-Instruct \\
    --host 0.0.0.0 \
    --port 8000 \\
    --tp 2

Am besten geeignet für

• 🎯 Produktions-APIs mit maximalem Durchsatz

• 🎯 Reasoning-Modelle (DeepSeek-R1, QwQ, o1-Stil)

• 🎯 Anwendungen mit geringer Latenz (TTFT)

• 🎯 Präfix-intensive Workloads (hohe KV-Cache-Wiederverwendung)

---

Ollama

Überblick

Ollama ist der einfachste Weg, LLMs lokal auszuführen. Perfekt für Entwicklung, Tests und den persönlichen Gebrauch.

Vorteile

• ✅ Installation und Ausführung mit einem Befehl

• ✅ Integrierte Modellbibliothek

• ✅ Großartiges CLI-Erlebnis

• ✅ Funktioniert auf Mac, Linux, Windows

• ✅ Automatische Quantisierung

• ✅ Geringer Ressourcenverbrauch

Nachteile

• ❌ Geringerer Durchsatz als Alternativen

• ❌ Eingeschränkte Unterstützung für mehrere GPUs

• ❌ Weniger produktionsreif

• ❌ Weniger Optimierungsoptionen

Schnellstart

# Installieren
curl -fsSL https://ollama.com/install.sh | sh

# Beliebiges Modell ausführen
ollama run llama3.2
ollama run mistral
ollama run codellama

# API bereitstellen
ollama serve

API-Nutzung

import requests

# Generieren
response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Erkläre Quantencomputing',
    'stream': False
})
print(response.json()['response'])

# Chat
response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': 'Hallo!'}
    ]
})

OpenAI-Kompatibilität

from openai import OpenAI

client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')

response = client.chat.completions.create(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Hallo!'}]
)

Leistung

Modell	GPU	Tokens/Sek.
Llama 3.2 3B	RTX 3060	45-55
Llama 3.1 8B	RTX 3090	35-45
Llama 3.1 70B	A100 40GB	15-20

Am besten geeignet für

• 🎯 Schnelles Prototyping

• 🎯 Persönlicher KI-Assistent

• 🎯 Lernen und Experimentieren

• 🎯 Einfache Bereitstellungen

---

vLLM

Überblick

vLLM ist eine in der Praxis bewährte LLM-Inferenz-Engine mit hohem Durchsatz für den Produktionseinsatz. v0.7 (2025) bringt verbesserte Leistung, bessere Unterstützung für Quantisierung und neue Optionen für speculative decoding.

Vorteile

• ✅ Höchster Durchsatz (kontinuierliches Batching + PagedAttention)

• ✅ PagedAttention für effiziente Speicherverwendung

• ✅ Hervorragende Unterstützung für mehrere GPUs

• ✅ OpenAI-kompatible API

• ✅ Produktionsreif, große Community

• ✅ Unterstützt viele Quantisierungsformate (AWQ, GPTQ, FP8)

• ✅ Speculative Decoding in v0.7

Nachteile

• ❌ Komplexeres Setup

• ❌ Höherer Speicherverbrauch beim Start

• ❌ Nur Linux (kein natives Windows/Mac)

• ❌ Erfordert mehr Konfiguration

Schnellstart

pip install vllm

# Modell bereitstellen (vLLM v0.7)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \
    --port 8000

Docker-Bereitstellung

docker run --gpus all -p 8000:8000 \
    vllm/vllm-openai:v0.7.0 \\
    --model meta-llama/Llama-3.1-8B-Instruct

API-Nutzung

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

# Chat-Vervollständigung
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': 'Du bist hilfreich.'},
        {'role': 'user', 'content': 'Schreibe ein Haiku über Programmieren'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Streaming
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Erzähl mir eine Geschichte'}],
    stream=True
)
for chunk in stream:
    print(chunk.choices[0].delta.content, end='')

Multi-GPU

# 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2

# 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4

Leistung

Modell	GPU	Tokens/Sek.	Gleichzeitige Benutzer
Llama 3.1 8B	RTX 3090	80-100	10-20
Llama 3.1 8B	RTX 4090	120-150	20-30
Llama 3.1 70B	A100 40GB	25-35	5-10
Llama 3.1 70B	2x A100	50-70	15-25

Am besten geeignet für

• 🎯 Produktions-APIs mit großer Community

• 🎯 Anwendungen mit hohem Datenverkehr

• 🎯 Chat-Dienste für mehrere Benutzer

• 🎯 Bedarf an maximalem Durchsatz

---

Text Generation Inference (TGI)

Überblick

Der Produktionsserver von HuggingFace, eng in das HF-Ökosystem integriert.

Vorteile

• ✅ Native HuggingFace-Integration

• ✅ Großartig für HF-Modelle

• ✅ Gute Unterstützung für mehrere GPUs

• ✅ Integrierte Sicherheitsfunktionen

• ✅ Prometheus-Metriken

• ✅ Gut dokumentiert

Nachteile

• ❌ Etwas geringerer Durchsatz als vLLM/SGLang

• ❌ Ressourcenintensiver

• ❌ Komplexe Konfiguration

• ❌ Längere Startzeiten

Schnellstart

# Docker (empfohlen)
docker run --gpus all -p 8080:80 \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct

# Mit HF-Token für eingeschränkte Modelle
docker run --gpus all -p 8080:80 \\
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct

Leistung

Modell	GPU	Tokens/Sek.	Gleichzeitige Benutzer
Llama 3.1 8B	RTX 3090	60-80	8-15
Llama 3.1 8B	RTX 4090	90-120	15-25
Llama 3.1 70B	A100 40GB	20-30	3-8

Am besten geeignet für

• 🎯 HuggingFace-Modellnutzer

• 🎯 Forschungsumgebungen

• 🎯 Sie benötigen integrierte Sicherheitsfunktionen

• 🎯 Bedarf an Prometheus-Überwachung

---

LocalAI

Überblick

LocalAI ist eine OpenAI-kompatible API, die mehrere Modalitäten unterstützt: LLMs, TTS, STT, Embeddings und Bildgenerierung.

Vorteile

• ✅ Unterstützung für mehrere Modalitäten (LLM, TTS, STT, Embeddings)

• ✅ Direkter OpenAI-Ersatz

• ✅ Vorgefertigte Modelle verfügbar

• ✅ Unterstützt GGUF-Modelle

• ✅ Unterstützung für Reranking

• ✅ Swagger-UI-Dokumentation

Nachteile

• ❌ Längere Startzeit (5-10 Minuten)

• ❌ Geringerer LLM-Durchsatz als vLLM/SGLang

• ❌ Bei der Bildgenerierung kann es zu CUDA-Problemen kommen

• ❌ Für reine LLM-Nutzung komplexer

Schnellstart

docker run --gpus all -p 8080:8080 localai/localai:master-aio-gpu-nvidia-cuda-12

API-Nutzung

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8080/v1', api_key='dummy')

# Chat
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Hallo!'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='Hello world', voice='alloy')

# STT
transcript = client.audio.transcriptions.create(model='whisper-1', file=open('audio.mp3', 'rb'))

# Embeddings
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='Hello world')

Am besten geeignet für

• 🎯 Sie benötigen mehrere Modalitäten (TTS, STT, LLM)

• 🎯 Sie möchten OpenAI-API-Kompatibilität

• 🎯 GGUF-Modelle ausführen

• 🎯 Workflows zum Dokumenten-Reranking

---

Leistungsvergleich (2025)

Durchsatz (Token/Sekunde) — Einzelner Benutzer

Modell	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B (RTX 3090)	40	90	100	70
Llama 3.1 8B (RTX 4090)	65	140	160	110
Llama 3.1 70B (A100 40GB)	18	30	35	25

Durchsatz — Mehrere Benutzer (10 gleichzeitig)

Modell	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B (RTX 4090)	150*	800	920	500
Llama 3.1 70B (A100 40GB)	50*	200	240	150

*Ollama bedient standardmäßig sequenziell

Speichernutzung

Modell	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B	5GB	6 GB	6 GB	7 GB
Llama 3.1 70B (Q4)	38 GB	40 GB	39 GB	42 GB

Time to First Token (TTFT) — DeepSeek-R1-32B

Framework	TTFT (A100 80GB)	TPOT (ms/Token)
SGLang v0.4	180ms	14 ms
vLLM v0.7	240 ms	17 ms
llama.cpp	420 ms	28 ms
Ollama	510 ms	35 ms

---

Funktionsvergleich

Funktion	Ollama	vLLM v0.7	SGLang v0.4	TGI	LocalAI
OpenAI-API	✅	✅	✅	✅	✅
Streaming	✅	✅	✅	✅	✅
Batching	Einfach	Kontinuierlich	Kontinuierlich	Dynamisch	Einfach
Multi-GPU	Begrenzt	Hervorragend	Hervorragend	Gut	Begrenzt
Quantisierung	GGUF	AWQ, GPTQ, FP8	AWQ, GPTQ, FP8	bitsandbytes, AWQ	GGUF
LoRA	✅	✅	✅	✅	✅
Spekulatives Decoding	❌	✅	✅	✅	❌
Prefix-Caching	❌	✅	✅ (Radix)	✅	❌
Reasoning-Modelle	Begrenzt	Gut	Hervorragend	Gut	Begrenzt
Metriken	Einfach	Prometheus	Prometheus	Prometheus	Prometheus
Funktionsaufrufe	✅	✅	✅	✅	✅
Visionsmodelle	✅	✅	✅	✅	Begrenzt
TTS	❌	❌	❌	❌	✅
STT	❌	❌	❌	❌	✅
Embeddings	✅	Begrenzt	Begrenzt	Begrenzt	✅

---

Wann was verwenden

Verwenden Sie Ollama, wenn:

• Sie in 5 Minuten loslegen möchten

• Sie prototypen oder lernen

• Sie einen persönlichen KI-Assistenten brauchen

• Sie auf Mac oder Windows arbeiten

• Einfachheit ist wichtiger als Geschwindigkeit

Verwenden Sie SGLang, wenn:

• Sie brauchen die absolut geringste Latenz (TTFT)

• Sie bedienen Reasoning-Modelle (DeepSeek-R1, QwQ, o1-Stil)

• Sie haben Workloads mit starkem Präfix-Sharing (RAG, System-Prompts)

• Sie in Benchmarks 2025 den besten Durchsatz brauchen

• Sie modernste Optimierungen möchten (Radix-Attention)

Verwenden Sie vLLM, wenn:

• Sie maximalen Durchsatz mit einem ausgereiften, gut unterstützten Framework

• Sie viele Benutzer in großem Maßstab bedienen

• Sie Produktionszuverlässigkeit mit einer großen Community brauchen

• Sie einen OpenAI-Drop-in-Ersatz möchten

• Sie Multi-GPU-Setups haben

• Sie breite Unterstützung für Modellformate brauchen (AWQ, GPTQ, FP8)

Verwenden Sie TGI, wenn:

• Sie im HuggingFace-Ökosystem sind

• Sie integrierte Sicherheitsfunktionen brauchen

• Sie detaillierte Prometheus-Metriken möchten

• Sie HF-Modelle direkt bereitstellen müssen

• Sie in einer Forschungsumgebung sind

Verwenden Sie LocalAI, wenn:

• Sie TTS und STT zusätzlich zu LLM brauchen

• Sie Embeddings für RAG möchten

• Sie Dokumenten-Reranking brauchen

• Sie eine einzige All-in-one-Lösung möchten

• Sie sprachfähige Apps entwickeln

---

Migrationsleitfaden

Von Ollama zu SGLang

# Ollama
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
response = client.chat.completions.create(model='llama3.2', ...)

# SGLang - nur URL und Modellnamen ändern
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)

Von vLLM zu SGLang

Beide unterstützen die OpenAI-API - ändern Sie einfach die Endpunkt-URL. Die APIs sind vollständig kompatibel.

# vLLM
python -m vllm.entrypoints.openai.api_server --model ... --port 8000

# SGLang (entsprechend)
python -m sglang.launch_server --model-path ... --port 8000

---

Empfehlungen nach GPU

GPU	Einzelbenutzer	Mehrbenutzer	Reasoning-Modelle
RTX 3060 12 GB	Ollama	Ollama	Ollama
RTX 3090 24 GB	Ollama	vLLM	SGLang
RTX 4090 24GB	SGLang/vLLM	SGLang/vLLM	SGLang
A100 40GB+	SGLang	SGLang	SGLang

---

Nächste Schritte

• Ollama-Anleitung - Einfachste Einrichtung

• vLLM-Anleitung - Höchster Durchsatz

• LocalAI-Anleitung - Unterstützung für multimodale Eingaben

• DeepSeek-R1-Anleitung - Reasoning-Modelle

• Multi-GPU-Einrichtung - Skalierung auf größere Modelle

• API-Integration - Anwendungen erstellen