LLM-Routing: Die geheime Architektur die KI-Kosten um 60% senkt

Stellen Sie sich eine Welt vor in der jede Nutzeranfrage an das perfekte LLM-Modell gesendet wird: GPT-4o mini für einfache Fragen, Claude 3.5 Sonnet für komplexe Analysen, Mistral Large für deutschsprachige Aufgaben. Ohne dass der Nutzer einen Unterschied bemerkt.

Genau das macht LLM-Routing. Und Unternehmen die es einsetzen senken ihre Kosten um 50 bis 70% mit weniger als 2% Qualitätsverlust.

TL;DR

• LLM-Routing = jede Anfrage an das am besten geeignete Modell senden (optimales Qualitäts-/Kostenverhältnis)
• 3 Hauptstrategien: Komplexitätsbasiertes Routing, Kaskaden-Routing, Konsens-Routing
• Typische Einsparungen: 50-70% Reduktion der LLM-Kosten mit < 2% Qualitätsverlust
• Tools: Martian, Unify, OpenRouter für verwaltetes Routing; eigener Classifier für volle Kontrolle
• Für RAG: LLM-Routing mit Prompt Caching kombinieren für > 80% Einsparung

Warum LLM-Routing unverzichtbar ist

Das Problem: ein Modell für alles

Die meisten Unternehmen verwenden ein einziges Modell für alle Anfragen:

Alle Anfragen → GPT-4o → Antworten
                $$$$$

Das Problem? 80% der Anfragen sind einfach und benötigen nicht die Leistung (und Kosten) eines GPT-4o.

Typische Anfragenverteilung

Die finanzielle Auswirkung

Für 100.000 Anfragen/Monat:

Die 3 Routing-Strategien

Strategie 1: Komplexitätsbasiertes Routing

Am häufigsten. Ein Classifier analysiert die Anfrage und sendet sie an das richtige Modell.

                    ┌─────────────────┐
                    │   Classifier    │
                    │  (Komplexität)  │
                    └───┬──────┬──────┘
                        │      │
              ┌─────────┼──────┼──────────┐
              ▼         ▼      ▼          ▼
         ┌────────┐ ┌──────┐ ┌──────┐ ┌───────┐
         │Trivial │ │Einfach│ │Mittel│ │Komplex│
         │(Regel) │ │(mini)│ │(std) │ │(pro)  │
         └────────┘ └──────┘ └──────┘ └───────┘
         $0         $0,001   $0,005   $0,03

Implementierung:

DEVELOPERpython
from openai import OpenAI
import anthropic

client_openai = OpenAI()
client_anthropic = anthropic.Anthropic()

# Komplexitäts-Classifier (selbst ein leichtes LLM)
CLASSIFIER_PROMPT = """Analysiere die Komplexität dieser Nutzeranfrage.
Antworte NUR mit einem der folgenden Level:
- TRIVIAL: Begrüßungen, Danke, Bestätigungen
- SIMPLE: Direkte Faktenfrage, Basisinfo
- MEDIUM: Vergleich, Synthese, mehrteilige Frage
- COMPLEX: Analyse, Langformtext, mehrstufiges Reasoning
- EXPERT: Komplexe kreative Aufgabe, Datenanalyse, Recht

Anfrage: {query}
Level:"""

async def classify_complexity(query: str) -> str:
    """Komplexität mit leichtem Modell klassifizieren."""
    response = client_openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "user", "content": CLASSIFIER_PROMPT.format(query=query)}
        ],
        max_tokens=10,
        temperature=0,
    )
    return response.choices[0].message.content.strip()

# Komplexität → Modell-Mapping
MODEL_ROUTING = {
    "TRIVIAL": None,  # Template-Antwort, kein LLM
    "SIMPLE": {"provider": "openai", "model": "gpt-4o-mini"},
    "MEDIUM": {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
    "COMPLEX": {"provider": "openai", "model": "gpt-4o"},
    "EXPERT": {"provider": "anthropic", "model": "claude-sonnet-4-20250514"},
}

TRIVIAL_RESPONSES = {
    "hallo": "Hallo! Wie kann ich Ihnen helfen?",
    "danke": "Gerne! Zögern Sie nicht bei weiteren Fragen.",
}

async def route_and_generate(query: str, context: str) -> dict:
    """Anfrage an das richtige Modell routen und Antwort generieren."""
    complexity = await classify_complexity(query)
    config = MODEL_ROUTING[complexity]

    if config is None:
        for keyword, response in TRIVIAL_RESPONSES.items():
            if keyword in query.lower():
                return {"response": response, "model": "template", "cost": 0}

    if config["provider"] == "openai":
        response = client_openai.chat.completions.create(
            model=config["model"],
            messages=[
                {"role": "system", "content": f"Kontext:\n{context}"},
                {"role": "user", "content": query},
            ],
        )
        return {
            "response": response.choices[0].message.content,
            "model": config["model"],
            "cost": estimate_cost(response.usage, config["model"]),
        }
    elif config["provider"] == "anthropic":
        response = client_anthropic.messages.create(
            model=config["model"],
            max_tokens=2048,
            system=f"Kontext:\n{context}",
            messages=[{"role": "user", "content": query}],
        )
        return {
            "response": response.content[0].text,
            "model": config["model"],
            "cost": estimate_cost_anthropic(response.usage, config["model"]),
        }

Strategie 2: Kaskaden-Routing

Beginnt mit dem günstigsten Modell. Bei zu niedriger Konfidenz Eskalation zum nächsten Modell.

Query → GPT-4o mini → Konfidenz > 80%? → Ja → Antwort ✓
                           │
                           Nein
                           ↓
              Claude 3.5 Sonnet → Konfidenz > 80%? → Ja → Antwort ✓
                                       │
                                       Nein
                                       ↓
                              GPT-4o → Antwort (erzwungen) ✓

Implementierung:

DEVELOPERpython
import re

CASCADE_MODELS = [
    {"provider": "openai", "model": "gpt-4o-mini", "threshold": 0.8},
    {"provider": "anthropic", "model": "claude-sonnet-4-20250514", "threshold": 0.7},
    {"provider": "openai", "model": "gpt-4o", "threshold": 0.0},  # Fallback
]

CONFIDENCE_PROMPT_SUFFIX = """

Füge nach deiner Antwort in der letzten Zeile hinzu:
CONFIDENCE: X.XX (zwischen 0 und 1, dein Vertrauen in die Antwort)"""

async def cascade_route(query: str, context: str) -> dict:
    """Kaskaden-Routing mit Konfidenz-Bewertung."""
    for config in CASCADE_MODELS:
        response, confidence = await generate_with_confidence(
            query, context, config
        )

        if confidence >= config["threshold"]:
            return {
                "response": response,
                "model": config["model"],
                "cascade_level": CASCADE_MODELS.index(config) + 1,
            }

    # Fallback: letzte Antwort
    return {
        "response": response,
        "model": CASCADE_MODELS[-1]["model"],
        "cascade_level": len(CASCADE_MODELS),
    }

async def generate_with_confidence(query, context, config):
    """Antwort generieren und Konfidenz-Score extrahieren."""
    full_query = query + CONFIDENCE_PROMPT_SUFFIX

    if config["provider"] == "openai":
        resp = client_openai.chat.completions.create(
            model=config["model"],
            messages=[
                {"role": "system", "content": f"Kontext:\n{context}"},
                {"role": "user", "content": full_query},
            ],
        )
        text = resp.choices[0].message.content
    else:
        resp = client_anthropic.messages.create(
            model=config["model"],
            max_tokens=2048,
            system=f"Kontext:\n{context}",
            messages=[{"role": "user", "content": full_query}],
        )
        text = resp.content[0].text

    # Konfidenz extrahieren
    confidence_match = re.search(r"CONFIDENCE:\s*([\d.]+)", text)
    confidence = float(confidence_match.group(1)) if confidence_match else 0.5
    clean_response = re.sub(r"\nCONFIDENCE:.*$", "", text).strip()

    return clean_response, confidence

Strategie 3: Konsens-Routing

Für kritische Anfragen: Mehrere Modelle befragen und die Mehrheitsantwort nehmen oder kombinieren.

Query → ┌─ GPT-4o mini ──────────┐
        ├─ Claude 3.5 Haiku ─────┤→ Vergleicher → Endantwort
        └─ Mistral Small ────────┘

Implementierung:

DEVELOPERpython
import asyncio

async def consensus_route(query: str, context: str) -> dict:
    """3 Modelle befragen und Antworten kombinieren."""
    models = [
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
        {"provider": "openai", "model": "gpt-4o-mini"},
    ]

    # Parallele Aufrufe
    tasks = [generate(query, context, m) for m in models]
    responses = await asyncio.gather(*tasks)

    # Antworten kombinieren
    combined = await synthesize_responses(query, responses)

    return {
        "response": combined,
        "models_used": [m["model"] for m in models],
        "individual_responses": responses,
    }

async def synthesize_responses(query, responses):
    """Ein Modell synthetisiert die Antworten der anderen."""
    synthesis_prompt = f"""Hier sind 3 Antworten auf dieselbe Frage.
Synthetisiere die beste Antwort durch Kombination der Stärken.
Bei Widersprüchen bevorzuge den Konsens.

Frage: {query}

Antwort 1: {responses[0]}
Antwort 2: {responses[1]}
Antwort 3: {responses[2]}

Synthese:"""

    resp = client_openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": synthesis_prompt}],
    )
    return resp.choices[0].message.content

Vergleich der Routing-Lösungen

Verwaltete Routing-Tools

Martian: Der ML-Router

DEVELOPERpython
import requests

def route_with_martian(query: str, context: str) -> dict:
    """Routing über Martian - automatische beste Modellauswahl."""
    response = requests.post(
        "https://api.withmartian.com/v1/chat/completions",
        headers={"Authorization": "Bearer MARTIAN_API_KEY"},
        json={
            "messages": [
                {"role": "system", "content": context},
                {"role": "user", "content": query},
            ],
            "model": "router",  # Martian wählt das Modell
            "max_tokens": 1024,
            "route_params": {
                "max_cost": 0.01,  # Max Budget pro Anfrage
                "min_quality": 0.85,  # Mindestqualität
            }
        }
    )

    result = response.json()
    return {
        "response": result["choices"][0]["message"]["content"],
        "model_used": result["model"],
        "cost": result["usage"]["total_cost"],
    }

OpenRouter: Der universelle Aggregator

DEVELOPERpython
from openai import OpenAI

# OpenRouter ist OpenAI-SDK-kompatibel
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="OPENROUTER_API_KEY",
)

def route_with_openrouter(query: str, context: str) -> dict:
    """Routing über OpenRouter mit preisbasierter Auswahl."""
    response = client.chat.completions.create(
        model="openrouter/auto",  # Automatisches Routing
        messages=[
            {"role": "system", "content": context},
            {"role": "user", "content": query},
        ],
        max_tokens=1024,
        extra_body={
            "route": "cost",  # Für Kosten optimieren
        }
    )
    return {
        "response": response.choices[0].message.content,
        "model_used": response.model,
    }

LLM-Routing für RAG

RAG-Architektur mit Routing

┌────────────────────────────────────────────────────────┐
│                  RAG + LLM-ROUTING                      │
├────────────────────────────────────────────────────────┤
│                                                         │
│  Nutzeranfrage                                          │
│       │                                                 │
│       ▼                                                 │
│  ┌──────────────┐                                      │
│  │  Classifier  │  ← Komplexität + Intent analysieren   │
│  │  (GPT-4o     │                                      │
│  │   mini)      │                                      │
│  └──────┬───────┘                                      │
│         │                                               │
│    ┌────┴────┐                                          │
│    ▼         ▼                                          │
│  Einfach   Komplex                                      │
│    │         │                                          │
│    ▼         ▼                                          │
│  ┌──────┐  ┌──────────┐                                │
│  │Light │  │  Full    │                                │
│  │ RAG  │  │  RAG     │                                │
│  │(top3)│  │  (top10  │                                │
│  └──┬───┘  │  +rerank)│                                │
│     │      └────┬─────┘                                │
│     ▼           ▼                                      │
│  GPT-4o     Claude 3.5                                  │
│  mini       Sonnet                                      │
│  ($0,001)   ($0,015)                                    │
│     │           │                                      │
│     └─────┬─────┘                                      │
│           ▼                                             │
│      Endantwort                                         │
└────────────────────────────────────────────────────────┘

Routing mit Prompt Caching kombinieren

Die ultimative Kostenreduktions-Kombination:

Metriken und Monitoring

Routing-KPIs

DEVELOPERpython
# Wesentliche Metriken zum Tracken
routing_metrics = {
    # Verteilung
    "requests_per_model": "Counter pro Modell",
    "complexity_distribution": "Histogramm der Level",

    # Qualität
    "user_satisfaction_per_model": "Durchschnittsscore pro Modell",
    "cascade_escalation_rate": "% eskalierter Anfragen",
    "consensus_disagreement_rate": "% Meinungsverschiedenheiten",

    # Kosten
    "cost_per_request_avg": "Durchschnittliche Kosten pro Anfrage",
    "cost_savings_vs_single_model": "Einsparung vs Einzelmodell",
    "classifier_cost_overhead": "Classifier-Mehrkosten",

    # Performance
    "routing_latency_p50": "< 50ms",
    "total_latency_p50": "< 2s",
    "cache_hit_rate": "> 70%",
}

Typisches Dashboard

LLM-Routing-ROI

ROI-Rechner

Implementierungszeit

Ailog und LLM-Routing

Ailogs RAG-Pipeline integriert nativ intelligentes Routing:

• Automatischer Classifier der die Komplexität jeder Frage analysiert
• Multi-Modell mit automatischem Fallback bei Fehlern
• Prompt Caching kombiniert für maximale Einsparungen
• Dashboard zur Verfolgung von Kosten und Qualität pro Modell

Entdecken Sie auch Prompt Caching um bei der Optimierung noch weiter zu gehen, oder erkunden Sie die RAG-Caching-Strategien zur Latenz-Reduktion.

FAQ

Fügt LLM-Routing Latenz hinzu?

Ja, aber sehr wenig. Der Classifier fügt typischerweise 30-80ms hinzu (ein GPT-4o-mini-Aufruf mit 50 Tokens). Für ein Gesamtlatenz-Budget von 2-3 Sekunden ist das vernachlässigbar. Der Trick: Verwenden Sie einen regelbasierten Classifier (Regex, Länge) für triviale Fälle und einen LLM-Classifier nur für mehrdeutige Fälle.

Wie messe ich die Qualität um das Routing anzupassen?

Drei komplementäre Ansätze: (1) Nutzer-Feedback (Daumen hoch/runter), (2) LLM-als-Richter das Antworten auf einer Skala von 10 bewertet, (3) RAG-Metriken (Faithfulness, Relevance) mit Frameworks wie RAGAS. Vergleichen Sie Scores pro Modell um Routing-Schwellenwerte anzupassen.

Verwalteter Router oder eigener?

Zum Starten reicht ein verwalteter Router (OpenRouter, Martian): Einrichtung in 1 Tag, keine Wartung. Wenn Ihr Volumen 500K Anfragen/Monat übersteigt oder Sie spezifische Bedürfnisse haben (private Modelle, ultra-niedrige Latenz), wechseln Sie zu einem eigenen Classifier.

Funktioniert Routing mit Streaming?

Ja. Der Classifier entscheidet über das Modell vor der Generierung. Die Antwort wird dann wie gewohnt vom gewählten Modell gestreamt. Die einzige Einschränkung: Kaskaden-Routing mit Konfidenz-Bewertung ist mit reinem Streaming nicht kompatibel (die vollständige Antwort wird zur Konfidenz-Bewertung benötigt).

Wie hoch ist das Risiko der Qualitätsverschlechterung?

Mit gut kalibriertem Routing ist die Verschlechterung minimal: < 2% im Durchschnitt. Das Hauptrisiko ist ein schlecht trainierter Classifier der komplexe Anfragen an ein leichtes Modell sendet. Lösung: Beginnen Sie konservativ (hohe Schwellenwerte) und senken Sie diese schrittweise unter Qualitätsmonitoring.

---

Bereit Ihre KI-Kosten zu dritteln? Erstellen Sie Ihr Ailog-Konto und profitieren Sie von intelligentem LLM-Routing integriert in Ihre RAG-Pipeline, gehostet in Frankreich.