API Timeout: कनेक्शन ड्रॉप्स का निदान और लंबी LLM जनरेशन के लिए सुरक्षित पुनः प्रयास

ड्रॉप्स कहाँ होते हैं: HTTP अनुरोध चक्र के 4 चरण

एक LLM API अनुरोध चार स्वतंत्र तकनीकी चरणों से मिलकर बनता है:

[क्लाइंट] --- (1. Connect Timeout) ---> [API Gateway]
[क्लाइंट] --- (2. Write Timeout)   ---> [प्रॉम्प्ट डेटा अपलोड]
[मॉडल]    --- (3. Read / TTFT)     ---> [रीजनिंग व रिस्पॉन्स जनरेशन]
[क्लाइंट] <--- (4. Pool Timeout)    --- [सॉकेट पूल होल्डिंग]

1. Connect Timeout: TCP और TLS हैंडशेक स्थापित करने का समय (5–10 सेकंड अनुशंसित)।
2. Write Timeout: 100k+ टोकन के बड़े प्रॉम्प्ट पेलोड को अपलोड करने का समय।
3. Read Timeout: पहले टोकन (TTFT) और SSE स्ट्रीम के प्रत्येक हिस्से के आने की प्रतीक्षा अवधि।
4. Pool Timeout: अत्यधिक समवर्ती अनुरोधों के दौरान कनेक्शन पूल से सॉकेट प्राप्त करने का समय।

---

टाइमआउट निदान मैट्रिक्स

---

Python (HTTPX) में टाइमआउट कॉन्फ़िगरेशन

मानक 10 सेकंड का डिफ़ॉल्ट टाइमआउट रीजनिंग मॉडल के लिए अपर्याप्त होता है। नीचे एक स्थिर क्लाइंट कॉन्फ़िगरेशन दिया गया है:

import os
import httpx
from openai import OpenAI

API_KEY = os.environ.get("BETTERTOKEN_API_KEY", "your_api_key_here")

custom_timeout = httpx.Timeout(
    connect=5.0,    # नेटवर्क अनुपलब्ध होने पर तेज़ विफलता
    read=120.0,     # गहरी रीजनिंग के लिए पर्याप्त समय
    write=10.0,     # प्रॉम्प्ट पेलोड अपलोड समय
    pool=10.0       # सॉकेट अधिग्रहण प्रतीक्षा
)

http_client = httpx.Client(
    timeout=custom_timeout,
    limits=httpx.Limits(max_keepalive_connections=50, max_connections=100)
)

client = OpenAI(
    base_url="https://www.bettertoken.ai/v1",
    api_key=API_KEY,
    http_client=http_client
)

response = client.chat.completions.create(
    model="claude-3-7-sonnet-20250219",
    messages=[
        {"role": "system", "content": "You are a senior systems architect."},
        {"role": "user", "content": "Design a high-throughput distributed message broker."}
    ],
    stream=True
)

for chunk in response:
    delta = chunk.choices[0].delta.content or ""
    print(delta, end="", flush=True)
और दिखाएं

---

SSE स्ट्रीम को स्थिर करना और सुरक्षित पुनः प्रयास

कनेक्शन टूटने पर दोहरे खर्च से बचने के लिए पुनः प्रयास इन तीन नियमों पर आधारित होने चाहिए:

1. स्ट्रीम शुरू होने के बाद दोबारा न भेजें: यदि आंशिक टोकन प्राप्त हो चुके हैं, तो पूरे अनुरोध को दोहराने से दोहरा बिलिंग होगा।
2. फुल जिटर के साथ एक्सपोनेंशियल बैकऑफ: पुनः प्रयास को बढ़ती हुई यादृच्छिक देरी के साथ शेड्यूल करें।
3. आइडम्पोटेंसी कुंजियों का उपयोग: बैच प्रोसेसिंग में दोहराव रोकने के लिए अद्वितीय टास्क आईडी का उपयोग करें।

import time
import random
import httpx

def execute_with_safe_retry(client, model, messages, max_retries=3):
    base_delay = 1.0
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                stream=True
            )
            return response
        except (httpx.ConnectTimeout, httpx.ReadTimeout, httpx.NetworkError) as err:
            if attempt == max_retries - 1:
                raise err
            sleep_time = random.uniform(0, base_delay * (2 ** attempt))
            time.sleep(sleep_time)

सत्यापन चेकलिस्ट

• HTTP स्थिति कोड 200 OK।
• बिना किसी त्रुटि के संपूर्ण SSE स्ट्रीम का सफल रिसेप्शन।
• स्ट्रीम समाप्त होने के बाद सॉकेट का सही तरीके से रिलीज होना।

विस्तृत जानकारी के लिए BetterToken API Reference देखें।