> 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/erste-schritte/model-compatibility.md).

# Modellkompatibilität

Vollständiger Leitfaden, welche KI-Modelle auf welchen GPUs auf CLORE.AI laufen.

{% hint style="success" %}
Finde GPUs mit dem richtigen VRAM auf [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Schnellreferenz

### Sprachmodelle (LLM)

| Modell                  | Parameter | Min. VRAM  | Empfohlen              | Quantisierung             |
| ----------------------- | --------- | ---------- | ---------------------- | ------------------------- |
| Llama 3.2               | 1B        | 2GB        | 4GB                    | Q4, Q8, FP16              |
| Llama 3.2               | 3B        | 4GB        | 6GB                    | Q4, Q8, FP16              |
| Llama 3.1/3             | 8B        | 6GB        | 12GB                   | Q4, Q8, FP16              |
| Mistral                 | 7B        | 6GB        | 12GB                   | Q4, Q8, FP16              |
| Qwen 2.5                | 7B        | 6GB        | 12GB                   | Q4, Q8, FP16              |
| Qwen 2.5                | 14B       | 12GB       | 16GB                   | Q4, Q8                    |
| Qwen 2.5                | 32B       | 20GB       | 24GB                   | Q4, Q8                    |
| Llama 3.1               | 70B       | 40GB       | 48GB                   | Q4, Q8                    |
| Qwen 2.5                | 72B       | 48GB       | 80GB                   | Q4, Q8                    |
| Mixtral                 | 8x7B      | 24GB       | 48GB                   | Q4                        |
| DeepSeek-V3             | 671B      | 320GB+     | 640GB                  | FP8                       |
| **DeepSeek-R1**         | **671B**  | **320GB+** | **8x H100**            | **FP8, Reasoning-Modell** |
| **DeepSeek-R1-Distill** | **32B**   | **20GB**   | **2x A100 / RTX 5090** | **Q4/Q8**                 |

### Bildgenerierungsmodelle

| Modell               | Min. VRAM | Empfohlen           | Hinweise                                 |
| -------------------- | --------- | ------------------- | ---------------------------------------- |
| SD 1.5               | 4GB       | 8GB                 | 512x512 nativ                            |
| SD 2.1               | 6GB       | 8GB                 | 768x768 nativ                            |
| SDXL                 | 8GB       | 12GB                | 1024x1024 nativ                          |
| SDXL Turbo           | 8GB       | 12GB                | 1–4 Schritte                             |
| **SD3.5 Large (8B)** | **16GB**  | **24GB**            | **1024x1024, fortgeschrittene Qualität** |
| FLUX.1 schnell       | 12GB      | 16GB                | 4 Schritte, schnell                      |
| FLUX.1 dev           | 16GB      | 24GB                | 20–50 Schritte                           |
| **TRELLIS**          | **16GB**  | **24GB (RTX 4090)** | **3D-Generierung aus Bildern**           |

### Videogenerierungsmodelle

| Modell                 | Min. VRAM | Empfohlen                | Ausgabe                           |
| ---------------------- | --------- | ------------------------ | --------------------------------- |
| Stable Video Diffusion | 16GB      | 24GB                     | 4 Sek., 576x1024                  |
| AnimateDiff            | 12GB      | 16GB                     | 2–4 Sek.                          |
| **LTX-Video**          | **16GB**  | **24GB (RTX 4090/3090)** | **5 Sek., 768x512, sehr schnell** |
| Wan2.1                 | 24GB      | 40GB                     | 5 Sek., 480p–720p                 |
| Hunyuan Video          | 40GB      | 80GB                     | 5 Sek., 720p                      |
| OpenSora               | 24GB      | 40GB                     | Variabel                          |

### Audio-Modelle

| Modell           | Min. VRAM | Empfohlen | Aufgabe          |
| ---------------- | --------- | --------- | ---------------- |
| Whisper tiny     | 1GB       | 2GB       | Transkription    |
| Whisper base     | 1GB       | 2GB       | Transkription    |
| Whisper small    | 2GB       | 4GB       | Transkription    |
| Whisper medium   | 4GB       | 6GB       | Transkription    |
| Whisper large-v3 | 6GB       | 10GB      | Transkription    |
| Bark             | 8GB       | 12GB      | Text-zu-Sprache  |
| Stable Audio     | 8GB       | 12GB      | Musikgenerierung |

### Vision- & Vision-Language-Modelle

| Modell               | Min. VRAM | Empfohlen           | Aufgabe                   |
| -------------------- | --------- | ------------------- | ------------------------- |
| Llama 3.2 Vision 11B | 12GB      | 16GB                | Bildverstehen             |
| Llama 3.2 Vision 90B | 48GB      | 80GB                | Bildverstehen             |
| LLaVA 7B             | 8GB       | 12GB                | Visuelle QA               |
| LLaVA 13B            | 16GB      | 24GB                | Visuelle QA               |
| **Qwen2.5-VL 7B**    | **16GB**  | **24GB (RTX 4090)** | **Bild/Video/Doc OCR**    |
| **Qwen2.5-VL 72B**   | **48GB**  | **2x A100 80GB**    | **Maximale VL-Fähigkeit** |

### Fine-Tuning- & Training-Tools

| Tool / Methode       | Min. VRAM | Empfohlene GPU    | Aufgabe                                 |
| -------------------- | --------- | ----------------- | --------------------------------------- |
| **Unsloth QLoRA 7B** | **12GB**  | **RTX 3090 24GB** | **2× schnelleres QLoRA, geringer VRAM** |
| Unsloth QLoRA 13B    | 16GB      | RTX 4090 24GB     | Schnelles Fine-Tuning                   |
| LoRA (standard)      | 12GB      | RTX 3090          | Parameter-effizientes Fine-Tuning       |
| Full Fine-Tune 7B    | 40GB      | A100 40GB         | Maximale Trainingsqualität              |

***

## Detaillierte Kompatibilitätstabellen

### LLM nach GPU

| GPU              | Max. Modell (Q4) | Max. Modell (Q8) | Max. Modell (FP16) |
| ---------------- | ---------------- | ---------------- | ------------------ |
| RTX 3060 12GB    | 13B              | 7B               | 3B                 |
| RTX 3070 8GB     | 7B               | 3B               | 1B                 |
| RTX 3080 10GB    | 7B               | 7B               | 3B                 |
| RTX 3090 24GB    | 30B              | 13B              | 7B                 |
| RTX 4070 Ti 12GB | 13B              | 7B               | 3B                 |
| RTX 4080 16GB    | 14B              | 7B               | 7B                 |
| RTX 4090 24GB    | 30B              | 13B              | 7B                 |
| RTX 5090 32GB    | 70B              | 14B              | 13B                |
| A100 40GB        | 70B              | 30B              | 14B                |
| A100 80GB        | 70B              | 70B              | 30B                |
| H100 80GB        | 70B              | 70B              | 30B                |

### Bildgenerierung nach GPU

| GPU              | SD 1.5 | SDXL   | FLUX schnell | FLUX dev |
| ---------------- | ------ | ------ | ------------ | -------- |
| RTX 3060 12GB    | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 3070 8GB     | ✅ 512  | ⚠️ 512 | ❌            | ❌        |
| RTX 3080 10GB    | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 3090 24GB    | ✅ 768  | ✅ 1024 | ✅ 1024       | ⚠️ 768\* |
| RTX 4070 Ti 12GB | ✅ 512  | ✅ 768  | ⚠️ 512\*     | ❌        |
| RTX 4080 16GB    | ✅ 768  | ✅ 1024 | ✅ 768        | ⚠️ 512\* |
| RTX 4090 24GB    | ✅ 1024 | ✅ 1024 | ✅ 1024       | ✅ 1024   |
| RTX 5090 32GB    | ✅ 1024 | ✅ 1024 | ✅ 1536       | ✅ 1536   |
| A100 40GB        | ✅ 1024 | ✅ 1024 | ✅ 1024       | ✅ 1024   |
| A100 80GB        | ✅ 2048 | ✅ 2048 | ✅ 1536       | ✅ 1536   |

\*Mit CPU-Offload oder verringerter Batch-Größe

### Videogenerierung nach GPU

| GPU           | SVD    | AnimateDiff | Wan2.1  | Hunyuan |
| ------------- | ------ | ----------- | ------- | ------- |
| RTX 3060 12GB | ❌      | ⚠️ kurz     | ❌       | ❌       |
| RTX 3090 24GB | ✅ 2–4s | ✅           | ⚠️ 480p | ❌       |
| RTX 4090 24GB | ✅ 4s   | ✅           | ✅ 480p  | ⚠️ kurz |
| RTX 5090 32GB | ✅ 6s   | ✅           | ✅ 720p  | ✅ 5s    |
| A100 40GB     | ✅ 4s   | ✅           | ✅ 720p  | ✅ 5s    |
| A100 80GB     | ✅ 8s   | ✅           | ✅ 720p  | ✅ 10s   |

***

## Quantisierungsleitfaden

### Was ist Quantisierung?

Quantisierung reduziert die Modellpräzision, um weniger VRAM zu benötigen:

| Format   | Bits | VRAM-Reduktion | Qualitätsverlust |
| -------- | ---- | -------------- | ---------------- |
| FP32     | 32   | Basislinie     | Keine            |
| FP16     | 16   | 50%            | Minimal          |
| BF16     | 16   | 50%            | Minimal          |
| FP8      | 8    | 75%            | Klein            |
| Q8       | 8    | 75%            | Klein            |
| Q6\_K    | 6    | 81%            | Klein            |
| Q5\_K\_M | 5    | 84%            | Mäßig            |
| Q4\_K\_M | 4    | 87%            | Mäßig            |
| Q3\_K\_M | 3    | 91%            | Deutlich         |
| Q2\_K    | 2    | 94%            | Signifikant      |

### VRAM-Rechner

**Formel:** `VRAM (GB) ≈ Parameter (B) × Bytes pro Parameter`

| Modellgröße | FP16   | Q8    | Q4     |
| ----------- | ------ | ----- | ------ |
| 1B          | 2 GB   | 1 GB  | 0,5 GB |
| 3B          | 6 GB   | 3 GB  | 1,5 GB |
| 7B          | 14 GB  | 7 GB  | 3,5 GB |
| 8B          | 16 GB  | 8 GB  | 4 GB   |
| 13B         | 26 GB  | 13 GB | 6,5 GB |
| 14B         | 28 GB  | 14 GB | 7 GB   |
| 30B         | 60 GB  | 30 GB | 15 GB  |
| 32B         | 64 GB  | 32 GB | 16 GB  |
| 70B         | 140 GB | 70 GB | 35 GB  |
| 72B         | 144 GB | 72 GB | 36 GB  |

\*Ca. 20% für KV-Cache und Overhead hinzufügen

### Empfohlene Quantisierung nach Anwendungsfall

| Einsatzgebiet       | Empfohlen | Warum                                         |
| ------------------- | --------- | --------------------------------------------- |
| Chat/Allgemein      | Q4\_K\_M  | Gute Balance aus Geschwindigkeit und Qualität |
| Programmierung      | Q5\_K\_M+ | Bessere Genauigkeit für Code                  |
| Kreatives Schreiben | Q4\_K\_M  | Geschwindigkeit ist wichtiger                 |
| Analyse             | Q6\_K+    | Höhere Präzision erforderlich                 |
| Produktion          | FP16/BF16 | Maximale Qualität                             |

***

## Kontextlänge vs. VRAM

### Wie Kontext den VRAM beeinflusst

Jedes Modell hat ein Kontextfenster (max. Tokens). Längerer Kontext = mehr VRAM:

| Modell       | Standardkontext | Maximaler Kontext | VRAM pro 1K Tokens |
| ------------ | --------------- | ----------------- | ------------------ |
| Llama 3 8B   | 8K              | 128K              | \~0,3 GB           |
| Llama 3 70B  | 8K              | 128K              | \~0,5 GB           |
| Qwen 2.5 7B  | 8K              | 128K              | \~0,25 GB          |
| Mistral 7B   | 8K              | 32K               | \~0,25 GB          |
| Mixtral 8x7B | 32K             | 32K               | \~0,4 GB           |

### Kontext nach GPU (Llama 3 8B Q4)

| GPU           | Angenehmer Kontext | Maximaler Kontext |
| ------------- | ------------------ | ----------------- |
| RTX 3060 12GB | 16K                | 32K               |
| RTX 3090 24GB | 64K                | 96K               |
| RTX 4090 24GB | 64K                | 96K               |
| RTX 5090 32GB | 96K                | 128K              |
| A100 40GB     | 96K                | 128K              |
| A100 80GB     | 128K               | 128K              |

***

## Multi-GPU-Konfigurationen

### Tensor-Parallele Verarbeitung

Teile ein Modell über mehrere GPUs auf:

| Konfiguration | Gesamter VRAM | Max. Modell (FP16) |
| ------------- | ------------- | ------------------ |
| 2x RTX 3090   | 48GB          | 30B                |
| 2x RTX 4090   | 48GB          | 30B                |
| 2x RTX 5090   | 64GB          | 32B                |
| 4x RTX 5090   | 128GB         | 70B                |
| 2x A100 40GB  | 80GB          | 70B                |
| 4x A100 40GB  | 160GB         | 100B+              |
| 8x A100 80GB  | 640GB         | DeepSeek-V3        |

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

***

## Spezifische Modellanleitungen

### Llama 3.1 Familie

| Variante       | Parameter | Min. GPU     | Empfohlene Konfiguration |
| -------------- | --------- | ------------ | ------------------------ |
| Llama 3.2 1B   | 1B        | Jede 4GB     | RTX 3060                 |
| Llama 3.2 3B   | 3B        | Jede 6GB     | RTX 3060                 |
| Llama 3.1 8B   | 8B        | RTX 3060     | RTX 3090                 |
| Llama 3.1 70B  | 70B       | A100 40GB    | 2x A100 40GB             |
| Llama 3.1 405B | 405B      | 8x A100 80GB | 8x H100                  |

### Mistral/Mixtral Familie

| Variante      | Parameter | Min. GPU     | Empfohlene Konfiguration |
| ------------- | --------- | ------------ | ------------------------ |
| Mistral 7B    | 7B        | RTX 3060     | RTX 3090                 |
| Mixtral 8x7B  | 46,7B     | RTX 3090     | A100 40GB                |
| Mixtral 8x22B | 141B      | 2x A100 80GB | 4x A100 80GB             |

### Qwen 2.5 Familie

| Variante      | Parameter | Min. GPU  | Empfohlene Konfiguration |
| ------------- | --------- | --------- | ------------------------ |
| Qwen 2.5 0.5B | 0.5B      | Jede 2GB  | Jede 4GB                 |
| Qwen 2.5 1.5B | 1.5B      | Jede 4GB  | RTX 3060                 |
| Qwen 2.5 3B   | 3B        | Jede 6GB  | RTX 3060                 |
| Qwen 2.5 7B   | 7B        | RTX 3060  | RTX 3090                 |
| Qwen 2.5 14B  | 14B       | RTX 3090  | RTX 4090                 |
| Qwen 2.5 32B  | 32B       | RTX 4090  | A100 40GB                |
| Qwen 2.5 72B  | 72B       | A100 40GB | A100 80GB                |

### DeepSeek-Modelle

| Variante                         | Parameter | Min. GPU          | Empfohlene Konfiguration |
| -------------------------------- | --------- | ----------------- | ------------------------ |
| DeepSeek-Coder 6.7B              | 6.7B      | RTX 3060          | RTX 3090                 |
| DeepSeek-Coder 33B               | 33B       | RTX 4090          | A100 40GB                |
| DeepSeek-V2-Lite                 | 15.7B     | RTX 3090          | A100 40GB                |
| DeepSeek-V3                      | 671B      | 8x A100 80GB      | 8x H100                  |
| **DeepSeek-R1**                  | **671B**  | **8x A100 80GB**  | **8x H100 (FP8)**        |
| **DeepSeek-R1-Distill-Qwen-32B** | **32B**   | **RTX 5090 32GB** | **2x A100 40GB**         |
| **DeepSeek-R1-Distill-Qwen-7B**  | **7B**    | **RTX 3090 24GB** | **RTX 4090**             |

***

## Fehlerbehebung

### "CUDA out of memory"

1. **Reduziere Quantisierung:** Q8 → Q4
2. **Verringere Kontextlänge:** Reduziere max\_tokens
3. **Aktiviere CPU-Offload:** `--cpu-offload` oder `enable_model_cpu_offload()`
4. **Verwende kleinere Batch:** batch\_size=1
5. **Probiere eine andere GPU:** Braucht mehr VRAM

### "Modell zu groß"

1. **Verwende quantisierte Version:** GGUF Q4-Modelle
2. **Verwende mehrere GPUs:** Tensor-Parallele Verarbeitung
3. **Offload zur CPU:** Langsamer, funktioniert aber
4. **Wähle ein kleineres Modell:** 7B statt 13B

### "Langsame Generierung"

1. **Upgrade der GPU:** Mehr VRAM = weniger Offload
2. **Verwende schnellere Quantisierung:** Q4 ist schneller als Q8
3. **Reduziere Kontext:** Kürzer = schneller
4. **Aktiviere Flash-Attention:** `--flash-attn`

## Nächste Schritte

* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) - Detaillierte GPU-Spezifikationen
* [Docker-Images-Katalog](/guides/guides_v2-de/erste-schritte/docker-images.md) - Bereit zum Bereitstellen Images
* [Schnellstart-Anleitung](/guides/guides_v2-de/quickstart.md) - Starte in 5 Minuten


---

# 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/erste-schritte/model-compatibility.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.