End-to-end-Optimierung: Vom Prompt bis zum Netzwerk — Produktion, Evaluierung und Optimierung

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, wohingegen GPT-5.6-Modelle standardmäßig mit medium reasonieren. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.

Optimierung ist ein System, kein Parameter

Die Reduzierung von Latenz und Kosten für eine LLM-Anwendung beschränkt sich nicht auf die Wahl eines schnelleren Modells. Es handelt sich um eine Kette von Optimierungen, die vom Prompt bis zur Netzwerkkonfiguration reicht, und die schwächste Komponente bestimmt die Leistung für den Rest. Ein Team, das die Größe seines Systemprompts halbiert, aber seinen Server weiterhin für jede Anfrage eine neue TLS-Verbindung öffnet, verliert durch den Netzwerk-Overhead genau so viel, wie es durch die Token-Einsparung gewonnen hat.

Die Reihenfolge, in der Sie diese Hebel ansetzen, ist entscheidend. Beginnen Sie mit dem Prompt, da dieser sowohl Kosten als auch Latenz beeinflusst, ohne Infrastrukturänderungen zu erfordern. Anschließend folgen API-Parameter, dann die Netzwerkkonfiguration und schließlich die Art und Weise, wie Ihre Anwendung die Antwort verarbeitet. Diese Lektion führt Sie durch jeden Hebel in dieser Reihenfolge.

Den Prompt optimieren

Jedes Eingabetoken kostet Zeit und Geld, und die meisten Produktions-Prompts tragen Ballast aus der Prototypenphase mit sich: Anweisungen, die nacheinander hinzugefügt wurden, wobei jede Formulierung die vorherige neu paraphrasiert. Ihre erste Reaktion sollte sein, den Prompt dicht umzuschreiben, Anreden und Wiederholungen zu entfernen, ohne die eigentlichen Constraints, die an das Modell übermittelt werden, zu verändern.

# ❌ Umständlicher Prompt
prompt_long = """
Sie sind ein Experte für Finanzanalysen. Sie müssen immer
professionell und strukturiert antworten. Sie müssen
sofern möglich numerische Daten verwenden. Sie müssen
unnötigen Fachjargon vermeiden. Sie müssen präzise, aber
vollständig sein.
Analysieren Sie den folgenden Quartalsbericht: ...
"""

# ✅ Optimierter Prompt (gleiches Ergebnis, weniger Tokens)
prompt_court = """Rolle: Senior-Finanzanalyst.
Constraints: Strukturiert, numerisch, präzise.
Aufgabe: Analysieren Sie diesen Quartalsbericht: ..."""

Beide Versionen übermitteln exakt dieselben fünf Constraints; die zweite tut dies jedoch ohne die fünf „Sie müssen”-Phrasen, die für das Modell nichts hinzufügen. Bei einem Dienst, der täglich zehntausend Berichte verarbeitet, amortisiert sich diese dreißigsekündige Umschreibung täglich.

Das richtige Modell für die Aufgabe wählen

Der zweite Hebel stützt sich auf die Tatsache, dass nicht jeder Aufruf dasselbe Modell benötigt. Die Routing einer Feldextraktionsaufgabe an ein Modell mit hohem Reasoning bedeutet, dass Sie für Kapazität zahlen, die die Aufgabe nicht nutzt, und länger auf ein identisches Ergebnis warten.

Aufgabentyp	Empfohlenes Modell	Begründung
Klassifizierung / Extraktion	`gpt-5.6-luna`	Schnell, wirtschaftlich
Komplexes Reasoning	`gpt-5.6-terra` mit mittlerem Reasoning	Bestes Verhältnis von Qualität zu Kosten
Kritische Aufgaben	`gpt-5.6-sol` mit hohem Reasoning	Höchste Qualität, langsamer
Hohe Volumina	`gpt-5.6-luna` über Batch API	-50% Kosten

In der Praxis sollten Sie diese Wahl in einer Routing-Funktion kodifizieren, anstatt sie dem Ermessen der Entwickler zu überlassen; andernfalls gewinnt immer das Standardmodell:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Wählt das optimale Modell basierend auf der Aufgabe."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

API-Parameter optimieren

Eine zu lange Antwort verschwendet Generierungszeit, die niemand liest. Geben Sie immer max_output_tokens an: Dies ist eine harte Grenze, die sowohl Ihre Rechnung als auch Ihre Schnittstelle schützt und verhindert, dass ein schlecht formulierter Prompt in eine zweitausendwörtige Abschweifung ausartet.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature erfordert effort none
    input="Fassen Sie diesen Text in einem Satz zusammen.",
    max_output_tokens=100,  # Harte Grenze
    temperature=0.0,         # Deterministisch = schneller
)

Sampling-Parameter wirken in dieselbe Richtung. Das Setzen von temperature=0 macht Antworten deterministisch und etwas schneller, was genau das ist, was Sie für Extraktions- oder Klassifizierungsaufgaben wollen, bei denen Kreativität eine Quelle der Varianz ist, kein Vorteil. Die Reduzierung von top_p auf 0,1 begrenzt den Suchraum und beschleunigt die Generierung; reservieren Sie diese Einstellung für Aufgaben, bei denen nur eine Formulierung akzeptabel ist, und behalten Sie Standardwerte bei, wo die Antwortvielfalt Teil des Produkts ist.

Das Netzwerk optimieren

Die Kosten für Paketübertragungen summieren sich bei jedem Aufruf, bleiben in Ihren Anwendungsmetriken jedoch unsichtbar. Die OpenAI-API wird primär an der US-Ostküste gehostet: Die Platzierung Ihres Anwendungsservers in derselben Region wie der Endpunkt kann eine potenzielle Gewinnung von 50 bis 150 Millisekunden bei der Netzwerklatenz ergeben. Für eine konversationelle Anwendung ist dies ein signifikanter Bruchteil der Time to First Token (TTFT).

Der zweite Gewinn ergibt sich aus der Wiederverwendung von Verbindungen. Ohne einen Pool wird jede Anfrage den TLS-Handshake erneut abspielen, was mehrere Roundtrips hinzufügt, bevor überhaupt nützliche Daten fließen. Die einmalige Konfiguration eines HTTP-Clients löst dies:

import httpx

# Client mit persistentem Verbindungspool
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Post-Processing optimieren

Der letzte Hebel ist oft derjenige, den die Leute vergessen: Eine Anwendung, die eine Streaming-Antwort empfängt, aber bis zum Ende wartet, bevor sie diese anzeigt, zunichte macht alle Vorteile des Streamings. Verarbeiten Sie die Antwort auf dem Laufenden, anstatt nach vollständiger Rezeption.

async def progressive_processing(prompt: str):
    """Verarbeitet jedes Chunk, sobald es eingeht."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Verarbeitung nach vollständigen Sätzen
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Das Aufteilen nach vollständigen Sätzen ist ein bewusster Kompromiss: Das Emission jedes Tokens erzeugt ein zitterndes Display, während das Warten auf den gesamten Absatz das Gefühl von Wiedervorstellung erzeugt. Der Satz ist die Einheit, die Leser natürlich konsumieren. Nutzen Sie dieses Muster, wenn Ihre Schnittstelle etwas anzeigen, vorlesen oder streamen muss, das das Modell produziert.

Kernaussagen

Optimieren Sie den Prompt zuerst: Weniger Tokens = weniger Latenz und Kosten
Routen Sie zum richtigen Modell basierend auf der Komplexität der Aufgabe
Begrenzen Sie max_output_tokens und verwenden Sie temperature=0, wenn möglich
Wiederverwenden Sie HTTP-Verbindungen und verarbeiten Sie Antworten über Streaming