Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Gyakorlati tanácsok éles környezethez

17. lecke 22 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Gyakorlati tanácsok éles környezethez
  2. 1. Kliens architektúra
  3. 2. Prompt kezelés
  4. 3. Időtúllépések és korlátok
  5. 4. Modell tartalék (Fallback)
  6. 5. Kötegelt feldolgozás (Batch Processing)
  7. 6. Tesztelés és validálás
  8. 7. Éles környezeti telepítési ellenőrzőlista
  9. Főbb megállapítások

A leckét 2026. november 3-án frissítettük az OpenAI dokumentációja alapján: a temperature és top_p paraméterek csak none gondolkodá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 a reasoning={"effort": "none"} (Responses API) vagy reasoning_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_tokens beá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