Gyakorlati tanácsok éles környezethez
Ezen az oldalon
A leckét 2026. november 3-án frissítettük az OpenAI dokumentációja alapján: a
temperatureéstop_pparaméterek csaknonegondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Ezért az ezeket a paramétereket beállító hívásoknak meg kell adniuk areasoning={"effort": "none"}(Responses API) vagyreasoning_effort="none"(Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.
Gyakorlati tanácsok éles környezethez
Ez a lecke az OpenAI API-ra épülő alkalmazások éles környezetbe (production) történő telepítésének legfontosabb gyakorlati tanácsait foglalja össze. Tekints erre úgy, mint egy indítás előtti ellenőrző listára. A korábbi leckékben megkaptad az építőköveket – hibakezelés, sebességkorlátozások, rugalmasság, megfigyelhetőség és költségek. Most itt az idő, hogy ezeket egyetlen olyan alkalmazássá állítsd össze, amelyet egy kollégád átvehet és futtathat nélküled is.
1. Kliens architektúra
Singleton központosított konfigurációval
Ha minden híváskor új OpenAI klienst példányosítasz, az pazarolja az alapul szolgáló HTTP-kapcsolatot, és ami ennél is komolyabb: szétszórja a konfigurációt. Végül lesz itt egy 30 másodperces időtúllépés, ott pedig az alapértelmezett, anélkül, hogy tudnád, melyik vonatkozik az éles környezetben. Az lru_cache dekorátor garantálja az egyetlen példányt, amely egy helyen van konfigurálva.
from openai import OpenAI
from functools import lru_cache
@lru_cache(maxsize=1)
def get_client() -> OpenAI:
"""Singleton kliens éles környezeti konfigurációval."""
return OpenAI(
max_retries=3,
timeout=30.0,
)
# A kódod bárhol:
client = get_client()
Környezeti változók
Ugyanez az elv vonatkozik a környezetek között változó beállításokra is. Induláskor ellenőrizd a kötelező változókat: jobb, ha egy szolgáltatás tiszta üzenettel megtagadja az indulást, mintsem elinduljon, majd az első felhasználói hívásnál elbukjon. Ez lehetővé teszi, hogy a modellt, a tokenkorlátot és a hőmérsékletet (temperature) újratelepítés nélkül állítsd be.
import os
# KÖTELEZŐ: soha ne kódold be keményen a kulcsokat
REQUIRED_ENV = ["OPENAI_API_KEY"]
for var in REQUIRED_ENV:
if not os.environ.get(var):
raise RuntimeError(f"Hiányzó változó: {var}")
# Környezetfüggő konfiguráció
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 kezelés
Promptok elkülönítése a kódtól
A prompt üzleti eszköz, ugyanúgy, mint egy üzleti szabály. Ha elásva egy f-stringben egy függvényen belül, lehetetlenné válik, hogy valaki, aki ismeri az üzleti folyamatokat, de nem tud Pythonozni, átnézze azt. Kezeld külön paraméterezhető sablonként: a függvény ezután csak a formázásra és a hívásra redukálódik, a 0.0-s hőmérséklet pedig reprodukálhatóvá teszi az osztályozást.
# 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"}, # a temperature megköveteli a none erőfeszítést
input=prompt,
temperature=0.0
)
return response.output_text.strip()
Verziókezd a promptjaidnak
Egy prompt megváltoztatása ugyanolyan biztosan megváltoztatja a rendszer viselkedését, mint a kód módosítása, de ezt egyetlen egységteszt sem veszi észre. Tartsd meg a egymást követő verziókat, és konfiguráció révén válaszd ki az aktívat. Ez lehetővé teszi, hogy két megfogalmazást összehasonlíts valós forgalmon, és ha az új rontja az eredményeket, egy környezeti változóval visszatérj az előzőhöz.
PROMPTS = {
"classification_v1": "Classify: {texte}",
"classification_v2": "Analyze and classify precisely: {texte}",
}
# Éles környezetben használj egy konkrét verziót
ACTIVE_PROMPT = os.environ.get("PROMPT_VERSION", "classification_v2")
3. Időtúllépések és korlátok
Minden kívülről érkező bemenetet korlátozz, mielőtt az elérné az API-t. Egy felhasználónak, aki egy 200 oldalas PDF-et illeszt be a bemeneti meződbe, nem szabad lehetőséget adnia arra, hogy több dolláros hívást indítson el, vagy hogy a kontextus túlcsordulása miatt sikertelen legyen a kérés. A megelőző csonkítás, kimeneti korláttal és a konfigurációból származó hőmérséklettel kombinálva, kiszámíthatóvá teszi minden hívás költségét és késleltetését.
def appel_avec_garde_fous(prompt: str) -> str:
"""API hívás minden biztonsági intézkedéssel."""
# Prompt méretének korlátozása
MAX_PROMPT_CHARS = 50000
if len(prompt) > MAX_PROMPT_CHARS:
prompt = prompt[:MAX_PROMPT_CHARS]
print(f"Prompt csonkolva {MAX_PROMPT_CHARS} karakterre")
response = get_client().responses.create(
model=MODEL,
reasoning={"effort": "none"}, # a temperature megköveteli a none erőfeszítést
input=prompt,
max_output_tokens=MAX_TOKENS,
temperature=TEMPERATURE,
)
return response.output_text
4. Modell tartalék (Fallback)
Amikor egy modell telített vagy átmenetileg elérhetetlen, a hiba visszaadása nem az egyetlen lehetőség. Egy másodlagos modellre való váltás ronthatja a minőséget, de megőrzi a szolgáltatást – ez egy kompromisszum, amely gyakran előnyösebb egy ügyfélszolgálati asszisztens esetén, kevésbé szerződéselemzésnél. A ciklus a modelleken halad végig preferencia szerint, és csak akkor dob kivételt, ha mindegyik sikertelen.
from openai import RateLimitError, InternalServerError
def appel_avec_fallback(prompt: str) -> str:
"""Megpróbálja a Terra modellt, majd hiba esetén átvált a Lunára."""
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} nem elérhető: {e}")
continue
raise RuntimeError("Minden modell elérhetetlen")
5. Kötegelt feldolgozás (Batch Processing)
Ezer dokumentum feldolgozásához a szekvenciális hívások túl lassúak, az egyidejű hívások pedig felrobbantják a sebességkorlátozásaidat. Egy szemafors (semaphore) megtalálja az arany középutat. Két részlet teszi ezt a megvalósítást robusztussá: a return_exceptions=True megakadályozza, hogy egyetlen hiba megszakítsa az egész köteget, az index szerinti rendezés pedig helyreállítja az eredeti sorrendet, amit az asyncio.gather végrehajtási időben nem garantál.
import asyncio
from openai import AsyncOpenAI
async def traiter_batch(prompts: list[str], max_concurrent: int = 5) -> list:
"""Promptok kötegének feldolgozása korlátozott egyidejűséggel."""
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)
# Rendezés index szerint a sorrend megtartásához
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. Tesztelés és validálás
Két különböző típusú tesztre van szükséged. Az első a „vezetékeket“ ellenőrzi – működik-e a kulcs, átjut-e a hálózaton, válaszol-e a modell –, és ez jól illeszkedik egy indítási egészségellenőrzéshez. A második, eredetibb típus maga a prompt minőségét teszteli: beküldesz egy esetet, ahol ismered a helyes választ, és ellenőrzöd, hogy megjelenik-e. Ezek az állítások jelentik a biztonsági hálót a regressziók ellen, amikor átfogalmazol egy sablont.
def test_api_disponible():
"""Ellenőrzi, hogy az API elérhető-e."""
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:
"""Ellenőrzi, hogy egy prompt konzisztens eredményt ad-e vissza."""
response = get_client().responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # a temperature megköveteli a none erőfeszítést
input=prompt,
temperature=0.0
)
resultat = response.output_text.lower()
return attendu.lower() in resultat
# Prompt regressziós tesztek
assert test_prompt_quality(
"Classify 'excellent product': positive or negative?",
"positive"
)
Készíts egy tucatnyi ilyen tesztesetet, amelyek reprezentatívak a valós használati eseteidre, és futtasd le őket minden alkalommal, amikor módosítasz egy promptot. Egy tízperces tesztsorozat heteket spórolhat meg neked a vélt minőséggel kapcsolatos kételkedésből.
7. Éles környezeti telepítési ellenőrzőlista
Telepítés előtt ellenőrizd az egyes pontokat:
Infrastruktúra
- Környezeti változók konfigurálva (OPENAI_API_KEY, stb.)
- Időtúllépések és max_retries beállítva
- Strukturált naplózás bevezetve
- Költségfigyelés engedélyezve
Rugalmasság (Resilience)
- Teljes hibakezelés (minden HTTP kód)
- Exponenciális visszalépés (backoff) az újrapróbálkozásokhoz
- Áramkör megszakító (circuit breaker) elhúzódó kiesések esetén
- Váltás alternatív modellre
Biztonság
- Az API kulcs soha nem látható a kódban vagy a naplókban
- Felhasználói bemenet validálása
- Kliens oldali sebességkorlátozás
- Nincsenek érzékeny adatok a promptokban
Teljesítmény
- Streamelés engedélyezve a felhasználói felületekhez
- Kötegelt feldolgozás nagy volumenű feladatokhoz
- Gyorsítótárazás ismétlődő kérésekhez
- Feladatonként adaptált modellválasztás
Költségek
- Napi költségkeret meghatározva
- Riasztások konfigurálva
max_output_tokensbeállítva, ahol lehetséges- Feladatonként a legköltséghatékonyabb modell kiválasztva
Főbb megállapítások
- Központosítsd a kliens konfigurációját singletonnal
- Válaszd el és verziókezd a promptjaidat a kódon kívül
- Implementálj modell tartalékot (fallback) a magas rendelkezésre állás érdekében
- Használj korlátozott egyidejűségű kötegelt feldolgozást nagy volumen esetén
- Teszteld a promptjaidat minőségi állításokkal
- Kövesd a teljes ellenőrzőlistát minden éles környezeti telepítés előtt