> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/vergleiche/llm-serving-comparison.md).

# 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.

{% hint style="success" %}
Alle Optionen verfügbar auf [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

## Kurzanleitung zur Entscheidung

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

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

{% hint style="info" %}
HTTP-502-Fehler während des Starts sind normal – der Dienst initialisiert noch.
{% endhint %}

***

## Ü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

```bash
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

```bash
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

```python
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

```bash
# 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

```bash
# 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

```python
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

```python
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

```bash
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

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

### API-Nutzung

```python
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

```bash
# 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

```bash
# 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

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

### API-Nutzung

```python
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

```python
# 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.

```bash
# 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](/guides/guides_v2-de/sprachmodelle/ollama.md) - Einfachste Einrichtung
* [vLLM-Anleitung](/guides/guides_v2-de/sprachmodelle/vllm.md) - Höchster Durchsatz
* [LocalAI-Anleitung](/guides/guides_v2-de/sprachmodelle/localai-openai-compatible.md) - Unterstützung für multimodale Eingaben
* [DeepSeek-R1-Anleitung](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md) - Reasoning-Modelle
* [Multi-GPU-Einrichtung](/guides/guides_v2-de/fortgeschritten/multi-gpu-setup.md) - Skalierung auf größere Modelle
* [API-Integration](/guides/guides_v2-de/fortgeschritten/api-integration.md) - Anwendungen erstellen


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/vergleiche/llm-serving-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.