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

Teorainneacha Ama agus Robustacht sa Táirgeadh

Ceacht 15 as 16 Nuashonraithe 30 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Ullmhaigh d’Fheidhmchlár don Fhíorshaol
  2. An Teorainn Ama 3600 Soicind
  3. Láimhseáil Earráidí
  4. Ailtireacht Asincronach
  5. Briseadh Ciorcaid
  6. Príomhphointí

Ullmhaigh d’Fheidhmchlár don Fhíorshaol

Sa táirgeadh, féadfaidh iarratais ar an API Freagraí tamall a ghlacadh—go háirithe le samhlacha réasúnaíochta a smaoiníonn go fada sula dtugann siad freagra. Is féidir le drochbhainistiú teorainneacha ama teiptheanna ciúine nó taithí úsáideora lagaithe a chruthú.

An Teorainn Ama 3600 Soicind

Molann xAI teorainn ama íosta de 3600 soicind (1 uair an chloig) d’iarratais ar shamhlacha réasúnaíochta. Tá sé seo i bhfad níos faide ná gnáth-APIanna, rud a imríonn tionchar ar do chuid ailtireachta.

Cén fáth chomh fada sin?

Is féidir le samhlacha réasúnaíochta Grok-4.5 na céadta mílte token inmheánacha réasúnaíochta a úsáid sula dtáirgeann siad freagra. Ar fhadhbanna casta (matamaitic ardleibhéil, anailís cód, réasúnaíocht ilchéime), d’fhéadfadh an tsamhail smaoineamh ar feadh roinnt nóiméad.

Cumraíocht ar Thaobh an Chliaint

import httpx
from openai import OpenAI

# OpenAI SDK le teorainn ama fadaithe
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

I gcurl:

curl --max-time 3600 https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{...}'

Láimhseáil Earráidí

Earráidí Coitianta

Cód HTTPCúisGníomh
401Eochair API neamhbhailíFíoraigh an eochair
429Sroichadh an teorainn rátaDéan iarracht arís le cúlú easpónantúil
500Earráid freastalaí xAIDéan iarracht arís tar éis cúpla soicind
503Seirbhís ar fáilDéan iarracht arís tar éis 30 soicind
Teorainn amaIarratas ró-fhadaMéadaigh an teorainn ama nó simpligh an leid

Patrún Athiarrachta le Cúlú

import time

def call_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.responses.create(**kwargs)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1s, 2s, 4s
            print(f"Error: {e}. Retrying in {wait}s...")
            time.sleep(wait)

Teorannú Ráta

Cuirtear teorainneacha ráta i bhfeidhm ag xAI bunaithe ar do phlean. Cuir teorannóir ráta taobh cliant i bhfeidhm:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests_per_minute=60):
        self.max_rpm = max_requests_per_minute
        self.timestamps = deque()

    def wait_if_needed(self):
        now = time.time()
        # Bain amach stampaí ama atá níos sine ná nóiméad amháin
        while self.timestamps and self.timestamps[0] < now - 60:
            self.timestamps.popleft()
        if len(self.timestamps) >= self.max_rpm:
            sleep_time = 60 - (now - self.timestamps[0])
            time.sleep(max(0, sleep_time))
        self.timestamps.append(time.time())

Ailtireacht Asincronach

Do fheidhmchláir ghréasáin, ná bac ar an bpríomhshnáithe ar feadh 3600 soicind. Úsáid ailtireacht asincronach:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1"
)

async def process_request(user_input):
    response = await client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=user_input,
        stream=True
    )
    async for event in response:
        if event.type == "response.output_text.delta":
            yield event.delta

Is é sruthú an cur chuige is fearr d’fheidhmchláir idirghníomhacha: feiceann úsáideoirí na chéad token laistigh de shoicindí, fiú má thógann an ghiniúint iomlán níos faide.

Briseadh Ciorcaid

Chun d’fheidhmchlár a chosaint ar mhainneachtainí API xAI:

class CircuitBreaker:
    def __init__(self, failure_threshold=5, reset_timeout=60):
        self.failures = 0
        self.threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.last_failure = 0
        self.is_open = False

    def call(self, func, *args, **kwargs):
        if self.is_open:
            if time.time() - self.last_failure > self.reset_timeout:
                self.is_open = False
                self.failures = 0
            else:
                raise Exception("Circuit open — API unavailable")

        try:
            result = func(*args, **kwargs)
            self.failures = 0
            return result
        except Exception as e:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.threshold:
                self.is_open = True
            raise

Príomhphointí

  • Cumraigh teorainn ama íosta de 3600 soicind do shamhlacha réasúnaíochta
  • Cuir athiarracht le cúlú easpónantúil i bhfeidhm d’earráidí 429 agus 500
  • Úsáid sruthú d’fheidhmchláir idirghníomhacha — feiceann úsáideoirí token láithreach
  • Láimhseáil teorannú ráta ar thaobh an chliaint chun earráidí 429 a sheachaint
  • Smaoinigh ar bhriseadh ciorcaid chun d’fheidhmchlár a chosaint ar mhainneachtainí API