रेट लिमिट्स

API रेट लिमिट और कॉन्करेंसी को समझना, और उनके दायरे में काम करना

अवलोकन

रेट लिमिट API को गलत इस्तेमाल से बचाती हैं और सभी यूज़र्स के लिए सही इस्तेमाल सुनिश्चित करती हैं। Moknah हमारे HTTP और WebSocket एंडपॉइंट्स, दोनों पर रिक्वेस्ट की संख्या, क्रेडिट के इस्तेमाल और एक साथ बने रहने वाले कनेक्शन्स (concurrent connections) पर लिमिट लागू करता है।

डिफ़ॉल्ट सीमाएँ

WebSocket की सीमाएँ और क्लोज़ कोड

क्योंकि WebSockets एक लगातार बना रहने वाला कनेक्शन बनाए रखते हैं, इसलिए वे रेट लिमिटिंग के लिए HTTP हेडर का इस्तेमाल नहीं करते हैं। इसके बजाय, लिमिट्स को कनेक्शन ड्रॉप और JSON कंट्रोल मैसेज के ज़रिए लागू किया जाता है:

ध्यान दें: अगर आपका WebSocket अचानक डिस्कनेक्ट हो जाता है, तो दोबारा कनेक्ट करने से पहले कम से कम 15 सेकंड इंतज़ार करें ताकि यह पक्का हो सके कि सर्वर-साइड लॉक पूरी तरह से हट गया है।

HTTP रेट लिमिट हेडर

स्टैंडर्ड REST एंडपॉइंट्स के लिए, हर API रिस्पॉन्स में ऐसे हेडर्स शामिल होते हैं जो आपको अपना स्टेटस ट्रैक करने में मदद करते हैं:

जब HTTP रेट लिमिट लागू हो

अगर आप HTTP रेट लिमिट से ज़्यादा रिक्वेस्ट करते हैं, तो आपको इन अतिरिक्त हेडर के साथ ’429 Too Many Requests’ रिस्पॉन्स मिलेगा:

क्रेडिट की गणना

क्रेडिट का हिसाब टेक्स्ट की लंबाई और प्रोसेसिंग विकल्पों के आधार पर लगाया जाता है। WebSockets के मामले में, स्ट्रीमिंग के दौरान हर चंक (chunk) के हिसाब से क्रेडिट डायनामिक रूप से काटे जाते हैं।

उदाहरण: AI-बेस्ड नॉर्मलाइज़ेशन वाला 500-कैरेक्टर का टेक्स्ट:

500 characters × 2 (AI-Enhanced) = 1,000 credits

बेहतरीन तरीके

1. बड़ी मात्रा में सीक्वेंशियल टेक्स्ट के लिए WebSockets का इस्तेमाल करें।

अगर आप बातचीत वाले AI रिस्पॉन्स बना रहे हैं या लंबे डॉक्यूमेंट्स को प्रोसेस कर रहे हैं, तो एक के बाद एक तेज़ी से 50 HTTP POST रिक्वेस्ट न भेजें। इसके बजाय, एक ही WebSocket कनेक्शन खोलें और उसी लगातार बने रहने वाले कनेक्शन के ज़रिए डेटा के हिस्सों (chunks) को स्ट्रीम करें। इससे 60 RPM की HTTP लिमिट पूरी तरह से बायपास हो जाती है (हालांकि क्रेडिट लिमिट अभी भी लागू रहती है)।

2. रिक्वेस्ट क्यूइंग (HTTP) लागू करें

चूंकि Moknah एक साथ कई रिक्वेस्ट (concurrent requests) को सपोर्ट नहीं करता है, इसलिए अपनी HTTP रिक्वेस्ट को कतार (queue) में रखें और उन्हें एक-एक करके प्रोसेस करें:

import queue
import threading
import time

class TTSQueue:
    def __init__(self, api_key):
        self.api_key = api_key
        self.queue = queue.Queue()
        self.worker = threading.Thread(target=self._process_queue, daemon=True)
        self.worker.start()

    def _process_queue(self):
        while True:
            text, voice_id, callback = self.queue.get()
            try:
                result = self._generate(text, voice_id)
                callback(result, None)
            except Exception as e:
                callback(None, e)
            finally:
                self.queue.task_done()

    def _generate(self, text, voice_id):
        # Your API call here
        pass

    def add(self, text, voice_id, callback):
        self.queue.put((text, voice_id, callback))

# Usage
tts = TTSQueue("your_api_key")
tts.add("Hello world", "voice_123", lambda r, e: print(r or e))

class TTSQueue {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.queue = [];
    this.processing = false;
  }

  async add(text, voiceId) {
    return new Promise((resolve, reject) => {
      this.queue.push({ text, voiceId, resolve, reject });
      this.processNext();
    });
  }

  async processNext() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;
    const { text, voiceId, resolve, reject } = this.queue.shift();

    try {
      const result = await this.generate(text, voiceId);
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.processing = false;
      this.processNext(); // Process next in queue
    }
  }

  async generate(text, voiceId) {
    // Your API call here
  }
}

// Usage
const tts = new TTSQueue("your_api_key");
const audio = await tts.add("Hello world", "voice_123");

2. रिक्वेस्ट क्यूइंग (HTTP) लागू करें

चूंकि Moknah एक साथ कई रिक्वेस्ट (concurrent requests) को सपोर्ट नहीं करता है, इसलिए अपनी HTTP रिक्वेस्ट को कतार (queue) में रखें और उन्हें एक-एक करके प्रोसेस करें:

import time
import random

def request_with_backoff(func, max_retries=5):
    retries = 0

    while retries < max_retries:
        try:
            response = func()

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                # Add jitter to prevent thundering herd
                wait_time = retry_after + random.uniform(0, 1)
                print(f"Rate limited. Waiting {wait_time:.1f}s...")
                time.sleep(wait_time)
                retries += 1
                continue

            return response

        except Exception as e:
            # Exponential backoff for other errors
            wait_time = (2 ** retries) + random.uniform(0, 1)
            print(f"Error: {e}. Retrying in {wait_time:.1f}s...")
            time.sleep(wait_time)
            retries += 1

    raise Exception("Max retries exceeded")

async function requestWithBackoff(func, maxRetries = 5) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      const response = await func();

      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("Retry-After") || 60);
        // Add jitter to prevent thundering herd
        const waitTime = retryAfter + Math.random();
        console.log(`Rate limited. Waiting ${waitTime.toFixed(1)}s...`);
        await new Promise(r => setTimeout(r, waitTime * 1000));
        retries++;
        continue;
      }

      return response;

    } catch (error) {
      // Exponential backoff for other errors
      const waitTime = Math.pow(2, retries) + Math.random();
      console.log(`Error: ${error.message}. Retrying in ${waitTime.toFixed(1)}s...`);
      await new Promise(r => setTimeout(r, waitTime * 1000));
      retries++;
    }
  }

  throw new Error("Max retries exceeded");
}

3. एक्सपोनेंशियल बैकऑफ़ लागू करें

जब रेट लिमिट (HTTP 429) या कनेक्शन लिमिट (WebSocket 4290) लागू हो, तो सर्वर पर स्पैमिंग किए बिना सुरक्षित रूप से दोबारा कोशिश करने के लिए ’एक्सपोनेंशियल बैकऑफ़’ (exponential backoff) का इस्तेमाल करें:

सारांश