'Betreib es einfach lokal" ist das Tech-Äquivalent von 'bau dir dein Gemüse einfach selbst an." Manchmal spart es ein Vermögen. Meistens kostet es mehr, macht mehr Arbeit und liefert schlechtere Ergebnisse. Aber man hört es überall — auf Twitter, auf Reddit, vom Kumpel mit dem Homeserver im Keller. Also lassen wir die heißen Takes weg und schauen auf echte Zahlen. 🔍

Die eigentliche Frage ist nicht soll ich selbst hosten. Sondern: Ab welchem Volumen wird Self-Hosting günstiger — und sind die Kompromisse überhaupt relevant für das, was du baust?

Was wir vergleichen

Cloud AI bedeutet: Du zahlst pro Nutzung. Jedes Mal, wenn deine App Text an Claude, GPT oder Gemini schickt, zahlst du für die Tokens — Wort-Häppchen, die die KI verarbeitet, grob ¾ eines englischen Worts. Stell dir das wie ein Taxameter vor: Kurzstrecke ist billig, Langstrecke läppert sich.

Self-hosted AI bedeutet: Du betreibst ein Open-Source-LLM (Large Language Model — das Gehirn hinter Tools wie ChatGPT) auf eigener Hardware. Du zahlst für die Maschine und den Strom, aber danach ist jede Anfrage kostenlos. Wie ein Auto kaufen: teuer am Anfang, aber kein Fahrpreis pro Strecke.

Hier die aktuellen Cloud-Preise (Stand März 2026), pro Million Tokens:

Anbieter Modell Input / Output Kosten
Anthropic Haiku 4.5 $1 / $5
Anthropic Sonnet 4.6 $3 / $15
Anthropic Opus 4.6 $5 / $25
OpenAI GPT-4o mini $0.15 / $0.60
OpenAI GPT-4o $2.50 / $10
Google Gemini Flash Gratis-Tier (15 Req/Min)
Google Gemini Pro $1.25 / $5

Und die Self-Hosted-Kandidaten: Ollama mit Open-Source-Modellen wie Llama 3.1, Mistral oder DeepSeek auf dem eigenen Rechner oder einem gemieteten GPU-Server.

Der fundamentale Tradeoff: Cloud berechnet pro Nutzung, Self-Hosted pro Zeit. Bei geringer Nutzung gewinnt die Cloud, weil du nur zahlst, was du verbrauchst. Bei hoher Nutzung gewinnt Self-Hosting, weil die Hardwarekosten fix sind. Wir müssen den Schnittpunkt finden. 💰

Die Kostenrechnung, die dir keiner zeigt

Cloud-Kosten bei Skalierung

Claude Haiku 4.5 als Baseline (günstigstes Cloud-Modell mit brauchbarer Qualität), bei einem typischen 30/70-Split Input/Output-Tokens:

Tägliche Tokens Monatliche Kosten Jährliche Kosten
10K $0,90 $10,80
100K $9 $108
500K $45 $540
1M $90 $1.080
5M $450 $5.400
10M $900 $10.800

Self-Hosted-Kosten

Option A — Hardware, die du schon hast:

Wenn du einen Rechner mit GPU (Grafikkarte, die KI-Berechnungen beschleunigt) besitzt, fallen nur Stromkosten an:

Hardware Modelle, die laufen Monatliche Stromkosten
16 GB RAM, keine GPU 7B-Modelle (langsam) ~$10
RTX 3090 24GB 13B-Modelle (schnell) ~$20
RTX 4090 24GB 13B-30B-Modelle (schnell) ~$25
M2/M3 Mac 32GB+ 7B-13B (gute Geschwindigkeit) ~$5

'7B" und '13B" steht für Milliarden Parameter — die Größe des Modells. Größere Modelle sind schlauer, brauchen aber mehr Speicher.

Option B — GPU-Server mieten:

Anbieter GPU Monatliche Kosten
Hetzner (nur CPU) Keine ~$50
Vast.ai RTX 3090 ~$150
Vast.ai RTX 4090 ~$250
Lambda A10G ~$350
RunPod A100 40GB ~$800

Option C — Homeserver kaufen:

Build Anschaffungskosten Monatlich (auf 3 Jahre)
Gebrauchte RTX 3090 + Basic-PC ~$1.200 ~$33 + Strom
RTX 4090 + ordentlicher PC ~$2.500 ~$70 + Strom
2× RTX 4090 ~$4.500 ~$125 + Strom
Mac Studio M3 Ultra 192GB ~$6.000 ~$167 + Strom

Wo sich die Linien kreuzen

Cloud Haiku vs. lokales 7B auf vorhandener Hardware:

Self-Hosted kostet ~$15/Monat Strom. Cloud Haiku überschreitet das bei etwa 5 Millionen Tokens pro Monat. Darunter — und die meisten Solo-Gründer liegen deutlich darunter — ist die Cloud günstiger.

Cloud Haiku vs. gemieteter GPU-Server (RTX 3090 für $150/Monat):

Du musst 50 Millionen Tokens pro Monat durchjagen, bevor sich der gemietete Server rentiert. Das sind 1,7 Millionen Tokens täglich — ein ernsthafter Production-Workload.

Für die meisten Indie-Builder und kleine Teams kosten Cloud-APIs weniger als Self-Hosting auf dedizierter Hardware. Punkt.

Die Qualitätslücke

Kosten sind nur die halbe Wahrheit. So performen die Modelle tatsächlich:

Fähigkeit Cloud (Claude/GPT) Self-Hosted (7B-13B)
Reasoning-Qualität Exzellent Mittelmaß
Code-Generierung Exzellent Gut für einfache Tasks
Context Window 200K–1M Tokens Typisch 4K–32K
Speed 50–100+ Tok/Sek 20–40 (GPU), 5–10 (CPU)
Tool Use Nativ, zuverlässig Möglich, weniger zuverlässig

Context Window — wie viel Text die KI gleichzeitig 'sehen" kann, quasi ihr Arbeitsspeicher — ist die größte Lücke. Cloud-Modelle verarbeiten ganze Codebases. Lokale Modelle sehen ein paar Seiten auf einmal.

Llama 3.1 70B ist wirklich beeindruckend und bei allgemeinen Aufgaben konkurrenzfähig. Aber es braucht ordentlich GPU-Power, und es gibt immer noch kein lokales Äquivalent zu Opus oder Top-Tier-GPT für komplexes Reasoning. Die Lücke ist kleiner geworden. Geschlossen ist sie nicht.

Wann Self-Hosting wirklich Sinn ergibt

1. Datenschutz und Datenhoheit

Wenn deine Daten das eigene Netzwerk nicht verlassen dürfen — Patientenakten, Rechtsunterlagen, Finanzdaten, Behördensysteme — ist Self-Hosting keine Option, sondern Pflicht. Keine API-Nutzungsbedingung der Welt ersetzt 'die Daten haben unser Haus nie verlassen." Gerade mit der DSGVO im Rücken ein starkes Argument.

# Ollama macht das zum 2-Minuten-Setup
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Fasse diese Patientenakte zusammen..."
}'

Kein Netzwerk-Request. Kein Logging bei Dritten. Volle Compliance.

2. Offline-Umgebungen

Edge-Devices, Air-Gapped-Netzwerke, abgelegene Standorte ohne Internet. Keine Verbindung heißt keine API — lokal ist die einzige Option.

3. Hohe Volumina bei einfachen Tasks

Embeddings — numerische Fingerabdrücke von Text für die Suche — Klassifizierung und Kurztext-Zusammenfassungen. Aufgaben, bei denen ein kleines Modell reicht und das Volumen riesig ist: ⚡

import ollama

def classify_document(text: str) -> str:
    response = ollama.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': f'Klassifiziere: Rechnung, Vertrag, Quittung, Brief, Sonstiges.\n\n{text[:500]}'}
    ])
    return response['message']['content']

# 100K Dokumente/Tag:
# Cloud-Kosten: ~$30/Tag
# Self-Hosted: ~$0,50/Tag Strom
# Monatliche Ersparnis: ~$900

4. Latenz-sensitive Apps

API-Calls bringen 100–500ms Netzwerkverzögerung mit. Lokale Inference — der Prozess, bei dem das Modell eine Antwort generiert — startet sofort:

Cloud:  150-500ms Netzwerk + 500-2000ms Inference = 650-2500ms
Lokal:  0ms Netzwerk + 200-1000ms Inference = 200-1000ms

Bei Autocomplete, Live-Übersetzung oder interaktiven Tools spürt man den Unterschied.

5. Entwicklung und Experimente

50 Prompt-Variationen lokal testen kostet $0. Dasselbe Experiment über die Claude API: $5–20. Nicht die Welt, aber es summiert sich bei intensiver R&D.

Das praktische Setup (10 Minuten)

Wenn du entschieden hast, dass Self-Hosting für deinen Use Case passt:

Ollama installieren

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

ollama pull llama3.1:8b          # 4,7 GB, Allzweck
ollama pull codellama:13b         # 7,4 GB, Code-Aufgaben
ollama pull nomic-embed-text      # 274 MB, für Embeddings

Als Drop-in-Replacement nutzen

Ollama spricht dieselbe Sprache wie OpenAIs API. Der meiste Code funktioniert ohne Änderungen — einfach die URL tauschen:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "Erkläre MCP in 3 Sätzen"}]
)
print(response.choices[0].message.content)

Lokal entwickeln, in der Cloud deployen — oder umgekehrt. Gleicher Code, andere URL.

Performance-Benchmarks

Hardware Tokens/Sek 500-Token-Antwort
M2 MacBook Pro 16GB ~35 ~14 Sekunden
RTX 3060 12GB ~40 ~12 Sekunden
RTX 4090 24GB ~80 ~6 Sekunden
Nur CPU (16 Kerne) ~8 ~60 Sekunden

CPU-only Inference ist für alles Interaktive eine Qual. Keine GPU oder Apple Silicon? Bleib bei der Cloud.

Der Hybrid-Ansatz (das ist der Move) 🚀

Das smarteste Setup ist weder rein Cloud noch rein Self-Hosted. Es routet jede Aufgabe an den richtigen Ort:

def get_ai_client(task_type: str):
    if task_type in ["embedding", "classification", "simple_summary"]:
        # Lokal — schnell, kostenlos, Qualität reicht
        return OpenAI(base_url="http://localhost:11434/v1", api_key="x")
    elif task_type in ["code_generation", "complex_analysis", "tool_use"]:
        # Cloud — bessere Qualität, lohnt sich
        return anthropic.Anthropic()
    else:
        return OpenAI(base_url="http://localhost:11434/v1", api_key="x")

Läuft lokal: Embeddings, Klassifizierung, Draft-Generierung, Dev/Testing. Läuft in der Cloud: Komplexes Reasoning, Code-Generierung, Tool Use, alles Kundennahe.

Reales Kostenbeispiel für ein Hybrid-Setup:

Aufgabe Volumen Wo Monatliche Kosten
Embeddings 50K/Tag Lokal $0
Klassifizierung 10K/Tag Lokal $0
Code Review 30/Tag Cloud (Haiku) $2
Content-Generierung 50/Tag Cloud (Sonnet) $15
Komplexe Analyse 10/Tag Cloud (Sonnet) $5
Gesamt $22/Mo

Rein Cloud für denselben Workload: ~$180/Monat. Der Hybrid spart 88%.

Entscheidungs-Cheatsheet

Verarbeitest du über 5M Tokens täglich? → Volume-Tasks selbst hosten, Cloud für Qualitäts-Tasks.

Strenge Datenschutz-Anforderungen (DSGVO & Co.)? → Self-Hosting, nicht verhandelbar.

Hast du schon GPU-Hardware? → Hybrid: Lokal für Einfaches, Cloud für Komplexes.

Nichts davon? → Nur Cloud. Ist günstiger und gibt dir die besten Modelle.

Für die meisten Solo-Gründer im März 2026 gilt: Fang mit der Cloud an. Claude Haiku für $1/$5 pro Million Tokens ist so billig, dass Self-Hosting zum Geldsparen wie Weizen anbauen ist, um beim Brot zu sparen. Die Hardware kostet mehr als Jahre an API-Nutzung bei typischem Gründer-Volumen. 💰

Die Ausnahme: Du hast Datenschutz-Anforderungen oder besitzt schon eine GPU. Dann installier Ollama, lauf Llama 3.1 für Massenaufgaben und ruf Claude für die harten Probleme. Dieser Hybrid drückt die Kosten um 80%+ und behält die Qualität dort, wo es zählt. Alles andere ist Over-Engineering. 🦝