Bästa praxis för produktion
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI-dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Bästa praxis för produktion
Denna lektion täcker de viktigaste bästa praxis för att driftsätta en applikation baserad på OpenAI API i produktion. Tänk på detta som din checklista inför lansering. Tidigare lektioner gav dig byggstenarna – felhantering, hastighetsbegränsningar, motståndskraft, observerbarhet och kostnader. Nu är det dags att sätta ihop dem till en applikation som en kollega kan ta över och köra utan dig.
1. Klientarkitektur
Singleton med centraliserad konfiguration
Att instansiera en OpenAI-klient vid varje anrop slösar på den underliggande HTTP-anslutningen och, vilket är allvarligare, sprider din konfiguration. Du hamnar med en tidsgräns på 30 sekunder här och standardvärdet där, utan möjlighet att veta vilket som gäller i produktion. Dekoratorn lru_cache garanterar en enda instans, konfigurerad på ett ställe.
from openai import OpenAI
from functools import lru_cache
@lru_cache(maxsize=1)
def get_client() -> OpenAI:
"""Singleton-klient med produktionskonfiguration."""
return OpenAI(
max_retries=3,
timeout=30.0,
)
# Överallt i din kod:
client = get_client()
Miljövariabler
Samma princip gäller för inställningar som varierar mellan miljöer. Kontrollera nödvändiga variabler vid start: det är bättre att en tjänst vägrar starta med ett tydligt meddelande än att starta och misslyckas vid första användaranropet. Detta gör modellen, token-gränsen och temperaturen justerbara utan ominstallation.
import os
# KRÄVS: hardkoda aldrig nycklar
REQUIRED_ENV = ["OPENAI_API_KEY"]
for var in REQUIRED_ENV:
if not os.environ.get(var):
raise RuntimeError(f"Missing variable {var}")
# Miljöspecifik 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-hantering
Separera prompts från kod
En prompt är en tillgång för verksamheten, precis som en affärsregel. Att begrava den i en f-sträng inuti en funktion gör det omöjligt för någon som kan verksamheten men inte Python att granska den. Isolera den som en parametriserad mall: funktionen reduceras då till formatering och anrop, och en temperatur på 0,0 gör klassificeringen reproducerbar.
# prompts/classification.txt
PROMPT_CLASSIFICATION = """You are a text classifier.
Classify the following text into one of these categories:
{categories}
Text: {texte}
Reply only with the category name."""
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 requires effort none
input=prompt,
temperature=0.0
)
return response.output_text.strip()
Versionera dina prompts
Att ändra en prompt ändrar systemets beteende lika säkert som att ändra kod, men utan att något enhetstest märker det. Behåll successiva versioner och välj den aktiva via konfiguration. Detta låter dig jämföra två formuleringar på riktig trafik och återgå till den tidigare med en miljövariabel om den nya försämrar resultaten.
PROMPTS = {
"classification_v1": "Classify: {texte}",
"classification_v2": "Analyze and classify precisely: {texte}",
}
# I produktion, använd en specifik version
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")
3. Tidsgränser och begränsningar
Begränsa all indata utifrån innan den når API:t. En användare som klistrar in en PDF på 200 sidor i ditt inmatningsfält får inte kunna utlösa ett anrop som kostar flera dollar eller få begäran att misslyckas på grund av att kontexten svämmar över. Förebyggande trunkering, kombinerat med utdatakapacitet och temperatur från konfigurationen, gör kostnaden och latensen för varje anrop förutsägbara.
def appel_avec_garde_fous(prompt: str) -> str:
"""API-anrop med alla skyddsåtgärder."""
# Begränsa prompt-storlek
MAX_PROMPT_CHARS = 50000
if len(prompt) > MAX_PROMPT_CHARS:
prompt = prompt[:MAX_PROMPT_CHARS]
print(f"Prompt truncated to {MAX_PROMPT_CHARS} characters")
response = get_client().responses.create(
model=MODEL,
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
max_output_tokens=MAX_TOKENS,
temperature=TEMPERATURE,
)
return response.output_text
4. Modell-reserv (Fallback)
När en modell är överbelastad eller tillfälligt otillgänglig är det inte ditt enda alternativ att returnera ett fel. Att byta till en sekundär modell försämrar kvaliteten men bevarar tjänsten – en avvägning som ofta är att föredra för en supportassistent, mindre så för kontraktsanalys. Loopen itererar genom modeller i preferensordning och kastar ett undantag endast om alla misslyckas.
from openai import RateLimitError, InternalServerError
def appel_avec_fallback(prompt: str) -> str:
"""Försöker med Terra och faller tillbaka till Luna vid fel."""
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} unavailable: {e}")
continue
raise RuntimeError("All models are unavailable")
5. Batch-bearbetning
För att bearbeta tusen dokument är sekventiella anrop för långsamma och samtidiga anrop spränger dina hastighetsbegränsningar. En semafor träffar rätt balans. Två detaljer gör denna implementation robust: return_exceptions=True förhindrar att ett enda fel avbryter hela batchen, och sortering efter index återställer den ursprungliga ordningen, vilket asyncio.gather inte garanterar vad gäller exekveringstid.
import asyncio
from openai import AsyncOpenAI
async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
"""Bearbetar en batch av prompts med begränsad samtidighet."""
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)
# Sortera efter index för att behålla ordning
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 = ["Question 1", "Question 2", "Question 3"]
# résultats = asyncio.run(traiter_batch(prompts))
6. Testning och validering
Du behöver två olika typer av tester. Det första kontrollerar rörsystemet – nyckeln fungerar, nätverket passerar, modellen svarar – och passar bra i en hälsokontroll vid start. Det andra, mer originella, testar själva prompt-kvaliteten: du skickar in ett fall där du vet det korrekta svaret och verifierar att det dyker upp. Dessa påståenden är ditt säkerhetsnät mot regressioner när du formulerar om en mall.
def test_api_disponible():
"""Verifierar att API:t är tillgängligt."""
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:
"""Verifierar att en prompt returnerar ett konsekvent resultat."""
response = get_client().responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0
)
resultat = response.output_text.lower()
return attendu.lower() in resultat
# Regressionstester för prompts
assert test_prompt_quality(
"Classify 'excellent product': positive or negative?",
"positive"
)
Bygg ett dussin testfall som detta, representativa för dina verkliga användningsfall, och kör dem varje gång du modifierar en prompt. En testsuite på tio minuter sparar dig veckor av tvivel kring upplevd kvalitet.
7. Checklista för produktionsdriftsättning
Innan du driftsätter, verifiera varje punkt:
Infrastruktur
- Miljövariabler konfigurerade (OPENAI_API_KEY, etc.)
- Tidsgränser och max_retries konfigurerade
- Strukturerad loggning på plats
- Kostnadsövervakning aktiverad
Motståndskraft
- Fullständig felhantering (alla HTTP-koder)
- Exponentiell backoff för försök
- Strömbrytare (circuit breaker) för långvariga avbrott
- Fallback till en alternativ modell
Säkerhet
- API-nyckel aldrig exponerad i kod eller loggar
- Validering av användarinmatning
- Hastighetsbegränsning på klientsidan
- Inga känsliga data i prompts
Prestanda
- Streaming aktiverat för användargränssnitt
- Batch-bearbetning för uppgifter med hög volym
- Cachelagring för repetitiva förfrågningar
- Modellval anpassat till varje uppgift
Kostnader
- Daglig budget definierad
- Aviseringar konfigurerade
- max_output_tokens inställt där det är möjligt
- Mest kostnadseffektiva modell vald per uppgift
Viktiga punkter
- Centralisera klientkonfiguration med en singleton
- Separera och versionera dina prompts utanför koden
- Implementera modell-reserv (fallback) för hög tillgänglighet
- Använd batch-bearbetning med begränsad samtidighet för volym
- Testa dina prompts med kvalitetspåståenden
- Följ den kompletta checklistan före varje produktionsdriftsättning