Best Practices für die Produktion
Auf dieser Seite
Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation:
temperatureundtop_pwerden nur mit einem Reasoning-Effort vonnoneakzeptiert, während GPT-5.6-Modelle standardmäßig durch Reasoning arbeiten (medium). Aufrufe, die diese Parameter setzen, müssen daherreasoning={"effort": "none"}(Responses API) oderreasoning_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