OpenAI Python SDK timeout at retries: itakda ang mga ito para sa CheapTokens

Tinawag ng iyong script ang modelo, walang bumalik, at makalipas ang sampung minuto naghihintay pa rin ito. Iyon ang default ng OpenAI Python SDK: 10-minutong timeout at 2 retry. Para baguhin ito, ipasa ang timeout=30.0 at max_retries=2 sa OpenAI(...), i-override ang mga ito sa bawat tawag gamit ang client.with_options(...), at limitahan ang sagot gamit ang max_tokens.

Nakadokumento ang lahat ng ito sa README ng SDK (sinuri noong 27 Oktubre 2026). Sa ibaba, inilalapat ito sa CheapTokens endpoint, https://api.cheaptokens.dev/v1, na gumagamit ng OpenAI Chat Completions format. Ang mga detalye ng setup na iyon ay nasa Your first API request with CheapTokens at sa docs.

Ano ang ginagawa ng SDK kapag wala kang itinakda#

Dalawang default ang mahalaga. Ang timeout ay 10 minuto. Ang retries ay 2, may maikling exponential backoff, para sa connection errors at para sa 408, 409, 429 at 5xx responses, at kapag ang request body ay ligtas na maipadala muli. Ang request na nag-timeout ay nire-retry din.

Kaya bawat pagtatangka ay may sariling timeout, at ang pinakamasamang kaso ay humigit-kumulang timeout na pinarami ng bilang ng pagtatangka, dagdag ang mga paghinto sa pagitan nila:

• default: 600 × 3 = 1800 segundo, kalahating oras
• timeout=30.0, max_retries=2: 30 × 3 = 90 segundo

Sabihin nating ang isang web endpoint ay kailangang sumagot sa loob ng 30 segundo. Sa mga default, maaari itong mag-hang nang kalahating oras bago makita ng iyong code ang error. Subukan ito sa ibang setting bago magpatuloy sa pagbabasa.

Itakda ang timeout at max_retries sa client#

Ang pinakasimpleng solusyon ay itakda ang pareho nang isang beses, kapag gumagawa ka ng client:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
    timeout=30.0,      # seconds per attempt
    max_retries=2,     # 0 turns retries off
)

resp = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "Summarize this ticket in two sentences: ..."}],
    max_tokens=800,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Ang max_retries ay dapat na non-negative integer. Ang timeout ay tumatanggap ng float, o isang httpx Timeout object kung gusto mo ng hiwalay na limitasyon para sa pagkonekta at pagbabasa. Ang README ng kasalukuyang main branch ay nag-import ng httpx2 para doon, ang mga lumang bersyon ay gumamit ng httpx, kaya patakbuhin ang pip show openai at tingnan kung alin ang ginagamit ng iyong install. Ang plain float ay hindi nangangailangan ng import at gumagana sa alinman.

Gamitin ang buong model id mula sa CheapTokens docs, deepseek-ai/DeepSeek-V4-Flash-0731 dito: nagkakaiba ang mga id sa pagitan ng mga provider. Ang modelong ito ay tumatanggap ng hanggang 32,768 output tokens bawat sagot at may 380K context, kaya ang max_tokens na linya sa itaas ay sadyang naroroon. Higit pa tungkol dito sa ibaba, at tungkol sa modelo sa cheap DeepSeek.

I-override ito para sa isang request#

Isang client, iba't ibang trabaho. Ang isang chat reply ay dapat sumuko nang mabilis, ang isang nightly summary ay maaaring maghintay. Sa halip na gumawa ng pangalawang client, kumuha ng isa para sa tawag:

quick = client.with_options(timeout=5.0, max_retries=0)
resp = quick.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    messages=[{"role": "user", "content": "Reply with one word: ok"}],
    max_tokens=5,
)

Ang with_options ay nagbabalik ng kopya na may mga bagong halaga at hinahayaan ang client na hindi ginalaw. Ang pagtatakda ng max_retries=0 ay ang tamang gawin kapag ang iyong sariling code ay nagre-retry na, halimbawa isang job queue na muling nag-e-enqueue ng gawain. Kung hindi, ang dalawang layer ay dumarami: 3 SDK attempts sa loob ng 3 queue attempts ay 9 requests para sa isang gawain.

Huliin ang mga error na mahalaga#

Pagkatapos maubos ang mga retry, nagtataas ang SDK ng exception. Ang bawat error class ay nagmamana mula sa openai.APIError, at ang mga nabigong request ay may dalang request_id, na siyang iyong ilo-log:

import openai

def ask(prompt: str) -> str | None:
    try:
        r = client.chat.completions.create(
            model="deepseek-ai/DeepSeek-V4-Flash-0731",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=800,
        )
        return r.choices[0].message.content
    except openai.APITimeoutError:
        print("timed out after retries")
    except openai.RateLimitError as e:
        print("429, slow down:", e.request_id)
    except openai.APIConnectionError:
        print("cannot reach the API")
    except openai.APIStatusError as e:
        print("HTTP", e.status_code, e.request_id)
    return None

Ang pagkakasunod-sunod ay mula makitid hanggang malawak. Ang APIStatusError ay sumasaklaw sa anumang 4xx o 5xx response, kaya kung ito ang nauna, lalamunin nito ang RateLimitError. Ganoon din sa timeout: nasa itaas ito ng pangkalahatang connection error. Sa isang batch script, ang return None ang buong punto: i-log ang prompt, magpatuloy sa susunod, at patakbuhin muli ang mga nabigo sa dulo.

Kapag nag-trigger ang timeout at naubos na ang mga retry, ganito ang hitsura ng exception:

Para sa detalyadong kaso ng 429, kabilang ang paghihintay sa pagitan ng mga pagtatangka, tingnan ang 429 Too Many Requests from an AI API.

Limitahan ang max_tokens para hindi tumakas ang mahabang sagot#

Ang timeout ay humihinto sa paghihintay. Hindi nito pinapaliit ang isinusulat ng modelo. Kung walang max_tokens, ang isang modelong may 32,768-token na limitasyon sa sagot ay malayang makakasulat ng napakahabang reply, at ang mahabang reply ay mabagal. Magtakda ng limitasyon na umaangkop sa gawain: 800 para sa isang ticket summary, 5 para sa oo/hindi.

Ang kapalit ay maaaring maputol ang isang sagot. Suriin ang resp.choices[0].finish_reason: ang length ay nangangahulugan na naabot ang cap bago matapos ang modelo. Saklaw ito ng Why does an AI answer stop mid-sentence?. Kung i-stream mo ang sagot sa halip, maaga ang mga unang salita at mas maikli ang pakiramdam ng paghihintay, tingnan ang Streaming responses in Python.

Ano ang ginagawa ng retries sa bill#

Ang retry ay isang bagong request. Kung ang isang pagtatangka ay naproseso, ito ay hiwalay na request na may sariling tokens. Sabihin nating ang isang ticket summary ay 1,500 tokens in at 400 out: ang isang request ay nagkakahalaga ng $0.000063 sa presyo ngayon, at ang buong pricing table ay may iba pang mga modelo. Ang mga presyo ay fixed per model, walang peak hours, kaya ang retry sa 3 a.m. ay kapareho ng presyo ng isa sa tanghali.

Ilipat ang mga slider sa iyong sariling batch:

Ang talahanayan ay nagpapakita ng isang pass. Kung ang ikasampu ng batch ay nangangailangan ng pangalawang pagtatangka, magdagdag ng ikasampu. Ang retries ay murang insurance kapag bihira ang mga pagkabigo, at isang mamahaling ugali kapag itinakda mo ang max_retries=10 laban sa isang endpoint na patuloy na nabibigo.

Bago ka mag-ship#