Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Best Practices für die Produktion

Lektion 17 von 22 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Best Practices für die Produktion
  2. 1. Client-Architektur
  3. 2. Prompt-Management
  4. 3. Timeouts und Limits
  5. 4. Modell-Fallback
  6. 5. Batch-Verarbeitung
  7. 6. Testen und Validieren
  8. 7. Checkliste für die Produktionsbereitstellung
  9. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während GPT-5.6-Modelle standardmäßig durch Reasoning arbeiten (medium). 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.

Best Practices für die Produktion

Diese Lektion behandelt die wesentlichen Best Practices für den Einsatz einer auf der OpenAI API basierenden Anwendung in der Produktion. Betrachten Sie dies als Ihre Checkliste vor dem Launch. Die vorherigen Lektionen haben Ihnen die Bausteine geliefert – Fehlerbehandlung, Rate Limits, Resilienz, Observability und Kosten. Jetzt ist es Zeit, diese zu einer Anwendung zusammenzufügen, die ein Kollege übernehmen und ohne Sie betreiben kann.

1. Client-Architektur

Singleton mit zentraler Konfiguration

Die Instanziierung eines OpenAI-Clienten bei jedem Aufruf verschwendet die zugrundeliegende HTTP-Verbindung und, noch ernster, streut Ihre Konfiguration. Sie landen mit einem 30-Sekunden-Timeout hier und dem Standardwert dort, ohne zu wissen, welcher in der Produktion gilt. Der lru_cache-Decorator garantiert eine einzige Instanz, die an einer Stelle konfiguriert wird.

from openai import OpenAI
from functools import lru_cache

@lru_cache(maxsize=1)
def get_client() -> OpenAI:
    """Singleton-Client mit Produktionskonfiguration."""
    return OpenAI(
        max_retries=3,
        timeout=30.0,
    )

# Überall in Ihrem Code:
client = get_client()

Umgebungsvariablen

Das gleiche Prinzip gilt für Einstellungen, die zwischen Umgebungen variieren. Prüfen Sie erforderliche Variablen beim Start: Es ist besser, dass ein Dienst mit einer klaren Meldung verweigert, sich zu starten, als dass er startet und beim ersten Benutzeranruf fehlschlägt. Dies macht das Modell, das Token-Limit und die Temperatur ohne Neudeployment anpassbar.

import os

# ERFORDERLICH: niemals Schlüssel hartcodieren
REQUIRED_ENV = ["OPENAI_API_KEY"]

for var in REQUIRED_ENV:
    if not os.environ.get(var):
        raise RuntimeError(f"Fehlende Variable {var}")

# Umgebungspezifische Konfiguration
MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.6-terra")
MAX_TOKENS = int(os.environ.get("OPENAI_MAX_TOKENS", "4096"))
TEMPERATURE = float(os.environ.get("OPENAI_TEMPERATURE", "0.7"))

2. Prompt-Management

Prompts vom Code trennen

Ein Prompt ist ein Geschäftsvermögen, genau wie eine Geschäftsregel. Wenn Sie ihn in einem f-String innerhalb einer Funktion verstecken, kann es jemandem, der das Geschäft kennt, aber nicht Python, unmöglich werden, ihn zu überprüfen. Isolieren Sie ihn als parametrisierte Vorlage: Die Funktion reduziert sich dann auf Formatierung und Aufruf, und eine Temperatur von 0,0 macht die Klassifizierung reproduzierbar.

# prompts/classification.txt
PROMPT_CLASSIFICATION = """Sie sind ein Textklassifizierer.
Klassifizieren Sie den folgenden Text in eine dieser Kategorien:
{categories}

Text: {texte}

Antworten Sie nur mit dem Kategoriennamen."""

def classifier(texte: str, categories: list[str]) -> str:
    prompt = PROMPT_CLASSIFICATION.format(
        categories=", ".join(categories),
        texte=texte
    )
    response = get_client().responses.create(
        model=MODEL,
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=prompt,
        temperature=0.0
    )
    return response.output_text.strip()

Versionieren Ihrer Prompts

Ändern Sie einen Prompt, so verändert sich das Systemverhalten genauso sicher wie beim Ändern von Code, aber ohne dass eine einzelne Unit-Test dies bemerkt. Halten Sie aufeinanderfolgende Versionen und wählen Sie die aktive über die Konfiguration aus. Dies ermöglicht es Ihnen, zwei Formulierungen auf echtem Verkehr zu vergleichen und bei Verschlechterung der Ergebnisse mit einer Umgebungsvariable auf die vorherige zurückzukehren.

PROMPTS = {
    "classification_v1": "Klassifizieren: {texte}",
    "classification_v2": "Analysieren und präzise klassifizieren: {texte}",
}

# In der Produktion eine spezifische Version verwenden
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")

3. Timeouts und Limits

Begrenzen Sie jeden Input von außen, bevor er die API erreicht. Ein Benutzer, der eine 200-seitige PDF-Datei in Ihr Eingabefeld einfügt, darf nicht in der Lage sein, einen mehrstündigen Aufruf auszulösen oder dazu führen, dass die Anfrage aufgrund eines Kontextüberlaufs fehlschlägt. Präventives Truncieren, kombiniert mit dem Output-Cap und der Temperatur aus der Konfiguration, macht die Kosten und Latenz jedes Aufrufs vorhersagbar.

def appel_avec_garde_fous(prompt: str) -> str:
    """API-Aufruf mit allen Sicherheitsvorkehrungen."""
    # Prompt-Größe begrenzen
    MAX_PROMPT_CHARS = 50000
    if len(prompt) > MAX_PROMPT_CHARS:
        prompt = prompt[:MAX_PROMPT_CHARS]
        print(f"Prompt auf {MAX_PROMPT_CHARS} Zeichen gekürzt")

    response = get_client().responses.create(
        model=MODEL,
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=prompt,
        max_output_tokens=MAX_TOKENS,
        temperature=TEMPERATURE,
    )

    return response.output_text

4. Modell-Fallback

Wenn ein Modell gesättigt ist oder vorübergehend nicht verfügbar ist, ist das Zurückgeben eines Fehlers nicht Ihre einzige Option. Das Umschalten auf ein sekundäres Modell verschlechtert die Qualität, bewahrt aber den Dienst – ein Kompromiss, der für einen Support-Assistenten oft vorzuziehen ist, weniger für Vertragsanalysen. Der Durchlauf durchläuft die Modelle in Reihenfolge der Präferenz und wirft eine Ausnahme nur, wenn alle fehlschlagen.

from openai import RateLimitError, InternalServerError

def appel_avec_fallback(prompt: str) -> str:
    """Versucht Terra und fällt bei Fehler auf Luna zurück."""
    modeles = ["gpt-5.6-terra", "gpt-5.6-luna"]

    for modele in modeles:
        try:
            response = get_client().responses.create(
                model=modele,
                input=prompt
            )
            return response.output_text
        except (RateLimitError, InternalServerError) as e:
            print(f"{modele} nicht verfügbar: {e}")
            continue

    raise RuntimeError("Alle Modelle sind nicht verfügbar")

5. Batch-Verarbeitung

Um tausend Dokumente zu verarbeiten, sind sequenzielle Aufrufe zu langsam und gleichzeitige Aufrufe sprengen Ihre Rate Limits. Ein Semaphore trifft das richtige Gleichgewicht. Zwei Details machen diese Implementierung robust: return_exceptions=True verhindert, dass ein einzelner Fehler den gesamten Batch storniert, und das Sortieren nach Index stellt die ursprüngliche Reihenfolge wieder her, die asyncio.gather in der Ausführungszeit nicht garantiert.

import asyncio
from openai import AsyncOpenAI

async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
    """Verarbeitet einen Batch von Prompts mit begrenzter Parallelität."""
    client = AsyncOpenAI()
    semaphore = asyncio.Semaphore(max_concurrent)
    resultats = []

    async def traiter_un(index: int, prompt: str):
        async with semaphore:
            response = await client.responses.create(
                model="gpt-5.6-terra",
                input=prompt
            )
            return index, response.output_text

    tasks = [traiter_un(i, p) for i, p in enumerate(prompts)]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    # Nach Index sortieren, um Reihenfolge zu erhalten
    sorted_results = sorted(
        [(idx, res) for idx, res in results if not isinstance(res, Exception)],
        key=lambda x: x[0]
    )
    return [res for _, res in sorted_results]

# prompts = ["Frage 1", "Frage 2", "Frage 3"]
# résultats = asyncio.run(traiter_batch(prompts))

6. Testen und Validieren

Sie benötigen zwei verschiedene Arten von Tests. Der erste prüft die Infrastruktur – der Schlüssel funktioniert, das Netzwerk geht durch, das Modell antwortet – und passt gut in einen Startup-Health-Check. Der zweite, originellere, testet die Prompt-Qualität selbst: Sie reichen einen Fall ein, bei dem Sie die richtige Antwort kennen, und überprüfen, ob diese erscheint. Diese Assertions sind Ihr Sicherheitsnetz gegen Regressionen, wenn Sie eine Vorlage umformulieren.

def test_api_disponible():
    """Überprüft, ob die API zugänglich ist."""
    try:
        response = get_client().responses.create(
            model="gpt-5.6-terra",
            input="test",
            max_output_tokens=5
        )
        assert response.output_text is not None
        print("API OK")
        return True
    except Exception as e:
        print(f"API KO: {e}")
        return False

def test_prompt_quality(prompt: str, attendu: str) -> bool:
    """Überprüft, ob ein Prompt ein konsistentes Ergebnis liefert."""
    response = get_client().responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=prompt,
        temperature=0.0
    )
    resultat = response.output_text.lower()
    return attendu.lower() in resultat

# Regressionstests für Prompts
assert test_prompt_quality(
    "Klassifizieren Sie 'excellent product': positiv oder negativ?",
    "positive"
)

Erstellen Sie ein Dutzend solcher Testfälle, die repräsentativ für Ihre echten Anwendungsfälle sind, und führen Sie sie jedes Mal aus, wenn Sie einen Prompt ändern. Eine Test-Suite von zehn Minuten wird Ihnen Wochen an Zweifeln über die wahrgenommene Qualität ersparen.

7. Checkliste für die Produktionsbereitstellung

Bevor Sie bereitstellen, überprüfen Sie jeden Punkt:

Infrastruktur

  • Umgebungsvariablen konfiguriert (OPENAI_API_KEY usw.)
  • Timeouts und max_retries konfiguriert
  • Strukturierte Protokollierung vorhanden
  • Kostenüberwachung aktiviert

Resilienz

  • Vollständige Fehlerbehandlung (alle HTTP-Codes)
  • Exponentielles Backoff für Wiederholungsversuche
  • Circuit Breaker für längere Ausfälle
  • Fallback auf ein alternatives Modell

Sicherheit

  • API-Schlüssel niemals im Code oder Logs offengelegt
  • Validierung von Benutzereingaben
  • Client-seitige Rate Limiting
  • Keine sensiblen Daten in Prompts

Leistung

  • Streaming für Benutzeroberflächen aktiviert
  • Batch-Verarbeitung für Hochvolumenaufgaben
  • Caching für wiederholte Anfragen
  • Modellwahl an jede Aufgabe angepasst

Kosten

  • Tagesbudget definiert
  • Warnungen konfiguriert
  • max_output_tokens gesetzt, wo möglich
  • Kosteneffektivstes Modell pro Aufgabe ausgewählt

Kernaussagen

  • Client-Konfiguration zentralisieren mit einem Singleton
  • Prompts vom Code trennen und versionieren
  • Modell-Fallback für hohe Verfügbarkeit implementieren
  • Batch-Verarbeitung mit begrenzter Parallelität für Volumen verwenden
  • Prompts mit Qualitätsassertionen testen
  • Die vollständige Checkliste vor jeder Produktionsbereitstellung befolgen