Was kostet KI-Entwicklung? Ein ehrlicher Überblick
Warum KI-Projekte so unterschiedlich kosten
Die Frage "Was kostet KI-Entwicklung?" klingt einfach. Die ehrliche Antwort ist: es kommt darauf an, ob du eine API aufrufst oder ein eigenes Modell trainierst. Das ist der Unterschied zwischen "Ich schraube eine Steckdose an" und "Ich baue ein Kraftwerk".
Wir bauen seit 2024 KI-Features in Produktionsanwendungen — mit Next.js, TypeScript, Python/FastAPI und PostgreSQL. In diesem Artikel bekommst du keine Marketing-Floskeln, sondern echte Zahlen, echten Code und echte Architektur-Entscheidungen.
Die aktuelle Preislandschaft: Was LLM-APIs wirklich kosten
Bevor wir über Projektkosten reden, musst du die Rohstoffkosten kennen. Hier sind die aktuellen API-Preise der relevanten Modelle (Stand Q1 2026):
| Modell | Input / 1M Tokens | Output / 1M Tokens | Kontext-Fenster | Sweet Spot | |---|---|---|---|---| | Claude 3.5 Haiku | $0.80 | $4.00 | 200k | Klassifikation, Routing, einfache Tasks | | Claude 3.5 Sonnet | $3.00 | $15.00 | 200k | Coding, komplexe Analyse, RAG | | Claude 3.5 Opus | $15.00 | $75.00 | 200k | Forschung, Multi-Step-Reasoning | | GPT-4o | $2.50 | $10.00 | 128k | Allrounder, multimodal | | GPT-4o-mini | $0.15 | $0.60 | 128k | High-Volume, einfache Tasks | | Gemini 1.5 Pro | $1.25 | $5.00 | 2M | Sehr lange Dokumente, Video | | Gemini 1.5 Flash | $0.075 | $0.30 | 1M | Budget-Tasks, hoher Durchsatz |
Die Preise sinken kontinuierlich. Vor 12 Monaten war GPT-4-Turbo noch bei $10/$30 pro 1M Tokens. Trotzdem: für Production Workloads summieren sich die Kosten schnell.
Konkretes Rechenbeispiel: Support-Ticket-Klassifikation
Nehmen wir einen realen Use Case: 10.000 Support-Tickets pro Monat automatisch klassifizieren (Kategorie, Priorität, Stimmung).
Annahmen:
- Durchschnittliches Ticket: ~200 Tokens Input
- System-Prompt + Few-Shot-Examples: ~300 Tokens
- Output (Klassifikation als JSON): ~50 Tokens
- Gesamt pro Ticket: 500 Input + 50 Output Tokens
Monatliche API-Kosten bei 10.000 Tickets:
| Modell | Input-Kosten | Output-Kosten | Gesamt/Monat | |---|---|---|---| | Claude 3.5 Haiku | 5M × $0.80/1M = $4.00 | 0.5M × $4.00/1M = $2.00 | $6.00 | | GPT-4o-mini | 5M × $0.15/1M = $0.75 | 0.5M × $0.60/1M = $0.30 | $1.05 | | Claude 3.5 Sonnet | 5M × $3.00/1M = $15.00 | 0.5M × $15.00/1M = $7.50 | $22.50 | | GPT-4o | 5M × $2.50/1M = $12.50 | 0.5M × $10.00/1M = $5.00 | $17.50 |
Erkenntnis: Für Klassifikation brauchst du kein Sonnet oder GPT-4o. Haiku oder GPT-4o-mini liefern bei einfachen Tasks >95% Accuracy — für einen Bruchteil der Kosten. Die Modellwahl ist die wichtigste Kostenentscheidung.
Architektur: Die drei Ausbaustufen
Jedes KI-Projekt fällt in eine von drei Stufen. Hier ist die Architektur, wie wir sie tatsächlich bauen:
┌─────────────────────────────────────────────────────────────────────┐
│ KI-PROJEKT ARCHITEKTUR-STUFEN │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ STUFE 1: API-Integration (10–30k €) │
│ ┌──────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Next.js │───▶│ FastAPI │───▶│ LLM API │ │
│ │ Frontend │◀───│ Service │◀───│ (Claude/GPT) │ │
│ └──────────┘ │ + Cache │ └──────────────┘ │
│ │ + Rate Limit │ │
│ └──────────────┘ │
│ │
│ STUFE 2: RAG / Product Features (30–80k €) │
│ ┌──────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Next.js │───▶│ FastAPI │───▶│ LLM API │ │
│ │ Frontend │◀───│ Orchestrator │◀───│ │ │
│ └──────────┘ │ │ └──────────────┘ │
│ │ ┌────────┐ │ ┌──────────────┐ │
│ │ │Embedder│──│───▶│ pgvector / │ │
│ │ └────────┘ │◀───│ Vector DB │ │
│ │ ┌────────┐ │ └──────────────┘ │
│ │ │Eval │ │ ┌──────────────┐ │
│ │ │Pipeline│──│───▶│ PostgreSQL │ │
│ │ └────────┘ │ │ (Logging) │ │
│ └──────────────┘ └──────────────┘ │
│ │
│ STUFE 3: Custom Model (80–250k+ €) │
│ ┌──────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Next.js │───▶│ FastAPI │───▶│ Custom Model │ │
│ │ Frontend │◀───│ Inference │◀───│ (Fine-tuned) │ │
│ └──────────┘ │ Server │ └──────┬───────┘ │
│ └──────────────┘ │ │
│ ┌──────────────┐ ┌──────▼───────┐ │
│ │ Training │───▶│ GPU Cluster │ │
│ │ Pipeline │ │ (A100/H100) │ │
│ │ + MLOps │ └──────────────┘ │
│ └──────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
Stufe 1: API-Integration (10.000 – 30.000 EUR)
Die schnellste Variante. Du rufst ein bestehendes Modell via API auf, baust eine saubere Abstraktionsschicht drum herum, und lieferst dem User ein fertiges Feature. Klingt trivial — die Arbeit steckt im Detail.
Was tatsächlich gebaut wird
Ein typisches Stufe-1-Projekt bei uns enthält:
- API-Abstraktionsschicht mit Retry-Logik, Timeout-Handling, Model-Fallback
- Prompt Management — versionierte Prompts, A/B-Testing-fähig
- Token-Tracking und Cost Monitoring pro User/Feature
- Response-Validierung — LLMs liefern nicht immer valides JSON
- Rate-Limiting und Queue für Fair Use
- Frontend-Integration mit Streaming (SSE) für bessere UX
Hier ein Beispiel, wie ein realer API-Call mit Token-Tracking in TypeScript aussieht:
import Anthropic from "@anthropic-ai/sdk";
interface ClassificationResult {
category: string;
priority: "low" | "medium" | "high" | "critical";
sentiment: "positive" | "neutral" | "negative";
confidence: number;
}
interface LLMUsage {
inputTokens: number;
outputTokens: number;
costUSD: number;
model: string;
latencyMs: number;
}
// Preise pro Token für Cost Tracking
const PRICING: Record<string, { input: number; output: number }> = {
"claude-3-5-haiku-20241022": { input: 0.8 / 1_000_000, output: 4.0 / 1_000_000 },
"claude-3-5-sonnet-20241022": { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000 },
};
const client = new Anthropic();
export async function classifyTicket(
ticketText: string,
model = "claude-3-5-haiku-20241022"
): Promise<{ result: ClassificationResult; usage: LLMUsage }> {
const start = performance.now();
const response = await client.messages.create({
model,
max_tokens: 150,
messages: [
{
role: "user",
content: `Klassifiziere dieses Support-Ticket als JSON.
Felder: category (billing|technical|shipping|account|other), priority (low|medium|high|critical), sentiment (positive|neutral|negative), confidence (0-1).
Ticket: "${ticketText}"
Antworte NUR mit validem JSON, kein Markdown.`,
},
],
});
const latencyMs = Math.round(performance.now() - start);
const text = response.content[0].type === "text" ? response.content[0].text : "";
const pricing = PRICING[model] ?? { input: 0, output: 0 };
const usage: LLMUsage = {
inputTokens: response.usage.input_tokens,
outputTokens: response.usage.output_tokens,
costUSD:
response.usage.input_tokens * pricing.input +
response.usage.output_tokens * pricing.output,
model,
latencyMs,
};
// Robustes JSON-Parsing — LLMs liefern manchmal Markdown-Wrapper
const jsonStr = text.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
const result: ClassificationResult = JSON.parse(jsonStr);
return { result, usage };
}
Und die Backend-Seite mit FastAPI
In Python bauen wir einen Service Layer mit Caching, damit wiederholte oder ähnliche Anfragen nicht doppelt bezahlt werden:
import hashlib
import json
import time
from functools import lru_cache
from anthropic import Anthropic
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from redis import Redis
app = FastAPI()
client = Anthropic()
redis = Redis(host="localhost", port=6379, db=0)
CACHE_TTL = 3600 * 24 # 24h — Klassifikationen ändern sich nicht
class TicketRequest(BaseModel):
text: str
model: str = "claude-3-5-haiku-20241022"
class ClassificationResponse(BaseModel):
category: str
priority: str
sentiment: str
confidence: float
cached: bool = False
cost_usd: float = 0.0
latency_ms: int = 0
@app.post("/api/classify", response_model=ClassificationResponse)
async def classify_ticket(req: TicketRequest):
# Cache-Key aus normalisiertem Text
cache_key = f"classify:{hashlib.sha256(req.text.strip().lower().encode()).hexdigest()}"
# Cache-Hit prüfen
cached = redis.get(cache_key)
if cached:
data = json.loads(cached)
data["cached"] = True
return ClassificationResponse(**data)
# LLM-Call mit Timing
start = time.monotonic()
try:
response = client.messages.create(
model=req.model,
max_tokens=150,
messages=[{
"role": "user",
"content": f'Klassifiziere als JSON (category, priority, sentiment, confidence): "{req.text}"'
}],
)
except Exception as e:
raise HTTPException(status_code=502, detail=f"LLM API error: {str(e)}")
latency_ms = int((time.monotonic() - start) * 1000)
# Kosten berechnen
pricing = {"claude-3-5-haiku-20241022": (0.8, 4.0)}
inp_price, out_price = pricing.get(req.model, (3.0, 15.0))
cost = (
response.usage.input_tokens * inp_price / 1_000_000
+ response.usage.output_tokens * out_price / 1_000_000
)
# Response parsen
text = response.content[0].text.strip().strip("`").strip()
if text.startswith("json"):
text = text[4:].strip()
result = json.loads(text)
data = {**result, "cached": False, "cost_usd": round(cost, 6), "latency_ms": latency_ms}
# In Cache schreiben
redis.setex(cache_key, CACHE_TTL, json.dumps(data))
return ClassificationResponse(**data)
Warum Redis-Cache? In der Praxis sehen wir bei Support-Systemen 15–30% Duplikat-Rate (gleiche Fehlermeldung, Copy-Paste-Tickets). Der Cache spart bei 10.000 Tickets/Monat locker 20% API-Kosten — und antwortet in unter 5ms statt 500ms.
Zeitrahmen und Kostenaufschlüsselung
| Posten | Aufwand | Anteil | |---|---|---| | Architektur & API-Abstraktion | 2–3 Tage | 15% | | Prompt Engineering & Testing | 3–5 Tage | 25% | | Backend Service (FastAPI/Node) | 3–5 Tage | 25% | | Frontend Integration | 2–3 Tage | 15% | | Testing, Monitoring, Deployment | 2–3 Tage | 20% |
Gesamtlaufzeit: 2–4 Wochen. Der größte Posten ist nicht der Code — es ist das Prompt Engineering und die Evaluation.
Stufe 2: KI-gestützte Produktfeatures (30.000 – 80.000 EUR)
Hier wird KI zum Produktkern. Typische Projekte: semantische Suche über Unternehmensdokumente, RAG-basierte Wissens-Assistenten, oder intelligente Workflows die mehrere LLM-Calls orchestrieren.
Was Stufe 2 von Stufe 1 unterscheidet
- Daten-Pipeline: Dokumente müssen chunked, embedded und in einer Vektordatenbank indexiert werden
- Evaluation-Framework: Du brauchst messbare Qualitätsmetriken (Precision, Recall, Halluzinationsrate)
- Orchestrierung: Mehrere LLM-Calls in Sequenz oder parallel — mit Routing-Logik
- pgvector / Vector DB: Semantische Suche über deine eigenen Daten
- Iteratives Prompt-Tuning: 3–5 Iterationsrunden bis die Qualität stimmt
Prompt Engineering: Wo das echte Geld gespart wird
Der größte Hebel für Kostenreduktion ist nicht das Modell — es ist der Prompt. Hier ein reales Beispiel, wie wir durch besseres Prompt Engineering die Token-Kosten um über 60% gesenkt haben:
## VORHER: Naiver Prompt (durchschnittlich ~820 Tokens Input)
Du bist ein hilfreicher Assistent, der Support-Tickets für ein deutsches
E-Commerce-Unternehmen klassifiziert. Das Unternehmen verkauft Elektronik
und Haushaltsgeräte. Du sollst jedes Ticket in eine Kategorie einordnen
und die Priorität bestimmen. Die möglichen Kategorien sind: Abrechnung,
Technischer Support, Versand, Kontoverwaltung, Sonstiges. Die möglichen
Prioritäten sind: niedrig, mittel, hoch, kritisch. Bitte analysiere das
folgende Ticket sorgfältig und gib deine Einschätzung ab. Erkläre auch
kurz, warum du diese Klassifikation gewählt hast. Antworte in einem
strukturierten Format.
Hier ist das Ticket:
[TICKET_TEXT]
Bitte klassifiziere das Ticket und erkläre deine Entscheidung.
---
## NACHHER: Optimierter Prompt (durchschnittlich ~280 Tokens Input)
Klassifiziere als JSON. Keine Erklärung.
{"category":"billing|technical|shipping|account|other","priority":"low|medium|high|critical","sentiment":"positive|neutral|negative","confidence":0.0-1.0}
Ticket: [TICKET_TEXT]
Ergebnis: 820 → 280 Input-Tokens = 66% Reduktion. Bei 10.000 Tickets/Monat mit Claude Haiku spart das $2.60/Monat. Klingt wenig? Bei 500.000 Tickets/Monat sind es $130/Monat — und bei Sonnet $250/Monat. Bei einem RAG-System mit langen Kontext-Fenstern explodieren die Ersparnisse: ein Prompt, der 4.000 statt 12.000 Tokens pro Anfrage braucht, spart bei 100.000 Anfragen/Monat mit Sonnet $2.400/Monat.
Die Regeln für Token-effiziente Prompts:
- Keine Höflichkeitsfloskeln — "Du bist ein hilfreicher Assistent" kostet Tokens und ändert nichts am Output
- Output-Format im Prompt vorgeben — weniger Tokens für Erklärungen, die keiner braucht
- Few-Shot statt Beschreibung — ein Beispiel sagt mehr als 200 Tokens Erklärung
- Keine doppelten Instruktionen — "Klassifiziere UND erkläre warum" verdoppelt Output-Tokens
Zeitrahmen Stufe 2
6–12 Wochen. Der größte Zeitfresser ist nicht der Code, sondern die Daten-Pipeline und die Evaluation. Du brauchst einen robusten Feedback-Loop: Qualität messen → Prompt anpassen → erneut messen → wiederholen.
Stufe 3: Custom Models & Training (80.000 – 250.000+ EUR)
Am oberen Ende: eigene Modelle fine-tunen oder von Grund auf trainieren. Das ist der richtige Weg wenn — und nur wenn — mindestens zwei dieser Bedingungen zutreffen:
- Generische Modelle schaffen die Accuracy nicht: Deine Domain ist so spezifisch, dass selbst mit perfektem Prompting nur 85% Accuracy rauskommen, du aber 98% brauchst
- Proprietäre Daten = Wettbewerbsvorteil: Du hast 500.000 gelabelte Datensätze, die kein Wettbewerber hat
- Regulatorik erzwingt Self-Hosting: DSGVO, BaFin, oder branchenspezifische Compliance verbietet Cloud-APIs
- Latenz/Kosten bei Scale: Bei 10M+ Anfragen/Monat wird ein kleines fine-getuntes Modell auf eigener GPU günstiger als API-Calls
Was hier reingeht
| Posten | Kosten | Warum | |---|---|---| | Daten-Aufbereitung & Labeling | 15.000–40.000 € | Oft der größte Posten. Garbage in, garbage out | | Training-Infrastruktur (GPU) | 5.000–30.000 € | A100/H100 Cluster, je nach Modellgröße | | ML Engineering | 30.000–80.000 € | Fine-Tuning, Hyperparameter, Evaluation | | MLOps & Deployment | 15.000–40.000 € | Inference-Server, Monitoring, Auto-Scaling | | Iterationen & Optimierung | 10.000–30.000 € | Mindestens 2–3 Trainingsrunden |
Zeitrahmen: 3–6 Monate. Und ehrlich: wir raten 80% unserer Kunden davon ab. Nicht weil wir es nicht können, sondern weil Stufe 1 oder 2 fast immer ausreicht — und in einem Zehntel der Zeit live ist.
Was den Preis nach oben oder unten treibt
Unabhängig von der Stufe gibt es Faktoren, die den Preis signifikant beeinflussen:
Datenqualität — Der wichtigste Faktor. Saubere, strukturierte Daten mit klaren Labels? Das Projekt wird 30% günstiger. Chaotische CSVs, undokumentierte PDFs, drei verschiedene Datumsformate? Rechne 20–40% Aufschlag für Data Engineering.
Legacy-Integration — Anbindung an eine moderne REST-API ist ein Nachmittag. Anbindung an ein SAP-System von 2008 über SOAP mit Custom-Auth? Das sind 2–3 Wochen extra.
Sicherheitsanforderungen — DSGVO-konforme Datenverarbeitung, On-Premise-Hosting, Audit-Trails, Verschlüsselung at rest und in transit. Jedes davon ist machbar, aber jedes kostet Engineering-Zeit.
Iterationsbudget — KI-Projekte sind nicht wie klassische Softwareprojekte. Du weißt am Tag 1 nicht, ob der Prompt in Production 92% oder 97% Accuracy liefert. Plane Budget für 2–3 Iterationsrunden nach dem ersten Release ein.
Token-Kosten-Rechner: Schnelle Orientierung
Hier ein einfacher Rechner, den du für deine eigene Kalkulation nutzen kannst:
interface CostEstimate {
monthlyTokensInput: number;
monthlyTokensOutput: number;
monthlyCostUSD: number;
monthlyCostEUR: number;
costPerRequest: number;
}
function estimateMonthlyCost(params: {
requestsPerMonth: number;
avgInputTokens: number;
avgOutputTokens: number;
model: "haiku" | "sonnet" | "gpt4o" | "gpt4o-mini" | "gemini-pro" | "gemini-flash";
eurUsdRate?: number;
}): CostEstimate {
const pricing: Record<string, [number, number]> = {
"haiku": [0.80, 4.00], // [input, output] per 1M tokens
"sonnet": [3.00, 15.00],
"gpt4o": [2.50, 10.00],
"gpt4o-mini": [0.15, 0.60],
"gemini-pro": [1.25, 5.00],
"gemini-flash": [0.075, 0.30],
};
const [inputPrice, outputPrice] = pricing[params.model];
const rate = params.eurUsdRate ?? 0.92;
const totalInput = params.requestsPerMonth * params.avgInputTokens;
const totalOutput = params.requestsPerMonth * params.avgOutputTokens;
const costUSD =
(totalInput / 1_000_000) * inputPrice +
(totalOutput / 1_000_000) * outputPrice;
return {
monthlyTokensInput: totalInput,
monthlyTokensOutput: totalOutput,
monthlyCostUSD: Math.round(costUSD * 100) / 100,
monthlyCostEUR: Math.round(costUSD * rate * 100) / 100,
costPerRequest: Math.round((costUSD / params.requestsPerMonth) * 1_000_000) / 1_000_000,
};
}
// Beispiel: 10.000 Support-Tickets/Monat mit Haiku
const estimate = estimateMonthlyCost({
requestsPerMonth: 10_000,
avgInputTokens: 500,
avgOutputTokens: 50,
model: "haiku",
});
// → { monthlyCostUSD: 4.20, monthlyCostEUR: 3.86, costPerRequest: 0.00042 }
Unser Rat: Starte mit dem Problem, nicht mit der Technologie
Der teuerste Fehler, den wir bei Kunden sehen: "Wir wollen KI einsetzen" als Startpunkt. Das ist wie "Wir wollen eine Datenbank einsetzen" — es sagt nichts über das Problem aus.
Der richtige Startpunkt ist immer eine konkrete Frage:
- "Wir verbrennen 3 FTE für Support-Ticket-Routing — geht das automatisch?"
- "Unsere Kunden finden nichts in unserer Dokumentation — können wir eine intelligente Suche bauen?"
- "Wir haben 50.000 Verträge und brauchen 2 Wochen für Due Diligence — geht das schneller?"
Aus der konkreten Frage ergibt sich der richtige Ansatz, das richtige Modell, die richtige Architektur — und damit ein realistisches Budget.
In 80% der Fälle ist die Antwort Stufe 1 oder 2. Und das ist gut so. Ein sauber gebautes Stufe-1-Projekt, das in 3 Wochen live geht und 95% Accuracy liefert, schlägt ein Stufe-3-Projekt, das nach 6 Monaten immer noch nicht fertig ist.
Nächster Schritt
Bei SecretStack starten wir jedes KI-Projekt mit einem kostenlosen Discovery Call. 30 Minuten, in denen wir dein Problem verstehen, den richtigen Ansatz identifizieren und dir eine ehrliche Einschätzung geben — inklusive Architektur-Skizze, Modellempfehlung und Kostenrahmen.
Kein Pitch-Deck, kein Sales-Speak. Nur Engineering-Expertise und eine klare Antwort auf die Frage: Was kostet es und wie lange dauert es?