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

Módh cúlra

Ceacht 9 as 20 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Tríú bealach idir sioncronach agus baisc
  2. Seoladh agus aisghabháil
  3. Tascanna fada réasúnaíochta
  4. An mód ceart a roghnú
  5. Príomhphointí

Tríú bealach idir sioncronach agus baisc

Líonann mód cúlra an API Freagraí niise shainiúil i do bhosca uirlisí. Tugann glao sioncronach an freagra duit láithreach, ach cuireann sé iallach ort an nasc a choinneáil oscailte ar feadh an ghiniúna ar fad. Déanann an API Baisc na mílte iarratas a phróiseáil ag leathphraghas, ach tógann sé uaireanta an chloig ar na torthaí teacht. Suíonn an mód cúlra eatarthu: láimhseálann sé iarratais aonair ag an ráta caighdeánach gan nasc oscailte. Seolann tú an t-iarratas, faigheann tú ID, agus faigheann tú an toradh nuair a bheidh sé réidh.

Díríonn an comhréiteach seo ar chás úsáide beacht: iarratas aonair a thógann ró-fhada le haghaidh glaonna blocála ach nach féidir fanacht go dtí amárach. Is é seo go díreach an scéal nuair a ritheann tú samhaltú ard-réasúnaíochta ar dhoiciméad casta.

Seoladh agus aisghabháil

Níl ach paraiméadar amháin ag teastáil chun é a ghníomhachtú. Níl aon téacs sa fhreagra láithreach; seolann sé ID agus stádas ar ais, de ghnáth queued nó in_progress.

import openai

client = openai.OpenAI()

# Seol an t-iarratas sa chúlra
response = client.responses.create(
    model="gpt-5.6-sol",  # Ideálach do thascanna mall (ard-réasúnaíocht)
    input="Anailísigh tionchair eacnamaíocha rialáil AE ar an IA "
          "do FBManna na Fraince. Mol plean gníomhaíochta 10 bpointe.",
    background=True,  # Mód cúlra
)

print(f"ID Freagra: {response.id}")
print(f"Stádas: {response.status}")  # "queued" nó "in_progress"

Is é an ID seo do nasc amháin leis an obair atá ar siúl: déan é a bhuanú sula ndéanann tú aon rud eile. Má chailleann tú é, ciallaíonn sé go gcáileofar as giniúint nach bhfaighidh tú choíche. Baineann an aisghabháil ansin le poladh ar an API go dtí go mbíonn an stádas críochnaitheach, ag láimhseáil teip agus cealú ar leithligh toisc go bhfuil iarmhairtí gnó éagsúla acu.

import time

def wait_for_response(response_id: str, interval: int = 5) -> str:
    """Fanann sé go gcríochnóidh freagra cúlra."""
    while True:
        response = client.responses.retrieve(response_id)

        match response.status:
            case "completed":
                return response.output_text
            case "failed":
                raise RuntimeError(
                    f"Theip ar an iarratas: {response.error}"
                )
            case "cancelled":
                raise RuntimeError("Cealaíodh an t-iarratas.")
            case _:
                print(f"Stádas: {response.status}...")
                time.sleep(interval)

Tascanna fada réasúnaíochta

Féadfaidh samhaltú cosúil le GPT-5.6 Sol le hard-réasúnaíocht cumasaithe 30 soicind go dhá nóiméad a thógáil sula dtáirgeann sé an chéad token infheicthe. I nglao sioncronach, buaileann na tréimhsí seo teorainneacha ama réamhshocraithe do chliaint HTTP, seachfhreastalaithe agus geataí. Cuireann an mód cúlra deireadh leis an bhfadhb seo ag an bhfréamh, agus ligeann sé duit, ar an taobh eile, roinnt anailísí tromchúiseacha a sheoladh gan oiread sin nasc a cheangal.

async def deep_analysis(document: str) -> str:
    """Seolann sé anailís le GPT-5.6 Sol gan blocáil."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=f"Déan anailís dhlíthiúil chuimsitheach ar an gconradh seo. "
              f"Aithin gach riosca féideartha, clásail fhadhbacha, "
              f"agus mol modhnuithe.\n\n{document}",
        background=True,
    )
    return response.id

# Seol anailísí iolracha comhthreomhara
task_ids = []
for doc in documents:
    task_id = await deep_analysis(doc)
    task_ids.append(task_id)

# Faigh torthaí níos déanaí
results = {}
for task_id in task_ids:
    results[task_id] = wait_for_response(task_id)

Síneann an patrún seo go nádúrtha chuig webhooks nuair is seirbhís eile an glaoiteoir. Seolann do chríochphointe an t-iarratas, filleann sé an ID, agus tarmligíonn sé tasc cúlra chun monatóireacht a dhéanamh ar an gcríochnú agus fógraí a sheoladh. Ní dhéanann an glaoiteoir poladh; faigheann sé fógra.

from fastapi import FastAPI, BackgroundTasks
import httpx

app = FastAPI()

@app.post("/api/long-analysis")
async def launch_analysis(request: dict, background_tasks: BackgroundTasks):
    """Seolann sé anailís agus fógraíonn sé trí webhook nuair a bheidh sé déanta."""
    response = client.responses.create(
        model="gpt-5.6-sol",
        input=request["prompt"],
        background=True,
    )

    # Monatóireacht sa chúlra
    background_tasks.add_task(
        monitor_and_notify,
        response_id=response.id,
        webhook_url=request["webhook_url"],
    )

    return {"response_id": response.id, "status": "launched"}

async def monitor_and_notify(response_id: str, webhook_url: str):
    """Déanann sé monatóireacht ar iarratas cúlra agus fógraíonn sé trí webhook."""
    result = wait_for_response(response_id)

    async with httpx.AsyncClient() as http:
        await http.post(webhook_url, json={
            "response_id": response_id,
            "result": result,
        })

An mód ceart a roghnú

Tagann an riail chinntithe anuas ar dhá cheist. Cé mhéad iarratas? An bhfuil an t-úsáideoir ag fanacht? Thar céad iarratas gan riachtanas láithreachis, buaíonn an API Baisc ar phraghas: torthaí in uaireanta an chloig ag leathchostas. Má tá duine ag fanacht ag a scáileán, is iad glaonna sioncronacha an t-aon rogha inghlactha fós ag an ráta caighdeánach. Líonann an mód cúlra an chuid eile den spás: iarratais bheaga, torthaí i gceann nóiméad, praghas caighdeánach. Is fiú an loighic seo a chódú uair amháin seachas í a athdhéanamh do gach seirbhís nua.

def choose_mode(
    num_requests: int,
    urgency: str,
    budget: str,
) -> str:
    """Molann sé an mód feidhmithe is fearr."""
    if num_requests > 100 and urgency != "immediate":
        return "batch"
    elif urgency == "immediate":
        return "synchronous"
    else:
        return "background"

Ar deireadh, pleanáil bealach éalaithe. Ceanglaíonn iarratas cúlra a sháraíonn go mór a fhad ionchais buiséad agus moillíonn sé an chuid eile de do phíblíne; ligeann an API duit é a chealú go sainráite. Socraigh an uasteorainn seo ag dhá oiread na faide a fheiceann tú sa chleachtas, ní ag an meán, nó rioscaíonn tú iarratais a chealú a bhí ar tí éirí.

def cancel_if_too_long(response_id: str, timeout: int = 120):
    """Cealaíonn sé iarratas má sháraíonn sé an teorainn ama."""
    start = time.time()

    while time.time() - start < timeout:
        response = client.responses.retrieve(response_id)
        if response.status == "completed":
            return response.output_text
        time.sleep(5)

    # Sáraíodh an teorainn ama — cealaigh
    client.responses.cancel(response_id)
    raise TimeoutError(
        f"Cealaíodh iarratas {response_id} tar éis {timeout}s."
    )

Príomhphointí

  • Seolann mód cúlra iarratais gan nasc a choinneáil oscailte
  • Ideálach do shocruithe ard-réasúnaíochta (GPT-5.6 Sol) agus do thascanna fada
  • Comhcheangail le webhook le haghaidh ailtireachta tiomáinte ag imeachtaí
  • Buanigh an ID freagra: is é do nasc amháin leis an obair atá ar siúl
  • Le haghaidh próiseála mórchóir ísealchostais, roghnaigh an API Baisc