Erstellung von KI-Agenten mit mehreren Modellen: Ein praktischer Architekturleitfaden

Die meisten KI-Agenten verwenden ein einzelnes Modell für alles. Den Planungsschritt, die Tool-Aufrufe, die Zusammenfassung, die Fehlerbehebung. Das funktioniert für Demos. In der Produktion ist es verschwenderisch.

Ein Planungsschritt, der tiefgehendes Denken erfordert, braucht nicht dasselbe Modell wie ein JSON-Extraktionsschritt. Eine Codegenerierungsaufgabe hat andere Anforderungen als eine Klassifizierungsaufgabe. Claude Opus 4.6 ($25/1M Ausgabe-Token) zu verwenden, um einen Datumsstring zu formatieren, ist wie einen leitenden Architekten zu engagieren, um eine Wand zu streichen.

So bauen Sie Agenten, die jeden Schritt an das optimale Modell weiterleiten.

Die Multi-Model-Agent-Architektur

User Request
    │
    ▼
┌─────────────┐
│   Router     │  ← Klassifiziert die Aufgabenkomplexität
│  (schnelles Modell)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Einfach│ │Komplex│
│Modell │ │Modell │
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│  Aggregator  │  ← Kombiniert Ergebnisse
│  (schnelles Modell)│
└─────────────┘

Drei Komponenten:

Ein Router, der eingehende Aufgaben nach Komplexität klassifiziert
Ein Pool von Modellen, die auf verschiedene Aufgabentypen abgestimmt sind
Ein Aggregator, der bei Bedarf Ergebnisse kombiniert

Implementierung mit OpenAI SDK

Mit einem einzigen API-Schlüssel über einen Aggregator können Sie auf alle Modelle zugreifen, ohne mehrere SDKs verwalten zu müssen:

from openai import OpenAI

client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Modell-Pool mit Kosten-/Fähigkeitsstufen
MODELS = {
    "router": "gpt-4.1-mini",        # $0.40/1M Eingabe - schnelle Klassifikation
    "simple": "gpt-4.1-mini",        # $0.40/1M Eingabe - Extraktion, Formatierung
    "reasoning": "claude-sonnet-4-6",# $3.00/1M Eingabe - Planung, Analyse
    "complex": "gpt-4.1",            # $2.00/1M Eingabe - Codegenerierung, mehrstufig
    "budget": "deepseek-chat",       # $0.28/1M Eingabe - Massenverarbeitung
}

def route_task(task: str) -> str:
    """Verwende ein günstiges Modell zur Klassifikation der Aufgabenkomplexität."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Klassifiziere diese Aufgabe in eine Kategorie:
- einfach: Datenextraktion, Formatierung, Übersetzung
- reasoning: Analyse, Planung, Vergleich
- komplex: Codegenerierung, mehrstufige Problemlösung
- budget: Massenverarbeitung, nicht-kritische Aufgaben
Antworte nur mit dem Kategorienamen."""},
            {"role": "user", "content": task}
        ],
        max_tokens=10
    )
    category = response.choices[0].message.content.strip().lower()
    return MODELS.get(category, MODELS["simple"])

def execute_task(task: str, context: str = "") -> str:
    """Leitet die Aufgabe an das passende Modell weiter und führt sie aus."""
    model = route_task(task)
    messages = []
    if context:
        messages.append({"role": "system", "content": context})
    messages.append({"role": "user", "content": task})

    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content

Praxisbeispiel: Code-Review-Pipeline

Hier ein praktischer Multi-Model-Agent, der Pull Requests überprüft:

def review_pr(diff: str) -> dict:
    """Multi-Model PR-Review-Pipeline."""

    # Schritt 1: Änderungen klassifizieren (günstiges Modell)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Klassifiziere diese Code-Änderungen: {diff[:2000]}\n"
                       "Kategorien: bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Schritt 2: Sicherheitsprüfung (Reasoning-Modell)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "Du bist ein Sicherheitsprüfer. Prüfe auf: "
                       "SQL-Injection, XSS, Auth-Bypass, Geheimnisse im Code, "
                       "unsichere Deserialisierung. Sei spezifisch bei Zeilennummern."
        }, {
            "role": "user",
            "content": f"Überprüfe diesen Diff auf Sicherheitsprobleme:\n{diff}"
        }]
    ).choices[0].message.content

    # Schritt 3: Codequalität (generelles Modell)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Bewerte die Codequalität: Benennung, Struktur, "
                       f"Fehlerbehandlung, Testabdeckung.\n{diff}"
        }]
    ).choices[0].message.content

    # Schritt 4: Zusammenfassung (günstiges Modell)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Fasse diese PR-Review in 3 Stichpunkten zusammen:\n"
                       f"Typ: {classification}\n"
                       f"Sicherheit: {security[:500]}\n"
                       f"Qualität: {quality[:500]}"
        }]
    ).choices[0].message.content

    return {
        "classification": classification,
        "security": security,
        "quality": quality,
        "summary": summary
    }

Kostenaufstellung für eine typische PR-Review (2K Token Diff):

Schritt	Modell	Eingabe-Token	Kosten
Klassifikation	GPT-4.1-mini	~2.100	$0.0008
Sicherheit	Claude Sonnet 4.6	~2.500	$0.0075
Qualität	GPT-4.1	~2.500	$0.0050
Zusammenfassung	GPT-4.1-mini	~1.200	$0.0005
Gesamt			~$0.014

Die Verwendung von Claude Sonnet 4.6 für alle vier Schritte würde ca. $0.028 kosten. Der Multi-Model-Ansatz halbiert die Kosten und nutzt das stärkste Modell dort, wo es am wichtigsten ist (Sicherheitsprüfung).

LangChain-Integration

from langchain_openai import ChatOpenAI

# Erstelle Modellinstanzen mit unterschiedlichen Konfigurationen
fast = ChatOpenAI(
    model="gpt-4.1-mini",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

reasoning = ChatOpenAI(
    model="claude-sonnet-4-6",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Verwendung in LangChain-Chains
from langchain_core.prompts import ChatPromptTemplate

classify_chain = ChatPromptTemplate.from_template(
    "Klassifiziere: {input}"
) | fast

analyze_chain = ChatPromptTemplate.from_template(
    "Analysiere ausführlich: {input}"
) | reasoning

Wann man Multi-Model-Agenten einsetzen sollte

Multi-Model-Routing erhöht die Komplexität. Es lohnt sich, wenn:

Ihr Agent verschiedene Aufgabentypen bearbeitet (nicht nur Chat)
Die monatlichen API-Kosten über $100 liegen (Einsparungen werden relevant)
Sie spezifische Modellstärken benötigen (Claude für Code, Gemini für langen Kontext, GPT für Geschwindigkeit)
Latenz für einige Schritte wichtig ist, für andere nicht

Für einfache Chatbots oder Agenten mit nur einem Zweck reicht ein einzelnes Modell aus. Der Overhead durch Routing ist nicht gerechtfertigt, wenn jede Anfrage dieselbe Fähigkeit benötigt.

Wichtigste Erkenntnisse

Verwenden Sie das günstigste Modell, das jeden Schritt gut bewältigt
Reservieren Sie teure Modelle für Aufgaben, die sie wirklich benötigen
Klassifikations-/Routing-Schritte sollten immer das günstigste verfügbare Modell nutzen
Messen Sie die tatsächlichen Kosten pro Agentenlauf, nicht nur die Tokenpreise
Ein API-Aggregator mit einem Schlüssel vereinfacht den Zugriff auf mehrere Modelle erheblich

Zugriff auf alle Modelle über eine API: lemondata.cc bietet 300+ Modelle mit nur einem API-Schlüssel. Erstellen Sie Multi-Model-Agenten, ohne mehrere Anbieter-Accounts verwalten zu müssen.