Zum Inhalt springen
LLM Pricing Calc
GPU-Mietpreise

LLM VRAM Rechner: Wie viel GPU-Speicher brauchen Sie?

Prüfen Sie die Hardware-Anforderungen für ein lokales LLM: Speicherbedarf aufgeteilt in Gewichte, KV-Cache und Overhead, plus welche Consumer-GPUs, Macs und Cloud-GPUs es ausführen können.

Quantisierung
Kontextlänge
KV-Cache

Benötigter VRAM gesamt

49.1 GB

Llama 3.3 70B Instruct · Q4_K_M · 8K Kontext · 1 Nutzer

KV-Cache: 320 KB / Token

Modellgewichte
42.8 GB
KV-Cache
2.68 GB
Laufzeit-Overhead
3.57 GB
Hardware-Kompatibilität
HardwareNutzbarer SpeicherPasstTempo (geschätzt)Cloud $/h
RTX 4060 Ti 16GBConsumer-GPU16 GBBenötigt 4×~17 tok/s—
RTX 3090 24GBConsumer-GPU24 GBBenötigt 3×~43 tok/s$0.66
RTX 4090 24GBConsumer-GPU24 GBBenötigt 3×~46 tok/s$1.02
RTX 5090 32GBConsumer-GPU32 GBBenötigt 2×~54 tok/s$1.38
MacBook Pro M4 Max 64GBApple Silicon48 GBPasst nicht——
MacBook Pro M4 Max 128GBApple Silicon96 GBPasst~8 tok/s—
Mac Studio M3 Ultra 512GBApple Silicon384 GBPasst~12 tok/s—
NVIDIA L4 24GBCloud-GPU24 GBBenötigt 3×~14 tok/s$1.32
NVIDIA L40S 48GBCloud-GPU48 GBBenötigt 2×~26 tok/s$1.72
NVIDIA A100 80GBCloud-GPU80 GBPasst~31 tok/s$1.39
NVIDIA H100 80GBCloud-GPU80 GBPasst~51 tok/s$2.39
NVIDIA H200 141GBCloud-GPU141 GBPasst~73 tok/s$3.29
NVIDIA B200 180GBCloud-GPU180 GBPasst~121 tok/s$5.49
AMD MI300X 192GBCloud-GPU192 GBPasst~80 tok/s$2.49

VRAM und Speicherbandbreite sind Herstellerangaben. Stundenpreise sind On-Demand-Preise der RunPod Community Cloud; andere Anbieter und Regionen weichen ab. Der nutzbare Speicher bei Apple Silicon geht vom Standard-GPU-Wired-Limit von macOS aus (~75 % des Unified Memory). „Benötigt Nד bedeutet Tensor-Parallelität über N identische GPUs. GPU-Preise: Offizielle Preise ↗

Ratgeber

Wie viel VRAM braucht man, um ein LLM auszuführen?

Ob ein Modell überhaupt lokal läuft, entscheidet der GPU-Speicher, nicht die Rechenleistung. Passt das Modell nicht in den VRAM, lagern llama.cpp und Ollama Layer in den System-RAM aus, und die Generierung bricht von zig Tokens pro Sekunde auf Schneckentempo ein. Der gesamte VRAM-Bedarf besteht aus drei Teilen:

  • Gewichte = Parameter × Bits pro Gewicht ÷ 8. Q4_K_M liegt im Schnitt bei ~4,85 Bit, Q8_0 bei ~8,5 Bit, FP16 bei 16 Bit.
  • KV-Cache = 2 × Layer × KV-Heads × Head-Dimension × Kontext × Nutzer × Bytes pro Wert. DeepSeeks Multi-Head Latent Attention speichert stattdessen einen komprimierten 576-dimensionalen Latent-Vektor pro Layer, daher ist sein Cache weit kleiner.
  • Overhead ≈ 1 GB CUDA-/Metal-Kontext + ~6 % der Gewichte für Aktivierungen und Scratch-Buffer, plus ein wenig pro zusätzlichem Nutzer.

Modellgewichte und Quantisierung: Q4 vs. Q8 vs. FP16

Die Gewichte sind die Fixkosten. Jeder Parameter muss im Speicher liegen, daher setzt die Modellgröße in Milliarden Parametern die Untergrenze. Quantisierung verkleinert jeden Parameter von 16 Bit auf 8 oder etwa 4 Bit und tauscht ein wenig Genauigkeit gegen einen deutlich kleineren Speicherbedarf. Das bedeutet es für zwei beliebte Llama-Modelle bei 8K Kontext:

VRAM nach Quantisierung für Llama 3.1 8B Instruct und Llama 3.3 70B Instruct bei 8K Kontext
QuantisierungLlama 3.1 8B InstructLlama 3.3 70B Instruct
Q4_K_M (4-Bit)7.21 GB49.1 GB
Q8_0 / FP8 (8-Bit)11.1 GB83.2 GB
FP16 / BF16 (16-Bit)19.0 GB153.4 GB

Q4_K_M ist der Standard für lokale Inferenz mit Ollama und LM Studio: rund 70 % kleiner als FP16, mit einem Qualitätsverlust, den die meisten im Chat nie bemerken. Q8_0 ist nahezu verlustfrei und eine gute Wahl, wenn Sie genug Speicher haben. FP16/BF16 ist das, was Produktionsserver wie vLLM standardmäßig ausführen, und es ist die Basis für Fine-Tuning. Unter etwa 3 Bit pro Gewicht sinkt die Qualität schnell, daher schlägt ein kleineres Modell in Q4 meist ein größeres, das auf Q2 gequetscht wurde.

Wachstum des KV-Cache mit der Kontextlänge

Der KV-Cache ist der variable Kostenfaktor, und er ist es, der viele überrascht. Er speichert Attention-Keys und -Values für jedes Token im Kontextfenster und wächst daher linear mit der Kontextlänge und der Zahl gleichzeitiger Nutzer. Für Llama 3.3 70B Instruct in Q4 belegt der KV-Cache 2.68 GB bei 8K Kontext, 42.9 GB bei 128K und 171.8 GB, wenn vier Nutzer jeweils 128K Kontext halten. Ein Modell, das bei 8K bequem passt, kann bei langem Kontext den Speicher sprengen. Den KV-Cache auf 8 Bit zu quantisieren (die Einstellung „KV-Cache“ oben) halbiert ihn, bei den meisten Workloads mit geringem Qualitätseinfluss.

Dimensionierung: Consumer- vs. Cloud-GPU

Consumer-GPUs (RTX 4060 Ti 16 GB, RTX 3090/4090 24 GB, RTX 5090 32 GB) führen 7B–14B-Modelle in Q8 aus, und die Karten mit 24–32 GB schaffen Modelle der 30B-Klasse in Q4. Llama 3.3 70B Instruct in Q4 braucht etwa 49.1 GB, also 3× RTX 4090. Apple Silicon tauscht Geschwindigkeit gegen Kapazität: Ein Mac mit 128 GB oder mehr kann Modelle der 70B-Klasse und mittelgroße Mixture-of-Experts-Modelle laden, die keine einzelne Consumer-GPU fassen kann, allerdings mit weniger Tokens pro Sekunde, weil Unified Memory weniger Bandbreite hat als GDDR oder HBM. Cloud-GPUs wie L40S (48 GB), A100 und H100 (80 GB) sowie H200 (141 GB) eignen sich für FP16-Serving, lange Kontexte und viele gleichzeitige Nutzer, wo der KV-Cache und nicht die Gewichte den Speicher dominiert.

Lassen Sie 10–15 % Reserve, statt den VRAM bis zum letzten Gigabyte zu füllen; Treiber, Display und Fragmentierung beanspruchen jeweils einen Teil. Wenn Sie ein selbst gehostetes LLM für die Produktion und nicht für ein Hobby-Setup dimensionieren, ist die nächste Frage die der Kosten: Der Rechner LLM-API vs. Self-Hosting vergleicht eine gemietete GPU mit Preisen pro Token, und der LLM-Kostenrechner zeigt, was derselbe Workload bei gehosteten APIs kostet. Gehostete Preise für Open-Weight-Modelle wie Llama, Qwen und DeepSeek finden Sie in der LLM-Preistabelle.

Weitere KI-Kostenrechner

FAQ zum LLM-VRAM

Wie viel VRAM braucht Llama 3.3 70B Instruct?

In Q4_K_M mit 8K Kontext braucht Llama 3.3 70B Instruct insgesamt etwa 49.1 GB: 42.8 GB für Gewichte, 2.68 GB für den KV-Cache und 3.57 GB Overhead. Das ist mehr als jede einzelne Consumer-GPU bietet: Es passt auf eine NVIDIA A100 80GB, NVIDIA H100 80GB, NVIDIA H200 141GB, NVIDIA B200 180GB oder AMD MI300X 192GB, einen MacBook Pro M4 Max 128GB oder Mac Studio M3 Ultra 512GB oder auf 3× RTX 4090 mit Tensor-Parallelität. In FP16 braucht es etwa 153.4 GB, wofür 3× H100 80GB nötig sind.

Wie viel VRAM brauche ich für ein LLM?

Faustregel: Parameter (Milliarden) × Bits pro Gewicht ÷ 8 = GB für die Gewichte. Dazu kommen der KV-Cache, der mit Kontextlänge und gleichzeitigen Nutzern wächst, plus 1–2 GB Laufzeit-Overhead. Ein 70B-Modell in Q4_K_M braucht allein für die Gewichte etwa 43 GB und passt daher nicht auf eine einzelne RTX 4090 mit 24 GB.

Was ist der KV-Cache und warum ist er wichtig?

Der KV-Cache speichert die Attention-Keys und -Values für jedes Token im Kontext, damit sie nicht neu berechnet werden müssen. Seine Größe = 2 × Layer × KV-Heads × Head-Dimension × Kontextlänge × Bytes pro Wert × Nutzer. Bei 128K Kontext kann er größer sein als die Modellgewichte selbst, weshalb Inferenz mit langem Kontext oft am Speicher scheitert.

Welche Quantisierung sollte ich verwenden?

Q4_K_M ist die beliebteste Wahl für lokale Inferenz: etwa 70 % kleiner als FP16 bei geringem Qualitätsverlust. Q8_0 ist nahezu verlustfrei bei halber Größe von FP16. FP16/BF16 ist die ursprüngliche Präzision, die die meisten Produktions-Serving-Stacks wie vLLM nutzen.

Brauchen MoE-Modelle weniger VRAM?

Nein. Mixture-of-Experts-Modelle wie Qwen3-235B-A22B oder gpt-oss-120b müssen alle Experten im Speicher halten, daher hängt der VRAM-Bedarf von der Gesamtzahl der Parameter ab. Nur die Geschwindigkeit profitiert von der kleineren Zahl aktiver Parameter, weil pro Token weniger Gewichte gelesen werden.

Wie viel Unified Memory eines Macs kann die GPU nutzen?

Standardmäßig lässt macOS die GPU etwa 65–75 % des Unified Memory belegen. Dieser Rechner geht von 75 % aus (48 GB auf einem MacBook Pro mit 64 GB, 96 GB bei 128 GB). Sie können das Limit mit sudo sysctl iogpu.wired_limit_mb anheben, auf eigenes Risiko.

Ist das derselbe VRAM-Bedarf wie bei Ollama und llama.cpp?

Annähernd. Ollama und llama.cpp laden GGUF-Dateien, deren Größe bei gleicher Quantisierung dem Gewichte-Wert hier entspricht. Ollama reserviert zusätzlich den KV-Cache für den vollen Kontext, den Sie mit num_ctx festlegen, sowie weitere Kopien, wenn es parallele Anfragen bedient. Stellen Sie daher Kontext und Nutzer passend zu Ihren Ollama-Einstellungen ein. Übersteigt der Gesamtwert Ihren VRAM, lagert Ollama Layer in den System-RAM aus, und die Generierung wird deutlich langsamer.

Wie genau ist die Schätzung der Tokens pro Sekunde?

Es ist eine Schätzung auf Basis der Speicherbandbreite für einen einzelnen Nutzer: Bandbreite × ~65 % Effizienz ÷ Bytes aktiver Gewichte, die pro Token gelesen werden. Die echte Geschwindigkeit hängt von der Inferenz-Engine, der Batch-Größe und davon ab, ob das Modell auf mehrere GPUs verteilt ist. Betrachten Sie den Wert als grobe Richtgröße.