LLM-Bereitstellung: Ollama vs vLLM vs TGI

Vergleichen Sie vLLM vs SGLang vs Ollama vs TGI vs LocalAI für LLM-Serving

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

Alle Optionen verfügbar auf CLORE.AI Marketplace.

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

Schnelle Entscheidungsübersicht

Einsatzgebiet	Beste Wahl	Warum
Schnelles Testen & Chat	Ollama	Einfachste Einrichtung, schnellster Start
Produktions-API (maximaler Durchsatz)	SGLang oder vLLM	Höchster Durchsatz 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-Anwendungen	vLLM oder SGLang	Beide ausgezeichnet

Vergleich der Startzeit

Lösung	Typischer Start	Hinweise
Ollama	30–60 Sekunden	Schnellster, 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 vor

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

---

Übersichtsvergleich

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

---

2025-Benchmarks: DeepSeek-R1-32B

TTFT, TPOT & Durchsatz (A100 80GB, batch=32, input=512, output=512)

Framework	TTFT (ms)	TPOT (ms/tok)	Durchsatz (tok/s)	Hinweise
SGLang v0.4	180	14	2,850	Insgesamt am besten 2025
vLLM v0.7	240	17	2,400	Ausgezeichnet, 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 = Time Per Output Token. Niedriger ist besser bei beiden.

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

Framework	Tokens/sec	Gleichzeitige Nutzer	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 hochdurchsatzfähiges LLM-Serving-Framework, entwickelt von Forschern der UC Berkeley und LMSYS. In Benchmarks 2025 erreicht oder übertrifft es häufig vLLM – insbesondere bei Reasoning-Modellen wie DeepSeek-R1.

Vorteile

• ✅ Oft schnellste TTFT und höchster Durchsatz in den 2025-Benchmarks

• ✅ 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 Spekulatives Decoding

• ✅ Tensor-Parallelismus über mehrere GPUs

Nachteile

• ❌ Jüngeres Ökosystem, weniger Community-Ressourcen als vLLM

• ❌ Komplexere Einrichtung als Ollama

• ❌ Nur Linux

Schnellstart

pip install sglang[all]

# Einen Dienst starten
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-Parallelismus)
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

• 🎯 Maximale Durchsatz-Produktion-APIs

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

• 🎯 Niedriglatenz-Anwendungen (TTFT)

• 🎯 Prefix-lastige Workloads (hohe KV-Cache-Wiederverwendung)

---

Ollama

Überblick

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

Vorteile

• ✅ Ein-Kommando-Installation und Ausführung

• ✅ Integrierte Modellbibliothek

• ✅ Großartiges CLI-Erlebnis

• ✅ Funktioniert auf Mac, Linux, Windows

• ✅ Automatische Quantisierung

• ✅ Geringer Ressourcen-Overhead

Nachteile

• ❌ Niedrigerer Durchsatz als Alternativen

• ❌ Begrenzte Multi-GPU-Unterstützung

• ❌ Weniger produktionsreif

• ❌ Weniger Optimierungsoptionen

Schnellstart

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

# Führe beliebiges Modell aus
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': 'Hello!'}
    ]
})

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/sec
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 Deployments

---

vLLM

Überblick

vLLM ist eine erprobte, hochdurchsatzfähige LLM-Inferenz-Engine für die Produktion. v0.7 (2025) bringt verbesserte Leistung, bessere Quantisierungsunterstützung und neue Optionen für spekulatives Decoding.

Vorteile

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

• ✅ PagedAttention für effizienten Speicher

• ✅ Hervorragende Multi-GPU-Unterstützung

• ✅ OpenAI-kompatible API

• ✅ Produktionsreif, große Community

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

• ✅ Spekulatives Decoding in v0.7

Nachteile

• ❌ Komplexere Einrichtung

• ❌ Höherer Speicherbedarf 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-Deployment

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ähle 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/sec	Gleichzeitige Nutzer
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 Traffic

• 🎯 Mehrbenutzer-Chatdienste

• 🎯 Bedarf an maximalem Durchsatz

---

Text Generation Inference (TGI)

Überblick

HuggingFaces Produktionsserver, eng integriert ins HF-Ökosystem.

Vorteile

• ✅ Native HuggingFace-Integration

• ✅ Ideal für HF-Modelle

• ✅ Gute Multi-GPU-Unterstützung

• ✅ Eingebaute Sicherheitsfunktionen

• ✅ Prometheus-Metriken

• ✅ Gut dokumentiert

Nachteile

• ❌ Etwas niedrigerer 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 geschützte 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/sec	Gleichzeitige Nutzer
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

• 🎯 Bedarf an eingebauten Sicherheitsfunktionen

• 🎯 Bedarf an Prometheus-Monitoring

---

LocalAI

Überblick

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

Vorteile

• ✅ Multimodale Unterstützung (LLM, TTS, STT, Embeddings)

• ✅ Drop-in-Ersatz für OpenAI

• ✅ Vorgefertigte Modelle verfügbar

• ✅ Unterstützt GGUF-Modelle

• ✅ Reranking-Unterstützung

• ✅ Swagger-UI-Dokumentation

Nachteile

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

• ❌ Niedrigerer LLM-Durchsatz als vLLM/SGLang

• ❌ Bildgenerierung kann CUDA-Probleme haben

• ❌ Komplexer für reinen LLM-Einsatz

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

• 🎯 Bedarf an mehreren Modalitäten (TTS, STT, LLM)

• 🎯 Möchten OpenAI-API-Kompatibilität

• 🎯 Ausführen von GGUF-Modellen

• 🎯 Dokument-Reranking-Workflows

---

Leistungsvergleich (2025)

Durchsatz (Token/Sekunde) — Einzelner Nutzer

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 Nutzer (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	6GB	6GB	7GB
Llama 3.1 70B (Q4)	38GB	40GB	39GB	42GB

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

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

---

Funktionsvergleich

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

---

Wann man was verwenden sollte

Verwende Ollama, wenn:

• Du in 5 Minuten loslegen möchtest

• Du prototypisierst oder lernst

• Du einen persönlichen KI-Assistenten brauchst

• Du auf Mac oder Windows arbeitest

• Einfachheit wichtiger ist als Geschwindigkeit

Verwende SGLang, wenn:

• Du die absolut niedrigste Latenz (TTFT)

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

• Du Workloads mit starker Prefix-Sharing brauchst (RAG, System-Prompts)

• Du Spitzen-Durchsatz in den 2025-Benchmarks benötigst

• Du modernste Optimierungen willst (Radix-Attention)

Verwende vLLM, wenn:

• Du maximalen Durchsatz mit einem reifen, gut unterstützten Framework brauchst

• Du viele Nutzer in großem Maßstab bedienst

• Du Produktionszuverlässigkeit mit großer Community brauchst

• Du einen OpenAI-Drop-in-Ersatz möchtest

• Du Multi-GPU-Setups hast

• Du breite Modellformat-Unterstützung brauchst (AWQ, GPTQ, FP8)

Verwende TGI, wenn:

• Du im HuggingFace-Ökosystem bist

• Du eingebaute Sicherheitsfunktionen brauchst

• Du detaillierte Prometheus-Metriken möchtest

• Du HF-Modelle direkt bereitstellen musst

• Du in einer Forschungsumgebung arbeitest

Verwende LocalAI, wenn:

• Du TTS und STT neben LLM brauchst

• Du Embeddings für RAG möchtest

• Du Dokument-Reranking brauchst

• Du eine einzige All-in-One-Lösung willst

• Du sprachgesteuerte Apps entwickelst

---

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 - einfach 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 – einfach die Endpoint-URL ändern. Die APIs sind vollständig kompatibel.

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

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

---

Empfehlungen nach GPU

GPU	Einzelner Nutzer	Mehrere Nutzer	Reasoning-Modelle
RTX 3060 12GB	Ollama	Ollama	Ollama
RTX 3090 24GB	Ollama	vLLM	SGLang
RTX 4090 24GB	SGLang/vLLM	SGLang/vLLM	SGLang
A100 40GB+	SGLang	SGLang	SGLang

---

Nächste Schritte

• Ollama-Anleitung - Einfachste Einrichtung

• vLLM-Leitfaden - Höchster Durchsatz

• LocalAI-Leitfaden - Multimodale Unterstützung

• DeepSeek-R1-Leitfaden - Reasoning-Modelle

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

• API-Integration - Anwendungen erstellen