SSD Nodes Learn Hosting plans →
تعلیمی Matt Connorتحریر: Matt Connor · اپ ڈیٹ شدہ 2026-10-25

KV cache بمقابلہ prompt cache: فرق کیا ہے؟

KV cache ہر request پر server کی RAM یا VRAM استعمال کرتی ہے اور ختم ہونے پر model load رک سکتا ہے۔ prompt caching صرف provider کا کم بل اور کم latency والا فائدہ ہے۔

KV cache بمقابلہ prompt cache: مختصر جواب

KV cache اور provider کے prompt cache میں ایک لفظ مشترک ہے، تقریباً باقی کچھ نہیں۔ KV cache ہر request کی عارضی working memory ہے۔ یہ ایک request کی پوری مدت تک آپ کے server کی RAM یا VRAM میں رہتی ہے، اور context length اور بیک وقت چلنے والی requests کی تعداد کے ساتھ بڑھتی ہے۔ Provider کا prompt caching billing اور latency کی سہولت ہے۔ آپ کے prompt کا ایک مستقل prefix provider کے servers پر محفوظ کیا جاتا ہے، پھر اسے دوبارہ بھیجنے پر کم نرخ وصول کیا جاتا ہے۔

ایک ایسی memory ہے جس کے لیے آپ hardware خریدتے ہیں۔ دوسری memory کوئی اور فریق اپنے پاس رکھتا ہے اور آپ سے اس کا کرایہ وصول کرتا ہے۔

عملی فرق تعریف سے زیادہ اہم ہے۔ KV cache ختم ہو سکتی ہے، اور ایسا ہونے پر model load ہونے سے انکار کر دیتا ہے یا request مسترد ہو جاتی ہے۔ Prompt cache ختم نہیں ہو سکتی۔ صرف یہ ہو سکتا ہے کہ request اس سے match نہ کرے، اور پھر آپ خاموشی سے پوری قیمت ادا کرتے ہیں۔

KV cache کیا محفوظ کرتا ہے، اور یہ کیوں موجود ہے

Transformer جب token نمبر 500 تیار کرتا ہے تو اسے اپنے سے پہلے موجود تمام 499 tokens پر attention دینی ہوتی ہے۔ ان میں سے ہر token کے لیے ہر layer کو ایک key vector اور ایک value vector درکار ہوتا ہے۔ ہر نئے token کے لیے ان سب کو دوبارہ تیار کرنے سے generation کی لاگت sequence length کے مربع کے ساتھ بڑھتی، اس لیے runtime انہیں محفوظ رکھتا ہے۔ اس محفوظ شدہ ذخیرے کو KV cache (key/value cache) کہتے ہیں۔

یہ ہر request کی الگ state ہوتی ہے، کیونکہ یہ اسی request کی بالکل درست token sequence سے بنتی ہے۔ مختلف prompts بھیجنے والے دو users اسے share نہیں کر سکتے، الا یہ کہ runtime prefix caching استعمال کرے۔ یہ ایک الگ feature ہے جس کی وضاحت آگے کی گئی ہے۔

Serving دو phases میں ہوتی ہے۔ Prefill آپ کے پورے prompt کو پڑھ کر cache بھرتا ہے، اور اس کی حد compute ہوتی ہے۔ Decode ایک وقت میں ایک token تیار کرتا ہے اور اسے cache میں شامل کرتا ہے، اور اس کی حد memory bandwidth ہوتی ہے۔ اسی تقسیم کی وجہ سے prompt processing اور token generation کی رفتار مختلف رپورٹ ہوتی ہے، جب آپ اپنے box پر tokens per second کی پیمائش کرتے ہیں۔

KV cache کتنی memory استعمال کرتا ہے؟

کسی vendor table کو تلاش کرنے کی ضرورت نہیں۔ سائز کا حساب ہے، جسے آپ کسی بھی model کے لیے دوبارہ کر سکتے ہیں:

bytes per token = 2 * layers * kv_heads * head_dim * bytes per element

2 کا تعلق key اور value دونوں سے ہے۔ باقی ہر عدد model کے config.json سے آتا ہے، جو model کے Hugging Face صفحے پر شائع ہوتا ہے۔

Llama 3.1 8B کو دیکھیں۔ اس کی config میں num_hidden_layers 32 اور num_key_value_heads 8 درج ہیں۔ 32 attention heads میں تقسیم hidden_size 4096 سے ہر head کی dimension 128 بنتی ہے۔ f16 میں ہر element 2 bytes کا ہوتا ہے:

2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per token

اسے مطلوبہ context کے سائز سے ضرب دیں، پھر بیک وقت چلائی جانے والی requests کی تعداد سے ضرب دیں۔

چارٹLlama 3.1 8B KV cache at f16, in GiB
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "2k context",
    "one_request_gib": 0.25,
    "four_requests_gib": 1
  },
  {
    "label": "8k context",
    "one_request_gib": 1,
    "four_requests_gib": 4
  },
  {
    "label": "32k context",
    "one_request_gib": 4,
    "four_requests_gib": 16
  },
  {
    "label": "128k context",
    "one_request_gib": 16,
    "four_requests_gib": 64
  }
]

8k context پر cache ایک request کے لیے 1 GiB ہے۔ 32k پر یہ 4 GiB ہے، جو خود 4-bit weights کے تقریباً اسی range میں ہے۔ model کے مکمل 128k context پر ایک request کے لیے یہ 16 GiB ہے، اور اگر چار requests میں سے ہر ایک پورا context بھر دے تو 64 GiB ہے۔ weights میں کوئی تبدیلی نہیں ہوئی۔ صرف cache کا سائز بدلا ہے۔

Grouped query attention (GQA) اس حساب میں اہم کردار ادا کرتی ہے۔ Llama 3.1 8B میں 8 key/value heads، 32 query heads کو service دیتے ہیں، اس لیے ہر چار query heads ایک ہی stored key/value pair شیئر کرتے ہیں۔ جس model کا num_key_value_heads، num_attention_heads کے برابر ہو، وہ اسی parameter count پر چار گنا cache استعمال کرتا ہے۔ یہ فرض کرنے سے پہلے کہ دو 8B models کو serve کرنے کی لاگت یکساں ہے، اس field کی تصدیق کریں۔

وہ model جو 2k پر چل گیا، 32k پر load کیوں نہیں ہوتا

Runtime model load کرتے وقت KV cache کے لیے memory reserve کرتا ہے۔ اس کا سائز آپ کی configured context length کے مطابق ہوتا ہے، نہ کہ اس prompt کے مطابق جو آپ حقیقت میں بھیجتے ہیں۔ Ollama کی default value اب ایک مقررہ number نہیں رہی۔ October 2026 تک اس کی context length documentation کے مطابق یہ value VRAM کی بنیاد پر مقرر ہوتی ہے: 24 GiB سے کم والی machines پر 4k، 24 اور 48 GiB کے درمیان 32k، اور 48 GiB یا اس سے زیادہ پر 256k۔ Cloud models کے لیے default ان کی maximum context length ہوتی ہے۔ CPU-only VPS یا چھوٹا GPU 4k سے شروع ہوتا ہے۔ اسے 32k تک بڑھانے پر، پہلا token آنے سے پہلے ہی آپ نے 4 GiB اضافی allocation طلب کر لی ہے۔ 24 GiB card پر 32k پہلے ہی default ہے، اس لیے یہ reservation آپ کے کہنے یا نہ کہنے سے قطع نظر ہو جاتی ہے۔

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Interactive prompt سے ہر session کے لیے یہی setting استعمال کریں:

ollama run llama3.1:8b
/set parameter num_ctx 32768

ہر stack میں failure مختلف دکھائی دیتی ہے۔ vLLM startup کے وقت حساب کی جانچ کرتا ہے اور چلنے سے انکار کر دیتا ہے:

ValueError: To serve at least one request with the model's max seq len (131072), (16.0 GiB KV cache is needed, which is larger than the available KV cache memory (9.56 GiB). Based on the available memory, the estimated maximum model length is 78336. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.

CPU-only VPS پر Ollama یا llama.cpp چلا رہے ہوں تو allocation عام system RAM سے ہوتی ہے، اور startup کے وقت memory کی کمی معلوم نہیں بھی ہو سکتی۔ اس کے بجائے kernel کا out-of-memory killer process کو terminate کر دیتا ہے، اور اس کا ثبوت kernel ring buffer میں رہ جاتا ہے:

dmesg -T | grep -i "killed process"

آپ کے serving process کا نام دکھانے والی line کا مطلب ہے کہ system نے اپنی دستیاب memory سے زیادہ memory کا وعدہ کیا تھا۔ حل یہ ہے کہ context چھوٹا کریں، نہ کہ swap file بڑی کریں۔ Disk پر paged KV cache ہر generated token کے وقت read ہوتی ہے، اس لیے generation اتنی سست ہو جاتی ہے کہ ناقابلِ استعمال رہتی ہے۔ مناسب number منتخب کرنے کا طریقہ Ollama میں num_ctx اور context length کے لیے ہماری guide میں دیا گیا ہے۔

تعداد پر concurrency کا اثر

ہر زیرِ تکمیل request اپنی KV cache رکھتی ہے۔ capacity planning میں عموماً یہی بات نظرانداز ہو جاتی ہے۔ 32k context رکھنے والے چار صارفین کو weights کے علاوہ مجموعی طور پر 16 GiB درکار ہوتے ہیں۔

اس معاملے میں runtimes کا رویہ مختلف ہوتا ہے۔ Ollama اور llama.cpp model load ہونے پر آپ کے مقرر کردہ context کے لیے memory reserve کرتے ہیں، اس لیے کوئی اسے استعمال کرے یا نہ کرے، memory commit ہو جاتی ہے۔ vLLM pool کو fixed-size blocks میں تقسیم کرتا ہے اور ہر request کے بڑھنے کے ساتھ blocks فراہم کرتا ہے، اس لیے 500-token request صرف 500 tokens کے برابر جگہ رکھتی ہے۔ دونوں صورتوں میں pool محدود ہوتا ہے۔ جب یہ بھر جائے تو نئی requests چلنے کے بجائے queue میں چلی جاتی ہیں۔ اس queueing سے response times پر کیا اثر پڑتا ہے، اس کی وضاحت self-hosted LLM کتنے concurrent users کو serve کر سکتا ہے میں کی گئی ہے۔

KV cache کو چھوٹا کرنے کے 4 طریقے

  1. Context length کم کریں۔ یہ سب سے مؤثر اور عموماً سب سے کم خرچ طریقہ ہے۔ زیادہ تر chat workloads کبھی بھی 32k کے قریب نہیں پہنچتے۔
  2. Cache کو خود quantise کریں۔ Ollama کا OLLAMA_KV_CACHE_TYPE بطور default f16 استعمال کرتا ہے اور q8_0 قبول کرتا ہے، جو تقریباً نصف memory استعمال کرتا ہے، نیز q4_0، جو تقریباً ایک چوتھائی memory استعمال کرتا ہے۔ llama.cpp میں اس کے مساوی options -ctk q8_0 اور -ctv q8_0 ہیں۔
  3. کم key/value heads یا کم layers والا model منتخب کریں۔ 40 GB weights download کرنے سے پہلے config.json پڑھیں۔
  4. ایک وقت میں کم requests serve کریں اور باقی کو queue میں رکھیں۔

q4_0 پر Llama 3.1 8B کی قدر 128 KiB فی token سے کم ہو کر تقریباً 32 KiB رہ جاتی ہے، اس لیے 32k context کی لاگت 4 GiB کے بجائے تقریباً 1 GiB ہوتی ہے۔ یہ بچت بلا قیمت نہیں ہے۔ Keys اور values کم precision کے ساتھ محفوظ ہوتے ہیں، اس لیے اسے برقرار رکھنے سے پہلے اپنی prompts پر output کا موازنہ کریں۔

Provider prompt caching سے اصل میں کیا فائدہ ہوتا ہے

Provider prompt caching ایک مختلف product ہے، جس میں حساب کی اکائی بھی مختلف ہوتی ہے۔ آپ ایک مستحکم prefix کو نشان زد کرتے ہیں، provider اسے محفوظ کرتا ہے، اور بعد کی وہ calls جو بالکل اسی prefix کو دہراتی ہیں، مکمل input price کے بجائے کم rate پر bill ہوتی ہیں۔

October 2026 تک Anthropic کے شائع کردہ multipliers یہ ہیں: 5-minute cache write کی لاگت base input token price سے 1.25 گنا ہوتی ہے۔ 1-hour write کی لاگت 2 گنا ہوتی ہے، جبکہ زیادہ تر models میں cache read کی لاگت 0.1 گنا ہوتی ہے۔ نئے models میں read کی لاگت مزید کم ہے: Claude Opus 5.5 اور Sonnet 5.5 پر 0.05 گنا، اور Claude Fable 5.1 اور Mythos 5.1 پر 0.025 گنا۔ اگر 20,000-token system prompt کو standard numbers کے تحت رکھیں تو اس سودے کی صورتِ حال واضح ہو جاتی ہے۔

چارٹCost of a 20,000 token prefix, in base input token equivalents
اس چارٹ کے پیچھے کا ڈیٹا
[
  {
    "label": "No caching, every call",
    "billed_token_equivalents": "20,000"
  },
  {
    "label": "First call, 5 minute cache write",
    "billed_token_equivalents": "25,000"
  },
  {
    "label": "First call, 1 hour cache write",
    "billed_token_equivalents": "40,000"
  },
  {
    "label": "Every later call, cache hit",
    "billed_token_equivalents": "2,000"
  }
]

اسے حساب کے طور پر سمجھیں۔ 5-minute write کا اضافی خرچ پہلی call پر 5,000 token equivalents ہے: 25,000، جبکہ اسے uncached بھیجنے پر 20,000 خرچ ہوتے۔ window کے اندر ہر بعد کی call پر 2,000 bill ہوتے ہیں، 20,000 کے بجائے؛ یعنی 18,000 کی بچت ہوتی ہے۔ اس لیے 5-minute cache دوسری call سے آگے فائدہ مند ہو جاتی ہے۔

1-hour cache ایک مختلف انتخاب ہے۔ write پر 40,000 bill ہوتے ہیں، یعنی 20,000 token equivalents کا اضافی خرچ۔ اس لیے فائدہ مند ہونے کے لیے ایک گھنٹے کے اندر دو hits درکار ہوتی ہیں۔ یہ سوال آپ کے traffic pattern سے متعلق ہے، model سے نہیں۔ مکمل حساب، بشمول window منتخب کرنے کا طریقہ، Claude prompt caching کے لیے break-even math میں موجود ہے۔

دو تفصیلات طے کرتی ہیں کہ cache hit حاصل بھی ہوگی یا نہیں۔ پہلی یہ کہ model کی minimum length سے کم prefix خاموشی سے cache نہیں کیا جاتا: October 2026 تک documented minimum، Claude Opus 5، Opus 5.5 اور Sonnet 5.5 کے لیے 512 tokens، جبکہ Claude Sonnet 5 کے لیے 1,024 tokens ہے۔ اس سے مختصر request معمول کے مطابق process ہوتی ہے اور کوئی error واپس نہیں آتا۔ دوسری یہ کہ lifetime اس request کے آغاز سے ناپی جاتی ہے جو entry کو write یا read کرتی ہے، اور ہر read اسے بغیر اضافی لاگت کے refresh کر دیتی ہے۔ اس لیے ایک مصروف endpoint 5-minute cache کو غیر معینہ مدت تک زندہ رکھ سکتا ہے۔ ہر دس منٹ میں ایک بار call ہونے والا endpoint ہر مرتبہ write premium ادا کرتا ہے اور کبھی فائدہ حاصل نہیں کرتا۔

اندازہ لگانے کے بجائے response کی جانچ کریں۔ usage object، cache_creation_input_tokens اور cache_read_input_tokens report کرتا ہے۔ ہر call پر read count صفر ہونے کا مطلب ہے کہ آپ writes خرید رہے ہیں اور بدلے میں کچھ حاصل نہیں کر رہے۔

جہاں دونوں caches ایک دوسرے سے ملتے ہیں

ایک طویل system prompt وہ مقام ہے جہاں یہ دونوں ملتے ہیں، اور یہ بیک وقت دونوں جانب آپ سے لاگت وصول کرتا ہے۔

مقامی طور پر، f16 پر Llama 3.1 8B server میں 20,000-token system prompt تقریباً 2.4 GiB KV cache استعمال کرتا ہے، اور اسے شامل کرنے والی ہر concurrent request کے لیے الگ جگہ درکار ہوتی ہے۔ دور دراز provider کے معاملے میں، یہی prefix پہلی بار ایک cache write کی لاگت رکھتا ہے، پھر ہر بعد کی call پر input کا 0.1 گنا خرچ ہوتا ہے، یا نئے models میں اس سے بھی کم۔ مقامی لاگت users کی تعداد کے ساتھ بڑھتی ہے۔ دور دراز لاگت traffic کے ساتھ بڑھتی ہے اور idle time کے دوران reset ہو جاتی ہے۔

ایک مقامی feature ہے جو provider prompt caching جیسا دکھائی دیتا ہے اور اکثر اس کے ساتھ خلط ملط ہو جاتا ہے: prefix caching۔ vLLM documentation automatic prefix caching کو موجودہ queries کے "KV cache کو cache کرنے" کے طور پر بیان کرتی ہے، تاکہ نئی query موجودہ query کے KV cache کو براہ راست reuse کر سکے، اگر اس کا prefix موجودہ queries میں سے کسی ایک کے prefix کے ساتھ یکساں ہو۔ موجودہ vLLM میں یہ default طور پر فعال ہے۔ llama.cpp server بھی default طور پر ہر slot کے لیے prompt cache برقرار رکھتا ہے، اور --cache-reuse N اس کم از کم chunk کا تعین کرتا ہے جسے یہ دوبارہ استعمال کرنے کی کوشش کرے گا۔

prefix caching جس چیز کو محفوظ کرتی ہے وہ prefill compute ہے۔ آپ کا 20,000-token system prompt ہر request پر دوبارہ process ہونے کے بجائے ایک بار process ہوتا ہے، جس سے first token تک کا وقت نمایاں طور پر کم ہو جاتا ہے۔ vLLM میں shared blocks کو duplicate کرنے کے بجائے دوبارہ استعمال کیا جاتا ہے، اس لیے memory usage بھی بہتر ہوتی ہے۔ لیکن یہ کبھی بھی اس cache کو کم نہیں کرتی جسے اس وقت live موجود tokens کے لیے برقرار رکھنا ضروری ہے۔ Requests کے درمیان weights کو resident رکھنا ایک متعلقہ مگر الگ طریقہ ہے، جس کی وضاحت Ollama model کو requests کے درمیان loaded رکھنا میں کی گئی ہے۔

اپنے سرور پر کیا ناپیں

ماڈل کو اپنے مطلوبہ context کے ساتھ load کریں، پھر تخمینے پر بھروسا کرنے کے بجائے حقیقی اعداد دیکھیں۔

ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -g

ollama ps loaded model، اس کے size، load کیے گئے context، اور یہ کہ وہ GPU یا CPU پر چل رہا ہے، کی فہرست دکھاتا ہے۔ پہلے context column چیک کریں، کیونکہ اب default آپ کے VRAM پر منحصر ہوتا ہے۔ اگر آپ کو توقع تھی کہ ماڈل مکمل طور پر GPU پر رہے گا، لیکن رپورٹ میں CPU split دکھائی دے، تو اس کا مطلب ہے کہ KV cache نے ماڈل کے ایک حصے کو GPU سے باہر دھکیل دیا ہے، اور generation speed اسی کے مطابق کم ہو جائے گی۔ nvidia-smi اصل VRAM figure دیتا ہے، جبکہ free -g CPU-only VPS پر یہی کام کرتا ہے۔ context کو مرحلہ وار بڑھائیں، ماڈل دوبارہ load کریں، اور دیکھیں کہ number کیسے بدلتا ہے۔ آپ کے حساب اور رپورٹ کیے گئے figure کا نتیجہ ایک دوسرے کے قریب ہونا چاہیے۔ جب ایسا نہ ہو، تو فرق عموماً runtime کے اپنے compute buffers کی وجہ سے ہوتا ہے، نہ کہ formula میں کسی error کی وجہ سے۔

اگر یہ اعداد آپ کو ایسے hardware کی طرف لے جائیں جسے آپ rent نہیں کرنا چاہتے، تو per-token ادائیگی کے ساتھ موازنہ GPU VPS بمقابلہ API tokens میں دیا گیا ہے۔

FAQ

کیا KV cache اور prompt caching ایک ہی چیز ہیں؟

نہیں۔ KV cache serving process کے اندر ہر request کے لیے مختص memory ہے۔ اس میں موجودہ context کے ہر token کے key اور value vectors محفوظ ہوتے ہیں۔ یہ آپ کی RAM یا VRAM میں رہتی ہے اور request ختم ہونے پر release ہو جاتی ہے۔ Provider prompt caching ایک billing feature ہے۔ یہ provider کے infrastructure پر ایک مستحکم prompt prefix محفوظ کرتی ہے اور جب آپ اسے دوبارہ بھیجتے ہیں تو کم rate وصول کرتی ہے۔ KV cache ختم ہونے سے model load ہونا رک جاتا ہے۔ Prompt cache نہ ملنے سے صرف آپ کا invoice اور پہلے token تک پہنچنے کا وقت بڑھتا ہے۔

میرا model 2k context پر load ہوتا ہے لیکن 32k پر fail کیوں ہوتا ہے؟

کیونکہ runtime load کے وقت پورا KV cache allocate کرتا ہے۔ اس کا سائز اس context length کے مطابق ہوتا ہے جسے آپ نے configure کیا ہے، نہ کہ اس prompt کے مطابق جو آپ بھیجتے ہیں۔ Llama 3.1 8B کے لیے f16 پر cache فی token 128 KiB ہے۔ اس لیے 2k context کی لاگت 0.25 GiB اور 32k کی لاگت 4 GiB ہے۔ دونوں صورتوں میں weights memory میں fit ہو جاتے ہیں۔ ناکامی reservation کے وقت ہوتی ہے۔ vLLM اسے ValueError کے طور پر report کرتا ہے، جس میں بتایا جاتا ہے کہ اسے کتنی KV cache memory درکار ہے اور اس کے پاس کتنی موجود ہے، ساتھ estimated maximum model length بھی دی جاتی ہے۔ یہ gpu_memory_utilization بڑھانے یا max_model_len کم کرنے کی تجویز دیتا ہے۔ CPU-only box پر Ollama یا llama.cpp چلاتے وقت kernel out-of-memory killer اس کے بجائے process کو terminate کر سکتا ہے۔ آپ dmesg -T | grep -i "killed process" سے اس کی تصدیق کر سکتے ہیں۔

میں اپنے model کے لیے KV cache size کیسے calculate کروں؟

Layer count، key/value heads کی تعداد، head dimension، اور فی element bytes کو 2 سے ضرب دیں۔ اس سے فی token bytes حاصل ہوتے ہیں۔ پھر اسے اپنے context length اور concurrent requests کی تعداد سے ضرب دیں۔ Layer اور head counts model کے config.json سے پڑھیں۔ f16 یا bf16 کے لیے فی element 2 bytes استعمال کریں۔ q8_0 cache تقریباً اس کا نصف، جبکہ q4_0 تقریباً ایک چوتھائی ہوتی ہے۔

کیا prompt caching میرے اپنے server کو درکار memory کم کرتی ہے؟

Provider prompt caching آپ کے hardware کے لیے کچھ نہیں کرتی، کیونکہ storage provider کی جانب موجود ہوتی ہے۔ مقامی متبادل prefix caching ہے، جو vLLM اور llama.cpp server دونوں فراہم کرتے ہیں۔ یہ shared prefix کے لیے پہلے سے calculate کیے گئے key اور value vectors دوبارہ استعمال کرتی ہے۔ اس سے prefill compute کی بچت ہوتی ہے اور پہلے token تک پہنچنے کا وقت کم ہوتا ہے۔ vLLM میں shared blocks duplicate کرنے کے بجائے دوبارہ استعمال کیے جاتے ہیں، اس لیے memory utilization بھی بہتر ہوتی ہے۔ دونوں features اس وقت in-flight tokens کے لیے درکار cache کو کم نہیں کرتے۔ اس لیے آپ کا context اور concurrency arithmetic اب بھی کم از کم ضرورت متعین کرتا ہے۔

کیا ایسے prompt کو cache کرنا فائدہ مند ہے جسے میں صرف ایک بار بھیجوں گا؟

نہیں۔ Cache write کی لاگت plain input سے زیادہ ہوتی ہے۔ October 2026 تک 5-minute option کے لیے یہ base rate سے 1.25 گنا ہے۔ اس لیے ایسا prefix جسے آپ window کے اندر دوبارہ کبھی send نہ کریں، براہ راست نقصان ہے۔ Caching اس وقت فائدہ دیتی ہے جب وہی prefix بار بار آئے، مثلاً ایک طویل system prompt یا ایسی document جس کے بارے میں آپ کئی سوالات پوچھیں گے۔ API response میں cache_read_input_tokens دیکھ کر تصدیق کریں کہ آپ کو hits مل رہے ہیں، نہ کہ writes کے لیے ادائیگی ہو رہی ہے۔

کیا یہ مضمون مفید تھا؟