> 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-Serving: Ollama vs vLLM vs TGI

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

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

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

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

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

***

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

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

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

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

```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': 'Hello!'}
    ]
})
```

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

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

```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ähle 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/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

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

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

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

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

```bash
# 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](/guides/guides_v2-de/sprachmodelle/ollama.md) - Einfachste Einrichtung
* [vLLM-Leitfaden](/guides/guides_v2-de/sprachmodelle/vllm.md) - Höchster Durchsatz
* [LocalAI-Leitfaden](/guides/guides_v2-de/sprachmodelle/localai-openai-compatible.md) - Multimodale Unterstützung
* [DeepSeek-R1-Leitfaden](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md) - Reasoning-Modelle
* [Multi-GPU-Setup](/guides/guides_v2-de/erweitert/multi-gpu-setup.md) - Skalierung auf größere Modelle
* [API-Integration](/guides/guides_v2-de/erweitert/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:

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

The question should be specific, self-contained, and written in natural language.
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.