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

Hibakezelés és tartalék megoldások

4. lecke 20 közül Fejlesztő
Ezen az oldalon
  1. Hibakezelés és tartalék megoldások
  2. Hibák visszaadása a modellnek
  3. Újrapróbálkozás exponenciális visszalépéssel
  4. Függvényenkénti időtúllépések (Timeouts)
  5. Tartalék megoldások (Fallback) függvények között
  6. Áramkör megszakító (Circuit Breaker)
  7. Teljes robusztus ciklus
  8. Főbb megállapítások

Hibakezelés és tartalék megoldások

A függvényhívás olyan kihívást jelent, amellyel a klasszikus kód nem néz szembe: ha a függvényed meghibásodik, a hiba két címzettet érint. Az alkalmazásodat, mint szokás – és a modellt is, amely az eredményre vár a folytatáshoz. Ha ezt elfelejted, az a legzavaróbb tünetet okozza éles környezetben: a beszélgetés minden magyarázat nélkül megáll, mert a kivételt elnyelte a szerveroldali kód, a modell pedig még mindig vár.

Az ezt a leckét végigkísérő szabály a következő: mindig adj vissza egy function_call_output objektumot, még hiba esetén is. Egy modell, amely értesül arról, hogy egy API nem elérhető, tud alternatívát javasolni, pontosítást kérni, vagy elmagyarázni a helyzetet a felhasználónak. Egy modell, amely semmit sem kap, semmit sem tud tenni.

Hibák visszaadása a modellnek

A hiba formátuma ugyanolyan fontos, mint maga a küldés. Egy puszta „Error“ üzenet semmit sem tanít a modellnek; egy JSON objektum, amely megkülönbözteti a hiba típusát, azt, hogy átmeneti vagy végleges-e, valamint a következő lépéseket, lehetővé teszi a modell számára a döntést. Ez ellentmondásosnak tűnhet: olyan hibaüzeneteket írsz, amelyeket egy érvelő gépnek szántál olvasásra, nem pedig emberek számára naplózásra.

import json
from openai import OpenAI

client = OpenAI()

def execute_function(name: str, arguments: str, call_id: str) -> dict:
    try:
        args = json.loads(arguments)
        result = dispatcher[name](**args)
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except KeyError:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "unknown_function",
                "message": f"The function '{name}' does not exist"
            })
        }
    except json.JSONDecodeError:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "invalid_arguments",
                "message": "The JSON arguments are malformed"
            })
        }
    except Exception as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "internal_error",
                "message": str(e)
            })
        }

Újrapróbálkozás exponenciális visszalépéssel

Az újrapróbálkozás csak olyan problémák esetén van értelme, amelyek egy második kísérletre megoldódhatnak: hálózati kimaradás, 429-es státuszkódok vagy ideiglenes leállások. Érvénytelen hitelesítés vagy helytelen paraméterek miatt elutasított kérések újrapróbálása csak késlelteti a kudarcot, miközben megsokszorozza a hívások számát. Ezért az alábbi kód kifejezetten szűri a hibákat – a szűrés végzi a munkát, míg a visszalépés csak az a udvariasság, amellyel a távoli szolgáltatásnak tartozol.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Újrapróbálkozás exponenciális visszalépéssel és jitterrel."""
    for attempt in range(max_retries + 1):
        try:
            return func(**args)
        except (ConnectionError, TimeoutError) as e:
            if attempt == max_retries:
                raise
            delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5)
            time.sleep(delay)
        except ValueError:
            # Adathiba: ne próbáld újra
            raise

def execute_function_robust(name, arguments, call_id):
    args = json.loads(arguments)
    try:
        result = execute_with_retry(dispatcher[name], args)
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except Exception as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": type(e).__name__,
                "message": str(e),
                "retries_performed": 3
            })
        }

Függvényenkénti időtúllépések (Timeouts)

Egyetlen, minden függvényre vonatkozó időtúllépés mindig rosszul van beállítva: ha túl rövid, megöl minden nehéz feldolgozást; ha túl hosszú, akkor a felhasználónak egyszerű gyorsítótárazott lekérdezésekre is várnia kell. Minden értéket a normál körülmények között megfigyelt időtartamok alapján állíts be, egy biztonsági ráhagyással – nem a legrosszabb elképzelhető eset alapján, ami gyakorlatilag azt jelentené, hogy nincs is időtúllépés.

import signal
from functools import wraps

TIMEOUTS = {
    "search_client": 5,
    "generate_report": 30,
    "send_email": 10,
}

def with_timeout(func, timeout_seconds):
    """Függvény végrehajtása időtúllépéssel."""
    import concurrent.futures
    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
        future = executor.submit(func)
        try:
            return future.result(timeout=timeout_seconds)
        except concurrent.futures.TimeoutError:
            raise TimeoutError(
                f"Function interrupted after {timeout_seconds}s"
            )

def execute_with_timeout(name, arguments, call_id):
    args = json.loads(arguments)
    timeout = TIMEOUTS.get(name, 10)  # Alapértelmezés: 10s

    try:
        result = with_timeout(
            lambda: dispatcher[name](**args),
            timeout
        )
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps(result)
        }
    except TimeoutError as e:
        return {
            "type": "function_call_output",
            "call_id": call_id,
            "output": json.dumps({
                "error": "timeout",
                "message": str(e),
                "suggestion": "Retry with more specific criteria"
            })
        }

Tartalék megoldások (Fallback) függvények között

A tartalék megoldás kompromisszum, nem reflex: egy hatórás gyorsítótárazott adat kiszolgálása jobb, mint a semmi egy irányítópultnál, de sokkal rosszabb, mint a semmi egy bankszámlaegyenleg esetén. Ha minőségromlást alkalmazol, mondd ki ezt – a modellnek visszaadott eredményben, így az figyelmeztetheti a felhasználót, ahelyett, hogy elavult adatot frissnek mutatna be.

async def search_product(term: str) -> dict:
    """Keresés tartalék megoldással: elsődleges API -> gyorsítótár -> helyi adatbázis."""
    # 1. kísérlet: Katalógus API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # 2. kísérlet: Redis gyorsítótár
    try:
        cached = await redis_client.get(f"product:{term}")
        if cached:
            result = json.loads(cached)
            result["_source"] = "cache"
            result["_warning"] = "Data may be outdated"
            return result
    except Exception:
        pass

    # 3. kísérlet: Helyi SQLite adatbázis
    try:
        row = db.execute(
            "SELECT * FROM products WHERE name LIKE ?",
            (f"%{term}%",)
        ).fetchone()
        if row:
            return {
                "name": row["name"],
                "price": row["price"],
                "_source": "local_db",
                "_warning": "Data from last synchronization"
            }
    except Exception:
        pass

    return {
        "error": "unavailable",
        "message": "No data source accessible for this search"
    }

Áramkör megszakító (Circuit Breaker)

Az áramkör megszakító azt kezeli, amit az újrapróbálkozás nem: olyan szolgáltatást, amely hosszú távon leállt. N hiba után aktiválódik, és azonnal hibát ad vissza anélkül, hogy megpróbálná a hívást, majd időnként engedélyez egy tesztelést a helyreállítás ellenőrzésére. A nyereség kétszeres: a felhasználóid nem várnak minden kérésnél időtúllépésre, és a küzdő szolgáltatást sem tartják lent a folyamatos újrapróbálkozások.

from datetime import datetime, timedelta

class CircuitBreaker:
    def __init__(self, failure_threshold=5, open_duration=60):
        self.threshold = failure_threshold
        self.duration = open_duration
        self.failures = 0
        self.last_failure = None
        self.state = "closed"  # closed, open, half-open

    def can_execute(self) -> bool:
        if self.state == "closed":
            return True
        if self.state == "open":
            if datetime.now() - self.last_failure > timedelta(seconds=self.duration):
                self.state = "half-open"
                return True
            return False
        return True  # half-open: allow one test attempt

    def record_success(self):
        self.failures = 0
        self.state = "closed"

    def record_failure(self):
        self.failures += 1
        self.last_failure = datetime.now()
        if self.failures >= self.threshold:
            self.state = "open"

# Egy áramkör megszakító minden külső szolgáltatáshoz
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Teljes robusztus ciklus

A teljes minta egyesíti a fenti öt mechanizmust. Egy óvintézkedés teszi igazán biztonságossá, amit könnyű elmulasztani: korlátozd az iterációk számát. Ritka, hogy egy modell addig hívjon循环osan egy függvényt, amíg az eredmény nem tetszik neki, de felső korlát nélkül elégeti a költségkeretedet a kimerülésig – és ez az a típusú incidens, amit csak a számlán veszel észre.

def robust_loop(prompt, tools, max_turns=10):
    messages = prompt
    for turn in range(max_turns):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages,
            tools=tools
        )

        calls = [i for i in response.output if i.type == "function_call"]
        if not calls:
            return response.output_text

        results = []
        for call in calls:
            result = execute_function_robust(
                call.name, call.arguments, call.call_id
            )
            results.append(result)

        messages = response.output + results

    return "Workflow interrupted: turn limit reached"

Főbb megállapítások

  • Mindig adj vissza egy function_call_output objektumot, még hiba esetén is
  • Strukturáld a hibákat JSON-ként, hogy a modell fel tudja használni őket
  • Csak az átmeneti hibákat próbáld újra exponenciális visszalépéssel
  • Implementálj tartalék megoldásokat az adatforrások között
  • Használj áramkör megszakítót a hibás szolgáltatások védelmére