Claude prompt caching: break-even کب ہوتا ہے؟
Cache write کی لاگت 1.25x، read 0.1x یا کم ہے، اس لیے prefix دوسری بار استعمال پر فائدہ دیتا ہے۔ اپنا break-even حساب کریں اور API سے تصدیق کریں۔
بچت شروع ہونے سے پہلے prompt caching کی لاگت
Prompt caching آپ کے prompt کے ابتدائی حصے کو ہر call پر دوبارہ پڑھنے کے بجائے Claude کو اسے دوبارہ استعمال کرنے دیتا ہے۔ پورا فیصلہ آپ کے model کی بنیادی input price پر لاگو ہونے والے دو multipliers پر منحصر ہے۔ October 2026 تک، cache write کی لاگت 5 minute lifetime کے لیے base input کی 1.25x، یا 1 hour lifetime کے لیے 2x ہے، اور یہ شرح ہر model پر یکساں ہے۔ زیادہ تر models میں cache read کی لاگت 0.1x ہے، لیکن read multiplier اب ہر جگہ یکساں نہیں رہا۔ Claude Fable 5.1 اور Claude Mythos 5.1 میں یہ 0.025x ہے؛ یہ دونوں models September 1, 2026 کو اسی شرح کے ساتھ جاری ہوئے تھے۔ Claude Opus 5.5 اور Claude Sonnet 5.5 میں یہ 0.05x ہے، اور Sonnet 5.5 کے لیے یہ شرح October 7, 2026 کو 0.1x سے کم کر کے 0.05x کی گئی تھی۔ ذیل کی مثالوں میں معمول کی 0.1x read شرح استعمال کی گئی ہے۔ کم read rates break-even کو معمولی طور پر آپ کے حق میں منتقل کرتی ہیں، اور اگلا section بتاتا ہے کہ یہ فرق کتنا ہے۔
یہ معاملہ موجودہ اضافی لاگت اور بعد کی رعایت کے درمیان ہے۔ prefix محفوظ کرنے کے لیے آپ ایک بار اضافی ادائیگی کرتے ہیں۔ اس کے بعد ہر request جو بالکل انہی bytes سے شروع ہوتی ہے، اس حصے کے لیے معمول کی input price کا دسواں حصہ ادا کرتی ہے، یا اوپر بیان کردہ models میں اس سے بھی کم۔ اگر کسی prefix کو اس کی lifetime کے اندر دوبارہ استعمال نہ کیا جائے تو اس پر 25 percent اضافی ادائیگی بلا فائدہ ہوتی ہے۔
الجبر کی ایک سطر میں break-even
اگر prefix کو cache کے بغیر بھیجا جائے تو اس کی بنیادی input cost کو B کہیں۔ Caching کے بغیر N requests کی لاگت N گنا B ہوگی۔ 5 minute cache کے ساتھ پہلی request prefix کو 1.25B پر لکھتی ہے، جبکہ باقی N minus 1 requests اسے 0.1B پر پڑھتی ہیں۔ دونوں کو برابر رکھنے پر 0.9N = 1.15 حاصل ہوتا ہے، لہٰذا N = 1.28۔ دوسری request ہی caching نہ کرنے کے مقابلے میں سستی ہو جاتی ہے۔
1 hour cache کی 2x write کے ساتھ یہی حساب دہرائیں تو 0.9N = 1.9 حاصل ہوتا ہے، لہٰذا N = 2.11۔ طویل cache کو break-even تک پہنچنے کے لیے دو reads درکار ہوتی ہیں، اسی لیے یہ default انتخاب نہیں ہے۔
سستی reads پر یہ حد بدلتی ہے، لیکن زیادہ نہیں۔ 0.05x read پر 5 minute cache کے لیے 0.95N = 1.2 حاصل ہوتا ہے، لہٰذا N = 1.26، اور 0.025x پر 0.975N = 1.225، یعنی پھر بھی N = 1.26۔ 1 hour cache کے لیے یہ قدریں N = 2.05 اور N = 2.03 تک آ جاتی ہیں۔ عملی نتیجہ ہر model میں ایک ہی ہے: 5 minute cache دوسری request سے فائدہ دیتی ہے، جبکہ 1 hour cache تیسری request سے۔
نیچے دیا گیا chart Claude Opus 5 پر 20,000 token prefix کی لاگت دکھاتا ہے۔ October 2026 تک اس کی بنیادی input rate $5 per million tokens ہے، اور August کے بعد سے اس میں کوئی تبدیلی نہیں ہوئی۔ Opus 5 اب legacy model ہے، اگرچہ یہ اب بھی دستیاب ہے۔ اس کے successor، Claude Opus 5.5، کی قیمت $4 per million ہے اور read rate 0.05x ہے، اس لیے وہاں اسی prefix کو لکھنے کی لاگت $0.10 اور پڑھنے کی لاگت $0.004 ہے۔ standard 0.1x read پر $3 per million model کے لیے ہر figure کو 0.6 سے ضرب دیں۔ curve کی شکل تبدیل نہیں ہوتی۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"requests": 1,
"uncached_usd": "0.10",
"cached_5m_usd": "0.125",
"cached_1h_usd": "0.20"
},
{
"requests": 2,
"uncached_usd": "0.20",
"cached_5m_usd": "0.135",
"cached_1h_usd": "0.21"
},
{
"requests": 3,
"uncached_usd": "0.30",
"cached_5m_usd": "0.145",
"cached_1h_usd": "0.22"
},
{
"requests": 5,
"uncached_usd": "0.50",
"cached_5m_usd": "0.165",
"cached_1h_usd": "0.24"
},
{
"requests": 10,
"uncached_usd": "1.00",
"cached_5m_usd": "0.215",
"cached_1h_usd": "0.29"
},
{
"requests": 20,
"uncached_usd": "2.00",
"cached_5m_usd": "0.315",
"cached_1h_usd": "0.39"
}
]ایک request کی اپنی لاگت caching کے بغیر $0.10 اور caching کے ساتھ $0.125 ہے، اس لیے one-shot prompt کو cache کرنا خالص خسارہ ہے۔ دوسری request تک 5 minute cache کی لاگت $0.135 ہو جاتی ہے، جبکہ caching کے بغیر لاگت $0.20 ہے۔ اس مرحلے پر 1 hour cache اب بھی مہنگی ہے: اس کی لاگت $0.21 کے مقابلے میں وہی $0.20 ہے۔ یہ تیسری request پر ہی uncached line سے آگے نکلتی ہے: $0.22 کے مقابلے میں $0.30۔ 20 requests تک فرق $2.00 کے مقابلے میں $0.315 ہے۔
Cache hit entry کو دوبارہ refresh بھی کرتا ہے، اسی لیے published price table میں اس column کا نام cache hits and refreshes ہے۔ چنانچہ مصروف endpoint 5 minute entry کو read prices پر غیر معینہ مدت تک برقرار رکھ سکتا ہے، جبکہ 1 hour lifetime کی 2x write صرف اسی وقت فائدہ دیتی ہے جب آپ کے traffic میں واقعی وقفے ہوں۔
کم hit rate کی لاگت
حقیقی network traffic میں cache misses ہوتی ہیں۔ جو request cache سے miss ہو جائے لیکن پھر بھی breakpoint رکھتی ہو، اسے write کے طور پر charge کیا جاتا ہے۔ اس لیے لاگت کو hit rate کے تابع model کرنا ہی درست طریقہ ہے۔ ذیل کا chart 1,000 requests کے لیے یہی دکھاتا ہے، اور ہر request میں وہی 20,000 token prefix شامل ہے۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"hit_rate_percent": 0,
"cost_5m_usd": "125.00",
"cost_1h_usd": "200.00",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 25,
"cost_5m_usd": "96.25",
"cost_1h_usd": "152.50",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 50,
"cost_5m_usd": "67.50",
"cost_1h_usd": "105.00",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 75,
"cost_5m_usd": "38.75",
"cost_1h_usd": "57.50",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 90,
"cost_5m_usd": "21.50",
"cost_1h_usd": "29.00",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 95,
"cost_5m_usd": "15.75",
"cost_1h_usd": "19.50",
"uncached_usd": "100.00"
},
{
"hit_rate_percent": 99,
"cost_5m_usd": "11.15",
"cost_1h_usd": "11.90",
"uncached_usd": "100.00"
}
]0 percent hit rate پر آپ $125.00 ادا کرتے ہیں، جبکہ uncached لاگت $100.00 ہے۔ 1 hour cache bill کو دوگنا کر کے $200.00 کر دیتا ہے۔ 1.25 minus 1.15h = 1 حل کرنے پر معلوم ہوتا ہے کہ 5 minute cache تقریباً 22 percent hit rate پر لاگت کم کرنا شروع کرتا ہے۔ اسی لیے 25 percent پر بھی لاگت $96.25 دکھائی دیتی ہے۔ 2x write پر یہی حساب 1 hour cache کے لیے تقریباً 53 percent بنتا ہے۔ اس لیے 50 percent hit rate پر بھی لاگت $105.00 رہتی ہے، جو uncached line سے زیادہ ہے۔ 90 percent پر دونوں بالترتیب $21.50 اور $29.00 تک پہنچتے ہیں۔ 99 percent پر short cache $11.15 تک پہنچ جاتا ہے، جو uncached price کے ایک دسویں حصے کی floor کے قریب ہے۔
0.05x read والے model میں thresholds 5 minute cache کے لیے تقریباً 21 percent اور 1 hour cache کے لیے 51 percent رہ جاتے ہیں۔ 0.025x read پر یہ تقریباً 20 اور 51 percent رہ جاتے ہیں۔ read price کم ہونے کے ساتھ floor بھی کم ہو جاتی ہے، یعنی uncached cost کے ایک بیسویں یا ایک چالیسویں حصے تک۔
Hit rate وہ عدد ہے جسے instrument کرنا چاہیے، کیونکہ prefix size طے ہونے کے بعد یہی واحد input ہے جسے آپ control کر سکتے ہیں۔
کون سے prefixes کے لیے breakpoint قابلِ قدر ہے
ایک request میں زیادہ سے زیادہ چار cache breakpoints شامل ہو سکتے ہیں، اس لیے سوال یہ ہے کہ کون سے blocks اس کے مستحق ہیں۔ امیدوار وہ blocks ہیں جو مختلف calls میں byte-identical ہوں اور اتنے بڑے ہوں کہ ان کا اثر نمایاں ہو۔ ذیل کا chart 5 minute cache پر 90 percent hit rate کے ساتھ 1,000 requests میں چار عام shapes کی لاگت دکھاتا ہے۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"label": "System prompt",
"prefix_size_tokens": "2,000",
"uncached_usd": "10.00",
"cached_usd": "2.15",
"saved_usd": "7.85"
},
{
"label": "System plus tools",
"prefix_size_tokens": "8,000",
"uncached_usd": "40.00",
"cached_usd": "8.60",
"saved_usd": "31.40"
},
{
"label": "Policy document",
"prefix_size_tokens": "25,000",
"uncached_usd": "125.00",
"cached_usd": "26.88",
"saved_usd": "98.12"
},
{
"label": "Codebase context",
"prefix_size_tokens": "120,000",
"uncached_usd": "600.00",
"cached_usd": "129.00",
"saved_usd": "471.00"
}
]صرف 2,000 token کا system prompt، $7.85 کی بچت کرتا ہے، جبکہ uncached لاگت $10.00 ہے۔ زیادہ volume پر یہ حقیقی رقم بنتی ہے، لیکن caching کی اہمیت کی اصل وجہ یہ نہیں۔ Tool definitions شامل کرنے پر آپ 8,000 tokens تک پہنچتے ہیں اور $31.40 کی بچت ہوتی ہے۔ 25,000 tokens کی ایسی policy document، جس کے بارے میں ہر request سوالات کرتی ہے، $98.12 کی بچت کرتی ہے۔ آخری row architecture تبدیل کرتی ہے: codebase یا transcript context کے 120,000 tokens کی uncached لاگت $600.00 اور cached لاگت $129.00 ہے، یعنی $471.00 کی بچت۔
بچت prefix کے size اور hit rate کے ساتھ بڑھتی ہے، اور کسی دوسری چیز کے ساتھ نہیں۔ اس سے یہ بھی بدل جاتا ہے کہ prompt میں کیا شامل کرنا قابلِ قدر ہے: Claude کے دس لاکھ tokens کی اصل لاگت اس قیمت کے دسویں حصے تک، یا اس سے بھی کم، آ جاتی ہے، کیونکہ کچھ models میں reads کی لاگت کم ہے، بشرطیکہ آپ اسے ایک سے زیادہ مرتبہ بھیجیں۔
ماہانہ بل میں یہ کس طرح نظر آتا ہے
ذیل کا چارٹ اوپر موجود 8,000 token prefix، system prompt اور tool definitions کو 90 فیصد hit rate کے ساتھ لیتا ہے اور اسے ماہانہ requests کے حجم پر لاگو کرتا ہے۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"label": "10k requests",
"uncached_usd": "400.00",
"cached_usd": "86.00",
"saved_usd": "314.00"
},
{
"label": "100k requests",
"uncached_usd": "4,000.00",
"cached_usd": "860.00",
"saved_usd": "3,140.00"
},
{
"label": "1M requests",
"uncached_usd": "40,000.00",
"cached_usd": "8,600.00",
"saved_usd": "31,400.00"
}
]10,000 requests ماہانہ ہونے پر بچت $314.00 ہے۔ یہ $400.00 اور $86.00 کے درمیان فرق ہے۔ 100,000 requests پر بچت $3,140.00 ہے۔ 1 million requests پر uncached input bill $40,000.00 ہے، اور caching اس میں سے $31,400.00 ختم کر دیتی ہے۔ یہ صرف input tokens ہیں۔ Output کی قیمت الگ مقرر ہوتی ہے، اور caching اس پر کوئی اثر نہیں ڈالتی۔ اس بات کو یاد رکھیں، خاص طور پر اس سے پہلے کہ آپ کسی کو بل میں 90 فیصد کمی کا وعدہ کریں۔ Caching ان وسیع تر طریقوں کے ساتھ مل کر کام کرتی ہے جو VPS پر AI agent کا بل قابو میں رکھنے کے لیے استعمال ہوتے ہیں۔
کیش کے کام کرنے کا ثبوت کیسے حاصل کریں
ڈیزائن پر بھروسا نہ کریں۔ جواب میں usage block پڑھیں۔ ہر Messages API (application programming interface) جواب ان cached tokens کی تعداد بتاتا ہے جو اس نے لکھے، ان cached tokens کی تعداد بتاتا ہے جو اس نے پڑھے، اور ان fresh tokens کی تعداد بتاتا ہے جنہیں اسے process کرنا پڑا۔
from anthropic import Anthropic
client = Anthropic()
resp = client.messages.create(
model="claude-opus-5",
max_tokens=512,
system=[
{
"type": "text",
"text": POLICY_DOCUMENT,
"cache_control": {"type": "ephemeral"},
}
],
messages=[{"role": "user", "content": question}],
)
u = resp.usage
print("write:", u.cache_creation_input_tokens)
print("read: ", u.cache_read_input_tokens)
print("fresh:", u.input_tokens)اسی document کے ساتھ، لیکن مختلف سوال کے ساتھ اسے 2 بار چلائیں۔ پہلی call میں cache_creation_input_tokens کی non-zero قدر اور cache_read_input_tokens کی صفر قدر رپورٹ ہوگی۔ دوسری call میں اس کے برعکس ہوگا، کیونکہ prefix مل چکا تھا۔ input_tokens صرف آخری breakpoint کے بعد موجود tokens کو شمار کرتا ہے، اس لیے کامیاب دوسری call میں یہ قدر کم ہوتی ہے، عموماً صرف نیا user message۔ دونوں calls کا بل بنتا ہے، کیونکہ Claude API کا کوئی free tier نہیں ہے، اگرچہ اوپر بیان کردہ 20,000 token prefix پر یہ جوڑی تقریباً 14 cents کی بنتی ہے۔
محفوظ کیے گئے request body کے خلاف shell سے یہی جانچ request.json پر کریں:
curl -s https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d @request.json | jq '.usage'صحت مند دوسری call تقریباً اس طرح کا output دیتی ہے:
{
"input_tokens": 42,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 20143,
"output_tokens": 187
}ایک line اصل صورتِ حال بتاتی ہے۔ اگر calls کے دوران cache_read_input_tokens مسلسل 0 رہے تو آپ ہر بار 1.25x write کی قیمت ادا کر رہے ہیں اور اس کے بدلے کچھ بھی واپس نہیں مل رہا۔
1 hour lifetime کے لیے breakpoint میں time to live (TTL) شامل ہوتا ہے:
{
"type": "text",
"text": "your stable prefix",
"cache_control": {"type": "ephemeral", "ttl": "1h"}
}خودکار caching بھی دستیاب ہے: request کی top level پر ایک واحد cache_control field شامل کریں، جس کے بعد API conversation کے بڑھنے کے ساتھ breakpoints خود manage کرتی ہے۔ یہ آپ کے 4 breakpoint slots میں سے ایک استعمال کرتا ہے۔ ابتدا اسی سے کریں۔ جب آپ کو boundary کی درست جگہ خود متعین کرنی ہو تو explicit breakpoints استعمال کریں۔
وہ ترتیب کا اصول جو hit rates ختم کر دیتا ہے
Cache درخواست کے آغاز سے byte بہ byte prefix کو match کرتا ہے، اور درخواست ایک مقررہ ترتیب میں تیار ہوتی ہے: tools، پھر system، پھر messages۔ کسی بھی سطح پر تبدیلی اس سطح اور اس کے بعد آنے والی ہر چیز کو invalid کر دیتی ہے۔ ایک tool کی description میں ترمیم کرنے سے system prompt اور message history بھی invalid ہو جاتی ہے، حالانکہ آپ نے انہیں تبدیل نہیں کیا ہوتا۔
اس سے ایک ایسا اصول حاصل ہوتا ہے جس میں کوئی استثنا نہیں۔ جو چیز calls کے درمیان تبدیل ہوتی ہے، وہ ہر اس چیز کے بعد آنی چاہیے جو تبدیل نہیں ہوتی۔
عام مسئلہ timestamp ہوتا ہے۔ system prompt کے آغاز میں Current time: 2026-08-03T14:07:11Z والی سطر 0 percent hit rate کی ضمانت دیتی ہے، کیونکہ prefix hash ہر call پر مختلف ہوتا ہے اور کوئی بھی سابقہ entry اس سے match نہیں کر سکتی۔ اسے user message کے آخر میں منتقل کریں۔ session identifier یا per-request nonce بھی اسی طرح مسئلہ پیدا کرتا ہے اور اس کا حل بھی یہی ہے۔ وہ retrieved documents جو ہر request کے لیے مختلف ہوں، cached block کے بعد ہونے چاہییں؛ بصورت دیگر وہ ہر stable token کو ایک بدلتی ہوئی boundary کے پیچھے دھکیل دیتے ہیں۔
دوسرا مسئلہ breakpoint کو اس block پر رکھنا ہے جو تبدیل ہوتا رہتا ہے۔ Cache writes breakpoint پر ہوتی ہیں، اس لیے اگر وہ block ہر بار مختلف ہو تو کوئی بھی مستحکم مواد محفوظ نہیں ہوتا، اور lookback کو صرف وہ entries ملتی ہیں جو سابقہ requests نے اپنی بدلتی ہوئی breakpoints پر لکھی تھیں۔ cache_control کو اس آخری block پر رکھیں جس کا content تمام requests میں یکساں ہو۔
تیسرا مسئلہ ایسا parameter change ہے جسے آپ prompt content نہیں سمجھتے۔ مختلف model کا cache بھی مختلف ہوتا ہے۔ tool_choice تبدیل کرنے سے message history invalid ہو جاتی ہے، اگرچہ tools اور system prompt cached رہتے ہیں۔ کسی tool کو شامل یا حذف کرنے سے ہر چیز invalid ہو جاتی ہے۔
کم از کم prefix، اور خاموش no-op
model کی کم از کم حد سے چھوٹا prefix cache نہیں ہوتا، اور آپ کو اس کا کوئی اشارہ نہیں ملتا۔ نہ error، نہ warning۔ request کامیاب ہو جاتی ہے، اور دونوں counters کی قدر 0 رہتی ہے۔ اکتوبر 2026 تک شائع شدہ کم از کم حدود یہ ہیں:
- Claude Opus 5، Claude Fable 5، اور نئے Opus 5.5، Sonnet 5.5، Fable 5.1 اور Haiku 5.5 پر 512 tokens
- Claude Sonnet 5 اور Claude Opus 4.8 پر 1,024 tokens
- Claude Haiku 4.5 پر 4,096 tokens
اگر کسی request میں دونوں counters کی قدر 0 ہو، حالانکہ آپ سمجھتے ہوں کہ وہ cached ہے، تو سب سے پہلے prefix کی لمبائی چیک کریں۔ یہی وجہ ہے کہ caching workload کے لیے سب سے کم قیمت model خودکار طور پر سب سے کم لاگت والا نہیں ہوتا۔ Haiku 4.5 کو caching شروع ہونے کے لیے Opus 5 کے مقابلے میں آٹھ گنا زیادہ طویل prefix درکار ہوتا ہے۔ اس لیے 2,000 tokens کا system prompt ایک model پر cache ہو جاتا ہے، جبکہ دوسرے پر خاموشی سے نظر انداز کر دیا جاتا ہے۔
Claude Code آپ کے لیے کہاں cache بناتا ہے، اور کہاں مدد نہیں کر سکتا
Claude Code اپنے prefix کو cache کرتا ہے۔ system prompt اور tool definitions ہر request کے آغاز میں موجود رہتے ہیں اور تبدیل نہیں ہوتے، اس لیے انہیں ایک بار لکھا جاتا ہے اور session کے باقی حصے میں دوبارہ پڑھا جاتا ہے۔ اسی وجہ سے طویل session میں ہر turn کی لاگت، context size سے ظاہر ہونے والی لاگت کے مقابلے میں بہت کم ہوتی ہے۔ یہ بات ان counters میں بھی نظر آتی ہے جن کی وضاحت Claude Code token usage کیسے ظاہر کرتا ہے میں کی گئی ہے۔
یہ cache اس وقت مدد نہیں کر سکتا جب context کے آغاز کے قریب کوئی تبدیلی ہو۔ Conversation history صرف append-only ہوتی ہے، اس لیے عام نئے turns پہلے سے cached prefix میں اضافہ کرتے ہیں۔ اگر session کے آغاز میں پڑھی گئی file میں ترمیم کی جائے تو cache متاثر نہیں ہوتا، کیونکہ Claude Code پہلے پڑھے گئے متن کو دوبارہ لکھنے کے بجائے صرف یہ note شامل کرتا ہے کہ file تبدیل ہو گئی ہے۔ البتہ model تبدیل کرنے سے cache ٹوٹ جاتا ہے، کیونکہ ہر model کا اپنا cache ہوتا ہے۔ ایسا MCP server connect کرنے سے بھی ہوتا ہے جس کے tools prefix میں load ہوتے ہیں، اور conversation compact کرنے سے بھی۔ ان میں سے ہر عمل اگلے turn میں prefix کو دوبارہ لکھنے کا سبب بنتا ہے۔ طویل idle gap بھی یہی اثر ڈالتا ہے، کیونکہ cache entry expire ہو جاتی ہے اور اگلے turn میں مکمل write کی لاگت ادا کرنی پڑتی ہے۔ ان میں سے کوئی بھی bug نہیں ہے۔ یہ prefix rule کے عین مطابق ہوتا ہے۔
اگر آپ اس کے بجائے اپنا client لکھ رہے ہیں تو layout کو بعد میں تبدیل کرنے کے بجائے پہلے request ہی سے درست ترتیب میں بنائیں۔ call کو اسی طرح build کریں جیسے VPS پر پہلی Claude API app میں کیا گیا ہے: stable blocks پہلے اور volatile blocks آخر میں رکھیں۔
ناکامی کی صورتیں اور آپ کو کیا نظر آئے گا
ہر call ایک write ہے۔ cache_creation_input_tokens ہر request پر non-zero ہے، جبکہ cache_read_input_tokens بدستور 0 ہے۔ breakpoint پر یا اس سے پہلے موجود کوئی چیز calls کے درمیان بدل رہی ہے۔ مسلسل دو requests پر تیار کردہ prefix کے پہلے 200 characters print کریں اور انہیں سامنے رکھ کر compare کریں۔
دونوں counters 0 ہیں۔ prefix model کی minimum حد سے کم ہے، یا cache_control field API تک نہیں پہنچا۔ پہلے prefix کے tokens count کریں، پھر وہ request body log کریں جو حقیقت میں بھیجی گئی تھی۔
Reads کام کرتی ہیں، پھر رک جاتی ہیں۔ کچھ hits کے بعد ایک write آتی ہے، پھر دوبارہ hits آتی ہیں۔ requests کے درمیان وقفہ lifetime سے زیادہ طویل تھا۔ write قبول کریں، یا 1 hour TTL پر منتقل ہو جائیں، لیکن پہلے تصدیق کر لیں کہ آپ کی hit rate 53 percent سے زیادہ ہے؛ 0.05x یا 0.025x read والے model پر یہ حد تقریباً 51 percent ہے۔
Deploy کے بعد hit rate کم ہو جاتی ہے۔ کسی tool description میں ترمیم کی گئی ہے یا model تبدیل کیا گیا ہے۔ دونوں صورتیں پورے prefix کو invalidate کر دیتی ہیں۔ ہر ایسے deploy کے بعد، جو prompt کو متاثر کرے، writes کا ایک مہنگا دور متوقع ہے۔
Caching فعال کرنے کے بعد bill بڑھ گیا۔ آپ کی hit rate break-even سے کم ہے۔ 5 minute cache پر تقریباً 22 percent سے کم hit rate میں prefix کو uncached بھیجنا سستا ہے، جبکہ 1 hour cache پر یہی بات تقریباً 53 percent سے کم hit rate کے لیے درست ہے۔ سستے read والے models میں یہ حدیں تقریباً 20 سے 21 percent اور 51 percent ہیں۔
FAQ
لاگت پوری ہونے سے پہلے ایک prompt کو کتنی بار دوبارہ استعمال کرنا ضروری ہے؟
5 minute cache میں ایک بار۔ زیادہ تر models میں write کی لاگت base input کی 1.25x اور read کی لاگت 0.1x ہوتی ہے۔ اس لیے N uncached requests کی لاگت N ہوتی ہے، جبکہ N cached requests کی لاگت 1.25 جمع 0.1 ضرب N منفی 1 ہوتی ہے۔ دونوں N = 1.28 پر برابر ہوتی ہیں، اس لیے دوسری request ہی سے فائدہ شروع ہو جاتا ہے۔ 0.05x یا 0.025x read والے models میں یہ حد N = 1.26 ہے، جس سے نتیجہ وہی رہتا ہے۔ 1 hour cache میں write کی لاگت 2x ہوتی ہے اور برابری N = 2.11 پر آتی ہے، یا سستی reads کے ساتھ تقریباً 2.05 پر؛ اس لیے اسے دو reads درکار ہوتی ہیں۔
cache_read_input_tokens ہمیشہ صفر کیوں ہوتا ہے؟
سب سے پہلے prefix length چیک کریں: اگر یہ model کی minimum سے کم ہو، جو October 2026 تک Claude Opus 5 کے لیے 512 tokens اور Claude Haiku 4.5 کے لیے 4,096 tokens ہے، تو caching خاموشی سے skip ہو جاتی ہے اور دونوں counters کی قدر 0 رہتی ہے۔ اگر prefix کافی طویل ہو تو ایسی content تلاش کریں جو calls کے درمیان تبدیل ہوتی ہو اور breakpoint پر یا اس سے پہلے موجود ہو، مثلاً system prompt میں timestamp یا session identifier۔ اگر counters پہلے کام کر رہے تھے اور پھر رک گئے ہیں تو requests کے درمیان وقفہ cache lifetime سے زیادہ تھا۔
کیا prompt caching سے Claude کے جوابات بدل جاتے ہیں؟
نہیں۔ Cache ان tokens کی processed form محفوظ کرتا ہے جو آپ پہلے ہی بھیج چکے ہیں، اور model دونوں صورتوں میں ایک ہی prompt دیکھتا ہے۔ یہ billing اور latency کی سہولت ہے، behaviour میں تبدیلی نہیں۔ اس کا مطلب یہ بھی ہے کہ آپ کسی working prompt پر اسے enable کر سکتے ہیں، اپنی evaluations دوبارہ چلائے بغیر۔
کیا مجھے 1 hour cache کے لیے ادائیگی کرنی چاہیے؟
صرف اس وقت جب آپ کی traffic میں 5 minutes سے زیادہ کے وقفے ہوں اور آپ کی hit rate تقریباً 53 percent سے زیادہ رہنے کی توقع ہو، یا سستی read والے model پر تقریباً 51 percent سے زیادہ ہو۔ miss کی صورت میں 2x write کی لاگت، 1.25x write سے چار گنا زیادہ ہوتی ہے۔ 1 hour write کا miss prefix کی مکمل base input price ضائع کر دیتا ہے، جبکہ 5 minute write کا miss صرف اس کا ایک چوتھائی ضائع کرتا ہے۔ 5 minute entry ہر hit پر refresh ہو جاتی ہے، اس لیے مسلسل traffic اسے read prices پر فعال رکھتی ہے اور کبھی طویل lifetime کی قیمت ادا نہیں کرنی پڑتی۔