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