BroadRouter
شروع کریں

Batch API کے بغیر LLM بیچ پروسیسنگ: دوبارہ شروع ہونے والا runner

BroadNet Inference ٹیم · 8 منٹ کی پڑھائی · شائع شدہ · اپ ڈیٹ

Batch API نہ ہو تو جاب خود چلائیں: JSONL فائل سے آئٹمز پڑھیں، جاری درخواستیں کلید کی حد پر روکیں، درخواستوں کا آغاز فی منٹ حد کے اندر رکھیں، 429 اور 5xx پر محدود بیک آف کے ساتھ دوبارہ کوشش کریں، اور ہر نتیجہ اس کی ID کے ساتھ شامل کرتے جائیں۔ دوبارہ شروع کرنے پر مکمل شدہ IDs چھوڑ دیں۔ ختم ہونے کا وقت عموماً ماڈل نہیں، ریٹ لمٹ طے کرتی ہے۔

کچھ LLM jobs چیٹ نہیں ہوتیں۔ آپ کے پاس لیبل کرنے کے لیے 50,000 سپورٹ ٹکٹس ہیں، ترجمہ کرنے کے لیے 200,000 پروڈکٹ تفصیلات، یا اسکور کرنے کے لیے دس لاکھ ریویوز۔ OpenAI اور Anthropic جیسے فراہم کنندگان اس کے لیے Batch API بیچتے ہیں۔ کئی OpenAI-compatible APIs، جن میں BroadNet Inference بھی ہے، ایسا نہیں کرتے۔ یہ پوسٹ دکھاتی ہے کہ جاب خود کیسے چلائیں: اندازہ لگائیں کہ کتنا وقت لگے گا، حدوں کی پابندی کرنے والا runner لکھیں، اور اسے روکنے اور دوبارہ شروع کرنے کے لیے محفوظ بنائیں۔

BroadRouter، BroadNet کی اپنی سائٹ ہے، اس لیے مثال کے اعداد BroadNet کی شائع شدہ حدوں پر ہیں۔ یہ طریقہ کسی بھی chat-completions API پر چلتا ہے؛ اپنے فراہم کنندہ کے اعداد ڈالیں۔

کیا BroadNet Inference میں Batch API ہے؟

نہیں۔ 15 نومبر 2026 کو دیکھا گیا API ریفرنس POST /v1/chat/completions، POST /v1/audio/transcriptions اور GET /v1/models (ماڈلز کی فہرست) دستاویزی کرتا ہے، ساتھ میں /portal/ کے تحت اکاؤنٹ اینڈپوائنٹس۔ کوئی بیچ یا فائل اپ لوڈ اینڈپوائنٹ نہیں اور کوئی بیچ رعایت نہیں۔ بڑی جاب عام درخواستوں کا ایک لوپ ہے۔

ہوسٹڈ Batch API آپ کو کیا دیتا ہے، یہ رہا، تاکہ معلوم رہے کہ آپ کیا دوبارہ بنا رہے ہیں:

OpenAI Batch API Anthropic Message Batches آپ کا اپنا runner
قیمت synchronous سے 50% کم 50% کم عام قیمت
واپسی کا وقت 24 گھنٹے کے اندر زیادہ تر 1 گھنٹے کے اندر؛ 24 کے بعد ختم آپ کی ریٹ لمٹس سے طے
فی بیچ سائز 50,000 درخواستیں یا 200 MB 100,000 درخواستیں یا 256 MB کوئی بھی سائز
ریٹ لمٹس فی ماڈل حدوں سے الگ قطار میں رکھی درخواستوں پر لاگو آپ کی کلید کی حدیں
نتائج کی ترتیب مختلف ہو سکتی ہے؛ custom_id سے ملائیں custom_id سے ملائیں آپ نتائج ID سے جوڑتے ہیں

دو سبق یہاں بھی لاگو ہوتے ہیں۔ دونوں فراہم کنندگان ہر درخواست پر ایک ID لگواتے ہیں، کیونکہ نتائج ترتیب سے واپس نہیں آتے۔ کوئی بھی سیکنڈوں میں جواب کا وعدہ نہیں کرتا۔ آپ کا runner بھی ایسے ہی چلے: ہر چیز پر ID، اور گھنٹوں میں ناپی گئی منصوبہ بندی۔

اگر واپسی کے وقت سے زیادہ 50% رعایت اہم ہے، اور آپ کے مطلوبہ ماڈلز وہاں ہیں، تو ہوسٹڈ Batch API سستا اوزار ہو سکتا ہے۔ بنانے سے پہلے دونوں کی قیمت LLM API لاگت کیلکولیٹر سے نکالیں۔

جاب میں کتنا وقت لگے گا؟

کوڈ لکھنے سے پہلے یہ حساب لگائیں۔ دو حدیں تھرو پٹ روکتی ہیں، اور سست والی جیتتی ہے:

  • جاری درخواستوں کی حد ÷ لیٹنسی۔ 4 درخواستیں جاری اور فی درخواست 2 سیکنڈ ہوں تو آپ فی سیکنڈ 2 مکمل کر سکتے ہیں۔
  • فی منٹ درخواستیں۔ فی منٹ 30 پر آپ فی سیکنڈ 0.5 شروع کر سکتے ہیں، ماڈل کتنا بھی تیز ہو۔

BroadNet کی استعمال کے مطابق ادائیگی والی کلید 4 درخواستیں جاری اور 30 فی منٹ دیتی ہے۔ جانچ کے وقت API ریفرنس میں درج قدروں پر (30 فی منٹ اور 4 جاری، 2026-11-15)، جب تک ہر درخواست 8 سیکنڈ سے زیادہ نہ لے، ریٹ لمٹ ہی باندھتی ہے، اور نیچے کا جدول 30 فی منٹ استعمال کرتا ہے:

آئٹمز فی درخواست ایک آئٹم فی درخواست 20 آئٹمز
10,000 5.6 گھنٹے 17 منٹ
100,000 2.3 دن 2.8 گھنٹے
1,000,000 23 دن 28 گھنٹے

فی منٹ 30 درخواستوں پر ایک کلید گھنٹے میں 1,800 درخواستیں کرتی ہے، یعنی روزانہ 43,200۔ دوبارہ کوششیں بھی گنی جاتی ہیں: آپ کا ہر 429 ایک سلاٹ خرچ کرتا ہے۔

دوسرا کالم سب سے بڑا لیور ہے۔ مختصر آئٹمز، جیسے ریویوز یا ٹکٹ کے عنوانات، نمبر شدہ فہرست کی شکل میں فی درخواست 10 سے 50 جا سکتے ہیں، اور جواب میں JSON array آتا ہے۔ چیک کریں کہ array میں ہر ان پٹ کے لیے ایک entry ہے اور ہر entry پر اس کا نمبر ہے۔ عربی متن کی درجہ بندی والی پوسٹ یہ پیٹرن دکھاتی ہے۔ لمبے آئٹمز پیک نہیں ہوتے: ہر درخواست کو پھر بھی ماڈل کی کانٹیکسٹ ونڈو میں سمانا ہوتا ہے، اور فہرست بڑھنے پر معیار گر سکتا ہے۔ بھروسا کرنے سے پہلے 200 آئٹمز پر پیکنگ ٹیسٹ کریں۔

فی کلید حد کو مات دینے کے لیے بغیر پوچھے ایک جاب کو کئی کلیدوں میں نہ پھیلائیں۔ BroadNet کی Acceptable Use Policy ریٹ، بیک وقت درخواستوں یا بجٹ کی حدوں سے بچنے کی ممانعت کرتی ہے۔ زیادہ چاہیے تو BroadNet سے پوچھیں، یا نیچے بتائے گئے پلان سیشنز استعمال کریں۔ بیچ جاب پلانر آپ کے آئٹمز کی تعداد، لیٹنسی اور حدوں کے لیے یہی حساب کرتا ہے۔

دوبارہ شروع ہونے والا runner کیسا دکھتا ہے؟

یہ runner items.jsonl پڑھتا ہے (ہر لائن میں ایک {"id", "text"} آبجیکٹ) اور ہر آئٹم کے لیے ایک نتیجہ لائن results.jsonl میں شامل کرتا ہے۔ اسے صرف OpenAI Python SDK چاہیے۔

import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))

اسے python batch_run.py items.jsonl results.jsonl سے چلائیں۔ ہم نے یہی فائل ایک لوکل mock سرور پر ٹیسٹ کی، جو بے ترتیب 429 (8%) اور 500 (5%) لوٹاتا تھا اور 4 سے زیادہ جاری یا فی منٹ 30 سے زیادہ آغاز کو مسترد کرتا تھا۔ 25 آئٹمز 28 درخواستوں (3 دوبارہ کوششیں) کے ساتھ 55 سیکنڈ میں مکمل ہوئے، اور کسی بھی 60 سیکنڈ کی ونڈو میں 30 سے زیادہ آغاز نہیں ہوئے۔ وقت بچانے کے لیے mock کی حد فی منٹ 300 کرنے پر، 10 سیکنڈ بعد روکا گیا 120 آئٹمز کا رن 39 محفوظ نتائج سے دوبارہ شروع ہوا اور 120 منفرد IDs کے ساتھ، بغیر کسی تکرار کے، مکمل ہوا۔

asyncio.gather کی بجائے worker pool کیوں؟

429 گائیڈ asyncio.gather کے گرد semaphore استعمال کرتی ہے۔ چند سو کالز کے لیے یہ ٹھیک ہے۔ بڑی جاب کے لیے قطار سے آئٹم لینے والے workers کا مقررہ pool بہتر ہے:

  • میموری۔ gather شروع میں ہی ہر آئٹم کے لیے ایک task بناتا ہے۔ pool صرف جاری آئٹمز رکھتا ہے۔
  • بیک وقت درخواستیں ہی pool کا سائز ہیں۔ چار workers کی کبھی پانچ درخواستیں کھلی نہیں ہو سکتیں۔
  • نتائج ڈسک پر بہتے ہیں جیسے جیسے وہ مکمل ہوتے ہیں، کسی بھی ترتیب میں، ID کے ساتھ۔

Pacer دوسری حد سنبھالتا ہے۔ اکیلا semaphore آپ کو 4 جاری سے آگے جانے سے روکتا ہے، لیکن اگر درخواستیں ایک سیکنڈ لیں تو چار workers فی منٹ 240 شروع کریں گے اور زیادہ تر پر 429 پائیں گے۔ pacer تمام workers میں، دوبارہ کوششوں سمیت، آغاز کے درمیان 2 سیکنڈ کا وقفہ رکھتا ہے۔

دوبارہ کوششیں محفوظ کیسے رہتی ہیں؟

صرف وہی دوبارہ کوشش کریں جو دوسری بار کامیاب ہو سکتی ہے:

جواب کارروائی
429 رکیں اور دوبارہ کوشش کریں؛ BroadNet کے ڈاکس کہتے ہیں “use response details and bounded backoff” (ترجمہ: جواب کی تفصیلات اور محدود بیک آف استعمال کریں)
500، 502، 503، 504، ٹائم آؤٹس، ٹوٹے کنکشنز محدود exponential backoff کے ساتھ دوبارہ کوشش کریں
400، 422 درخواست درست کریں؛ دوبارہ کوشش وہی ایرر بھیجتی ہے
401، 402، 403 جاب روکیں؛ کلید، بیلنس یا پالیسی پر توجہ چاہیے
413 آئٹم مختصر کریں

runner SDK کی اپنی دوبارہ کوششیں بند کرتا ہے (max_retries=0)، تاکہ ٹھیک ایک دوبارہ کوشش کی پالیسی ہو، نظر آنے والی حد کے ساتھ۔ بیک آف مکمل jitter کے ساتھ exponential ہے، 60 سیکنڈ پر محدود، تاکہ ساتھ ناکام ہونے والے workers ساتھ دوبارہ کوشش نہ کریں۔ چھ کوششوں کے بعد آئٹم "ok": false کے طور پر لکھا جاتا ہے اور جاب آگے بڑھتی ہے۔ ایک خراب آئٹم کبھی دس لاکھ کو نہیں روکتا۔

ماڈل کال کا کوئی side effect نہیں ہوتا، اس لیے یہاں ڈیلیوری کم از کم ایک بار ہے: اگر درخواست کے دوران پروسیس مر جائے تو وہ آئٹم دوبارہ شروع ہونے پر پھر بھیجا جاتا ہے، اور آپ اس کے لیے دو بار ادائیگی کرتے ہیں۔ یہی واحد ضیاع ہے۔ اگر جاب کسی دوسرے سسٹم میں بھی لکھتی ہے، جیسے ٹکٹس یا ای میلز، تو اس لکھائی کو آئٹم ID کی بنیاد پر idempotent بنائیں اور اسے results.jsonl پر ایک الگ پاس میں کریں۔ طویل چلنے والے ایجنٹس والی پوسٹ idempotent side effects تفصیل سے بتاتی ہے۔

چیک پوائنٹنگ کیسے کام کرتی ہے؟

آؤٹ پٹ فائل ہی چیک پوائنٹ ہے۔ ہر مکمل شدہ آئٹم ایک flush کی گئی لائن ہے، اس لیے کریش، deploy یا Ctrl-C کے بعد اگلا رن فائل پڑھتا ہے، "ok": true والی IDs جمع کرتا ہے اور صرف باقی کو قطار میں ڈالتا ہے۔ پہلے ناکام ہونے والے آئٹمز اگلے رن میں دوبارہ آزمائے جاتے ہیں، اور ان کی نئی لائن شامل ہوتی ہے۔ نتائج پڑھتے وقت ہر ID کی آخری لائن لیں۔

تین عادتیں اسے دنوں تک پائیدار بناتی ہیں:

  1. مستحکم IDs۔ ڈیٹا بیس کی کلید یا ان پٹ کا hash استعمال کریں، کبھی لائن نمبر نہیں، جو ان پٹ فائل بدلنے پر کھسک جاتا ہے۔
  2. finish_reason چیک کریں۔ max_tokens پر کٹا ہوا جواب "ok": true ہے، لیکن بے کار۔ DeepSeek V4.1 Flash، GLM 5.3 اور Qwen3.8 27B جواب سے پہلے ریزننگ کرتے ہیں، اور ریزننگ max_tokens میں گنی جاتی ہے۔ runner reasoning_effort="low" سیٹ کرتا ہے، جسے BroadNet دستاویزی کرتا ہے، اور 1,500 ٹوکن چھوڑتا ہے۔
  3. ہر لائن پر usage لاگ کریں۔ results.jsonl سے usage جمع کرنے پر اصل ٹوکن بل ملتا ہے، جسے آپ اپنے اندازے سے ملا سکتے ہیں۔

لاگت کیا ہے: استعمال کے مطابق ادائیگی یا پلان سیشن؟

استعمال کے مطابق ادائیگی میں لاگت ٹوکن ہے۔ فرض کریں 100,000 ریویوز، 150 ٹوکن کا سسٹم پرامپٹ، 150 ٹوکن کا ریویو اور کم ریزننگ کے ساتھ 100 آؤٹ پٹ ٹوکن۔ یہ 30 ملین ان پٹ اور 10 ملین آؤٹ پٹ ٹوکن ہیں۔ DeepSeek V4.1 Flash پر اس کی لاگت 30 × $0.175 + 10 × $0.52 ہے۔ سسٹم پرامپٹ پہلے اور بائٹ بہ بائٹ یکساں رکھیں، تو جہاں کیش hit ہو وہاں اس کے 15 ملین ٹوکن $0.0055 فی 1M کی کیش شدہ ان پٹ شرح پر بل ہو سکتے ہیں۔ آپ کی usage لائنیں دکھاتی ہیں کہ ایسا کتنی بار ہوا۔

پلان پر ٹوکن مفت ہیں اور لاگت وقت ہے۔ DeepSeek V4.1 Flash کا پلان سیشن “runs one request at a time” (ترجمہ: ایک وقت میں ایک درخواست چلاتا ہے)، اس لیے ہر سیشن کے لیے IN_FLIGHT=1 رکھیں۔ فی سیشن تھرو پٹ 86,400 ÷ فی آئٹم سیکنڈ ہے، روزانہ۔ BroadNet عام رفتار تقریباً 100 ٹوکن فی سیکنڈ بتاتا ہے، لیکن آپ کی لیٹنسی پرامپٹ کی لمبائی اور ریزننگ پر منحصر ہے، اس لیے 50 آئٹمز پر ناپیں۔ اگر آپ فی آئٹم 3 سیکنڈ ناپتے ہیں تو ایک سیشن روزانہ 28,800 کرتا ہے:

جاب سیشنز 3 s/آئٹم پر وقت پلان
100,000 آئٹمز 1 تقریباً 3.5 دن ایک Orbit ہفتہ، فی سیشن $15
100,000 آئٹمز 4 تقریباً 21 گھنٹے چار Orbit ہفتے، ہر سیشن کے لیے ایک؛ یا فی سیشن تقریباً 21 Meteor گھنٹے، ہر ایک $1 کا
1,000,000 آئٹمز 6 تقریباً 6 دن چھ Orbit ہفتے

پلانز “best effort under fair use” (ترجمہ: fair use کے تحت best effort) دیے جاتے ہیں، اور BroadNet پلان کلیدوں کے لیے فی منٹ درخواستوں کی حد شائع نہیں کرتا؛ لاگو حدیں آپ کے اکاؤنٹ میں نظر آتی ہیں۔ RPM اندازے سے نہیں، انہی سے سیٹ کریں۔ سیشن پلانر گائیڈ بتاتی ہے کہ سیشنز کو کلیدوں میں کیسے بانٹیں۔

BroadNet Inference کہاں فٹ ہوتا ہے

BroadNet Inference میں Batch API نہیں ہے، اس لیے یہ بڑی jobs کے لیے تب موزوں ہے جب آپ runner پر خود کنٹرول رکھنا اور عام فی ٹوکن قیمتیں دینا پسند کریں، یا DeepSeek V4.1 Flash پلان سیشنز سے لاگت مقرر کرنا چاہیں۔ بجٹ والی چھوٹی jobs کے لیے Gemma 4 VL 26B، فی 1M $0.10 ان پٹ اور $0.22 آؤٹ پٹ پر، $5 کے ابتدائی کریڈٹ پر چلتا ہے۔ ہر درخواست کے بعد پرامپٹس اور آؤٹ پٹس نہیں رکھے جاتے۔ اگر آپ کی جاب ایک دن رک سکتی ہے اور آپ کے مطلوبہ ماڈلز 50% بیچ رعایت والے فراہم کنندہ پر ہیں تو وہ سستا پڑ سکتا ہے؛ فیصلہ کرنے سے پہلے موازنہ کریں۔ پلانز اور حدیں inference.broadnet.ai/plans پر ہیں۔

عام سوالات

کیا BroadNet Inference میں Batch API ہے؟

نہیں۔ 15 نومبر 2026 کو دیکھا گیا اس کا API ریفرنس POST /v1/chat/completions، POST /v1/audio/transcriptions اور GET /v1/models دستاویزی کرتا ہے، کوئی بیچ یا فائل اپ لوڈ اینڈپوائنٹ نہیں اور کوئی بیچ رعایت نہیں۔ بڑی jobs کو اپنی کلید کی حدوں کے اندر عام درخواستوں کی طرح چلائیں۔

LLM API سے 100,000 پرامپٹس کیسے پروسیس کروں؟

آئٹمز کو JSONL فائل میں رکھیں، ہر ایک کے ساتھ ایک ID۔ کلید کی جاری درخواستوں کی حد کے برابر مقررہ تعداد میں workers چلائیں، درخواستوں کا آغاز فی منٹ حد کے اندر رکھیں، 429 اور 5xx پر محدود بیک آف کے ساتھ دوبارہ کوشش کریں، اور ہر نتیجہ ID کے ساتھ آؤٹ پٹ فائل میں شامل کریں، تاکہ جاب دوبارہ شروع ہو سکے۔

دس لاکھ درخواستوں کے بیچ میں کتنا وقت لگے گا؟

آئٹمز کو اپنی اصل شرح سے تقسیم کریں۔ فی منٹ 30 درخواستوں اور فی درخواست ایک آئٹم پر ایک کلید روزانہ 43,200 کرتی ہے، اس لیے دس لاکھ میں تقریباً 23 دن لگتے ہیں۔ فی درخواست 20 مختصر آئٹمز پیک کرنے سے یہ تقریباً 28 گھنٹے رہ جاتا ہے، اگر ماڈل لمبا پرامپٹ ٹھیک سے سنبھالے۔

بیچ LLM کالز کے لیے asyncio.gather استعمال کروں یا worker pool؟

دسیوں ہزار آئٹمز کے لیے قطار سے آئٹم لینے والے workers کا ایک مقررہ pool استعمال کریں۔ semaphore کے ساتھ gather چھوٹی jobs کے لیے چلتا ہے، لیکن یہ شروع میں ہی ہر task بنا دیتا ہے اور دوبارہ شروع کرنا اور پیش رفت ٹریک کرنا مشکل بناتا ہے۔

کیا تیزی کے لیے کئی API کلیدیں استعمال کر سکتا ہوں؟

پہلے چیک کریں۔ BroadNet کی Acceptable Use Policy ریٹ یا بیک وقت درخواستوں کی حدوں سے بچنے کی ممانعت کرتی ہے، اس لیے فی کلید حد سے آگے جانے کے لیے ایک جاب کو کئی کلیدوں میں بانٹنے سے پہلے BroadNet سے پوچھیں۔ فی درخواست زیادہ آئٹمز پیک کرنا اور پلان سیشنز تھرو پٹ بڑھانے کے دستاویزی طریقے ہیں۔

کیا فلیٹ پلان بیچ jobs کے لیے اچھا ہے؟

DeepSeek V4.1 Flash کے لیے ہو سکتا ہے۔ سیشن بغیر ٹوکن میٹر کے ایک وقت میں ایک درخواست چلاتا ہے، اس لیے لاگت مقرر ہے اور سوال وقت کا ہے۔ فی آئٹم سیکنڈ ناپیں، پھر مدت کے اندر کام ختم کرنے کے لیے کافی سیشن خریدیں۔

Markdown میں پڑھیںChatGPT سے پوچھیںClaude سے پوچھیںPerplexity سے پوچھیں