Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Láimhseáil earráidí agus cúltacaí

Ceacht 4 as 20 Forbróir
Ar an leathanach seo
  1. Láimhseáil earráidí agus cúltacaí
  2. Earráidí a thabhairt ar ais don tsamhail
  3. Atriail le cúltaca easpónantúil
  4. Teorainneacha ama in aghaidh na feidhme
  5. Cúltaca idir feidhmeanna
  6. Briseadh ciorcaid
  7. Lúb láidir iomlán
  8. Príomhphointí

Láimhseáil earráidí agus cúltacaí

Tugann glao feidhme dúshlán nach mbíonn ag cód clasaiceach: nuair a theipeann ar d’fheidhm, tá dhá ghlacadóir leis an earráid sin. Do iarratas, mar is gnách—agus an tsamhail, atá ag fanacht le toradh chun leanúint ar aghaidh. Má dhéanann tú dearmad den rud seo, cruthaíonn tú an comhartha is mearbhaillí sa táirgeadh: comhrá a stopann go tobann gan aon mhíniú, toisc go ndearnadh eisceacht a shlogadh ar thaobh an fhreastalaí agus tá an tsamhail fós ag fanacht.

Is é an riail a struchtúraíonn an ceacht seo ar fad ná: tabair function_call_output ar ais i gcónaí, fiú amháin ar theip. Is féidir le samhail a chuirtear ar an eolas nach bhfuil API ar fáil rogha eile a mholadh, soiléiriú a iarraidh, nó an scéal a mhíniú don úsáideoir. Ní féidir le samhail nach bhfaigheann aon rud aon rud a dhéanamh.

Earráidí a thabhairt ar ais don tsamhail

Tá an formáid na hearráide chomh tábhachtach céanna leis an earráid a sheoladh. Ní mhúineann “Earráid” lom aon rud don tsamhail; ceadóidh oibiacht JSON a dhéanann idirdhealú ar chineál na hearráide, cibé acu atá sí sealadach nó buan, agus na chéad chéimeanna eile, don tsamhail cinneadh a dhéanamh. Tá sé seo contrártha don chiall: tá tú ag scríobh teachtaireachtaí earráide atá le léamh ag meaisín réasúnaíochta, ní le logáil do dhaoine.

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)
            })
        }

Atriail le cúltaca easpónantúil

Ní bhíonn ciall ag baint le hiarracht athdhéanta ach amháin i gcás fadhbanna a d’fhéadfadh réiteach ar an dara hiarracht: gearradh líonra, cóid stádais 429, nó easnamh sealadacha. Má dhéanann tú iarracht ar iarratas a diúltaíodh mar gheall ar fhíordheimhniú neamhbhailí nó paraiméadair míchearta, ní dhéanfaidh tú ach moill a chur ar an teip agus líon na nglao a iolrú. Sin é an fáth go scagann an cód thíos earráidí go sonrach—déanann an scagadh an obair, agus ní mórán ach an chirt atá tú i bhfiacha don seirbhís i gcéin an cúltaca.

import time
import random

def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
    """Retry with exponential backoff and jitter."""
    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:
            # Data error: do not retry
            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
            })
        }

Teorainneacha ama in aghaidh na feidhme

Tá teorainn ama amháin do gach feidhm míchumraithe i gcónaí: ró-ghearr, agus maraíonn sí próiseáil throm; ró-fhada, agus fanann an t-úsáideoir ar chuardach simplí taisce. Bunaithe gach luach ar fhad ama breathnaithe faoi ghnáthchoinníollacha, le corrlach—ní ar an gcás is measa is féidir a shamhlú, rud a chiallódh go héifeachtach gan aon teorainn ama a bheith agat ar chor ar bith.

import signal
from functools import wraps

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

def with_timeout(func, timeout_seconds):
    """Executes a function with a timeout."""
    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)  # 10s by default

    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"
            })
        }

Cúltaca idir feidhmeanna

Is comhréiteach é an cúltaca, ní freagairt instinctúil: tá sonraí taisce atá sé huaire an chloig d’aois níos fearr ná gan aon rud do dheais, agus i bhfad níos measa ná gan aon rud d’iarmhéid bainc. Nuair a dhéanann tú díghrádú, abair é—sa toradh a thugtar ar ais don tsamhail, ionas gur féidir léi rabhadh a thabhairt don úsáideoir seachas sonraí seanbhunaithe a chur i láthair mar shonraí úra.

async def search_product(term: str) -> dict:
    """Search with fallback: primary API -> cache -> local database."""
    # Attempt 1: Catalog API
    try:
        return await api_catalog.search(term)
    except Exception:
        pass

    # Attempt 2: Redis cache
    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

    # Attempt 3: Local SQLite database
    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"
    }

Briseadh ciorcaid

Déileálann an briseadh ciorcaid leis an rud nach féidir le hiarracht athdhéanta a dhéanamh: seirbhís atá síos ar feadh tréimhse fada. Tar éis N teip, tripeálann sé agus filleann sé earráid láithreach, gan iarracht a dhéanamh fiú, ansin ligeann sé d’iarratas tástála tríd ó am go chéile chun seiceáil an bhfuil téarnamh ann. Tá an gnóthachan dúbailte—stopann do chuid úsáideoirí ag fanacht ar theorainn ama ar gach iarratas, agus ní choinnítear an tseirbhís atá ag streachailt síos ag do chuid iarrachtaí athdhéanta.

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"

# One circuit breaker per external service
breakers = {
    "weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
    "catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}

Lúb láidir iomlán

Tugann an patrún iomlán na cúig mheicníocht thuas le chéile. Déanann aon réamhchúram amháin sábháilte go hiomlán é, agus is furasta dearmad a dhéanamh air: cuir teorainn le líon na n-athrá. Is annamh a dhéanann samhail lúbadh ag glaoch ar fheidhm nach maith léi an toradh atá uirthi, ach gan uasteorainn, dófaidh sí do bhuiséad go dtí go mbeidh tú tuirseach—agus is é sin an cineál teagmhais a fhionnann tú ar an mbille.

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"

Príomhphointí

  • Tabair function_call_output ar ais i gcónaí, fiú amháin ar earráid
  • Struchtúraigh earráidí mar JSON ionas gur féidir leis an tsamhail iad a úsáid
  • Déan iarracht athdhéanta ar earráidí sealadacha amháin le cúltaca easpónantúil
  • Cuir cúltacaí i bhfeidhm idir foinsí sonraí
  • Úsáid briseadh ciorcaid chun seirbhísí atá ag teip a chosaint