تحديد معدل استدعاء API للذكاء الاصطناعي: كيف يعمل وكيفية التعامل معه

كل API للذكاء الاصطناعي لديه حدود لمعدل الاستدعاء. تجاوزها أثناء التطوير مزعج. تجاوزها في الإنتاج يجعل المستخدمين يرون أخطاء. فهم كيفية عمل حدود المعدل عبر المزودين وبناء منطق إعادة المحاولة الصحيح هو الفرق بين عرض تجريبي وتطبيق إنتاجي.

كيف يحدد كل مزود حدودك

OpenAI

تستخدم OpenAI حدود معدل متدرجة بناءً على تاريخ استخدام حسابك ومستوى الدفع.

المستوى	الطلبات في الدقيقة (RPM)	الرموز في الدقيقة (TPM)	كيفية الوصول
مجاني	3	40,000	حساب جديد
المستوى 1	500	200,000	دفع 5 دولارات
المستوى 2	5,000	2,000,000	دفع 50 دولارًا
المستوى 3	5,000	10,000,000	دفع 100 دولار
المستوى 4	10,000	50,000,000	دفع 250 دولارًا
المستوى 5	10,000	300,000,000	دفع 1,000 دولار

الحدود لكل نموذج. استخدام GPT-4.1 لا يستهلك من حصة GPT-4.1-mini الخاصة بك.

Anthropic

تستخدم Anthropic نظام مستويات مشابه مع حدود RPM و TPM. كما تفرض حدًا يوميًا للرموز في المستويات الأدنى.

Google (Gemini)

لدى Google AI Studio حدود لكل نموذج. المستوى المجاني سخي في عدد الطلبات اليومية لكنه صارم في حدود الطلبات في الدقيقة (15 طلبًا في الدقيقة لمستوى Gemini 2.5 Flash المجاني).

منصات التجميع

تضيف منصات التجميع مثل LemonData و OpenRouter طبقة تحديد معدل خاصة بها فوق حدود المزودين الأساسيين. يستخدم LemonData حدودًا بناءً على الدور:

الدور	الطلبات في الدقيقة (RPM)
مستخدم	1,000
شريك	3,000
VIP	10,000

الميزة: حدود التجميع عادةً أعلى من مستويات المزودين المجانية الفردية، والتوجيه متعدد القنوات يعني أنه إذا تم تحديد معدل قناة أساسية، يتم توجيه الطلب إلى قناة أخرى.

قراءة رؤوس حدود المعدل

تعيد جميع المزودين الرئيسيين معلومات حدود المعدل في رؤوس الاستجابة:

x-ratelimit-limit-requests: 500
x-ratelimit-remaining-requests: 499
x-ratelimit-reset-requests: 60s
x-ratelimit-limit-tokens: 200000
x-ratelimit-remaining-tokens: 199500

استخدم هذه الرؤوس بشكل استباقي. لا تنتظر حدوث خطأ 429 لتبطئ.

بناء منطق إعادة المحاولة

الطريقة الخاطئة

# لا تفعل هذا
import time

def call_api(messages):
    while True:
        try:
            return client.chat.completions.create(
                model="gpt-4.1",
                messages=messages
            )
        except Exception:
            time.sleep(1)  # تأخير ثابت، بدون تراجع أسي، يلتقط كل الأخطاء

المشاكل: لا يوجد تراجع أسي، يلتقط أخطاء غير قابلة لإعادة المحاولة، لا يوجد حد أقصى لإعادة المحاولة، لا يوجد تشتت (jitter).

الطريقة الصحيحة

import time
import random
from openai import RateLimitError, APIError, APIConnectionError

def call_with_retry(messages, model="gpt-4.1", max_retries=3):
    """إعادة المحاولة مع تراجع أسي وتشتت."""
    for attempt in range(max_retries + 1):
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages
            )
        except RateLimitError as e:
            if attempt == max_retries:
                raise
            # استخدم retry_after من الاستجابة إذا كان متاحًا
            wait = getattr(e, 'retry_after', None)
            if wait is None:
                wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"تم تحديد المعدل. الانتظار {wait:.1f}s (المحاولة {attempt + 1})")
            time.sleep(wait)
        except APIConnectionError:
            if attempt == max_retries:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(wait)
        except APIError as e:
            # لا تعيد المحاولة على أخطاء العميل (400، 401، 403)
            if e.status_code and 400 <= e.status_code < 500:
                raise
            if attempt == max_retries:
                raise
            time.sleep((2 ** attempt) + random.uniform(0, 1))

المبادئ الأساسية:

• تراجع أسي: 1 ثانية، 2 ثانية، 4 ثوانٍ، 8 ثوانٍ
• تشتت (jitter): إضافة عشوائية من 0 إلى 1 ثانية لمنع التزاحم المفاجئ
• احترام رأس retry_after عند توفره
• لا تعيد المحاولة على أخطاء العميل (طلب خاطئ، فشل التوثيق)
• تحديد حد أقصى لعدد المحاولات

النسخة غير المتزامنة

import asyncio
import random
from openai import AsyncOpenAI, RateLimitError

async_client = AsyncOpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

async def call_with_retry_async(messages, model="gpt-4.1", max_retries=3):
    for attempt in range(max_retries + 1):
        try:
            return await async_client.chat.completions.create(
                model=model,
                messages=messages
            )
        except RateLimitError:
            if attempt == max_retries:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            await asyncio.sleep(wait)

متقدم: محدد معدل دلو الرموز (Token Bucket)

للتطبيقات ذات الإنتاجية العالية، نفذ تحديد معدل من جانب العميل لتجنب الوصول إلى حدود الخادم:

import time
import asyncio

class TokenBucket:
    def __init__(self, rate: float, capacity: int):
        self.rate = rate          # الرموز في الثانية
        self.capacity = capacity  # الحد الأقصى للانفجار
        self.tokens = capacity
        self.last_refill = time.monotonic()

    async def acquire(self, tokens: int = 1):
        while True:
            now = time.monotonic()
            elapsed = now - self.last_refill
            self.tokens = min(
                self.capacity,
                self.tokens + elapsed * self.rate
            )
            self.last_refill = now

            if self.tokens >= tokens:
                self.tokens -= tokens
                return
            # الانتظار للحصول على الرموز الكافية
            wait = (tokens - self.tokens) / self.rate
            await asyncio.sleep(wait)

# 500 طلب في الدقيقة = ~8.3 في الثانية
limiter = TokenBucket(rate=8.0, capacity=20)

async def rate_limited_call(messages, model="gpt-4.1"):
    await limiter.acquire()
    return await async_client.chat.completions.create(
        model=model,
        messages=messages
    )

التحول إلى نموذج بديل عند حدود المعدل

عندما يتم تحديد معدل النموذج الأساسي لديك، انتقل إلى نموذج بديل:

FALLBACK_CHAIN = [
    "claude-sonnet-4-6",
    "gpt-4.1",
    "gpt-4.1-mini",
]

async def call_with_fallback(messages):
    for model in FALLBACK_CHAIN:
        try:
            return await async_client.chat.completions.create(
                model=model,
                messages=messages
            )
        except RateLimitError:
            continue
    raise Exception("تم تحديد معدل جميع النماذج")

هنا تتألق منصات تجميع API. مع أكثر من 300 نموذج خلف نقطة نهاية واحدة، لديك دائمًا نموذج بديل متاح.

مراقبة استخدام حدود المعدل

تابع استهلاك حدود المعدل لديك لاكتشاف المشاكل قبل أن تؤثر على المستخدمين:

import logging

def log_rate_limits(response):
    headers = response.headers
    remaining = headers.get("x-ratelimit-remaining-requests")
    limit = headers.get("x-ratelimit-limit-requests")
    if remaining and int(remaining) < int(limit) * 0.1:
        logging.warning(
            f"تحذير حد المعدل: تبقى {remaining}/{limit} طلبات"
        )

اضبط تنبيهات عندما تنخفض السعة المتبقية إلى أقل من 10%. هذا يمنحك وقتًا لتطبيق التقييد قبل أن يرى المستخدمون أخطاء 429.

الملخص

الاستراتيجية	متى تستخدمها
تراجع أسي	دائمًا (الأساس)
محدد معدل من جانب العميل	تطبيقات ذات إنتاجية عالية (>100 طلب في الدقيقة)
التحول إلى نموذج بديل	تطبيقات الإنتاج ذات متطلبات اتفاقية مستوى الخدمة (SLA)
المراقبة الاستباقية	أي نشر إنتاجي
API دفعي	أعباء عمل غير في الوقت الحقيقي

الهدف ليس تجنب حدود المعدل تمامًا. بل التعامل معها بسلاسة حتى لا يلاحظها المستخدمون أبدًا.

---

ابنِ تطبيقات ذكاء اصطناعي مقاومة: lemondata.cc توفر توجيهًا متعدد القنوات يتعامل تلقائيًا مع حدود المعدل في المزودين الأساسيين. مفتاح API واحد، أكثر من 300 نموذج.