KV cache आणि prompt cache मधील मुख्य फरक काय आहे?
KV cache ही सर्व्हरची RAM वापरते, तर prompt cache ही बिलिंग कमी करण्याचे साधन आहे. KV cache संपल्यास मॉडेल लोड होत नाही, तर prompt cache न वापरल्यास पूर्ण शुल्क लागते.
KV cache आणि prompt cache मधील फरक: थोडक्यात उत्तर
KV cache आणि प्रोव्हायडरची prompt cache यामध्ये फक्त 'cache' हा शब्द समान आहे, बाकी काहीही नाही. KV cache ही प्रत्येक विनंतीसाठी (per-request) लागणारी वर्किंग मेमरी असते. ती एका विनंतीच्या संपूर्ण कालावधीत तुमच्या सर्व्हरच्या RAM किंवा VRAM मध्ये राहते. जसा कॉन्टेक्स्टचा आकार वाढतो आणि एकाच वेळी अनेक विनंत्या येतात, तशी ही मेमरी वाढत जाते. प्रोव्हायडरची prompt caching हे बिलिंग आणि लॅटन्सी कमी करण्याचे एक फिचर आहे. तुमच्या प्रॉम्प्टचा एक स्थिर भाग (prefix) प्रोव्हायडरच्या सर्व्हरवर साठवला जातो आणि जेव्हा तुम्ही तो पुन्हा पाठवता, तेव्हा त्यावर सवलतीच्या दरात शुल्क आकारले जाते.
एक म्हणजे तुम्ही हार्डवेअर म्हणून विकत घेतलेली मेमरी, तर दुसरी म्हणजे दुसऱ्या कोणाकडे तरी असलेली मेमरी, ज्याचे भाडे तुम्ही भरता.
व्यावहारिक फरक हा व्याख्येपेक्षा जास्त महत्त्वाचा आहे. तुमची KV cache संपू शकते; असे झाल्यास मॉडेल लोड होण्यास नकार देते किंवा विनंती नाकारली जाते. तुम्ही prompt cache संपवू शकत नाही. तुम्ही फक्त ती वापरण्यात (hit) अपयशी ठरू शकता, ज्याचा परिणाम असा होतो की तुम्हाला पूर्ण किंमत मोजावी लागते.
KV cache मध्ये काय साठवले जाते आणि ते का आवश्यक आहे
जेव्हा एखादा transformer 500 व्या क्रमांकाचे टोकन तयार करत असतो, तेव्हा त्याला त्याआधीच्या सर्व 499 टोकन्सकडे लक्ष द्यावे लागते. या प्रत्येक टोकनसाठी, प्रत्येक लेयरला एक key vector आणि value vector ची आवश्यकता असते. प्रत्येक नवीन टोकनसाठी हे सर्व पुन्हा मोजल्यास, generation चा वेळ लांबीच्या वर्गाच्या प्रमाणात (square of the length) वाढेल. त्यामुळे, runtime हे vectors साठवून ठेवते. या साठवणुकीला KV cache (key/value cache) म्हणतात.
ही स्थिती प्रत्येक request साठी स्वतंत्र असते, कारण ती त्या विशिष्ट request च्या टोकन क्रमानुसार तयार केलेली असते. दोन वापरकर्ते वेगवेगळे prompts पाठवत असतील, तर ते हा cache शेअर करू शकत नाहीत. जोपर्यंत runtime 'prefix caching' वापरत नाही, जे एक वेगळे वैशिष्ट्य आहे आणि पुढे स्पष्ट केले आहे.
सर्व्हिंग दोन टप्प्यांत होते. Prefill टप्प्यात तुमचा संपूर्ण prompt वाचला जातो आणि cache भरला जातो; हे प्रक्रियेच्या क्षमतेवर (compute) अवलंबून असते. Decode टप्प्यात एका वेळी एक टोकन तयार केले जाते आणि ते cache मध्ये जोडले जाते; हे मेमरी बँडविड्थवर अवलंबून असते. या विभाजनामुळेच prompt प्रोसेसिंग आणि टोकन जनरेशनचा वेग तुमच्या स्वतःच्या मशीनवर टोकन्स प्रति सेकंद मोजताना वेगवेगळा दिसतो.
KV cache किती मेमरी वापरते?
विक्रेत्याच्या तक्त्यावर अवलंबून राहू नका. याचा आकार गणितावर आधारित आहे, जो तुम्ही कोणत्याही मॉडेलसाठी पुन्हा करू शकता:
bytes per token = 2 * layers * kv_heads * head_dim * bytes per elementयेथे 2 म्हणजे key आणि value. इतर सर्व आकडे मॉडेलच्या config.json मधून येतात, जे मॉडेलच्या Hugging Face पेजवर प्रकाशित केलेले असतात.
Llama 3.1 8B चे उदाहरण घेऊ. त्याच्या config मध्ये num_hidden_layers 32 आणि num_key_value_heads 8 दिलेले आहेत. 4096 चा hidden_size 32 attention heads मध्ये विभागल्यास head dimension 128 मिळते. f16 मध्ये प्रत्येक घटक 2 bytes चा असतो:
2 * 32 * 8 * 128 * 2 = 131072 bytes = 128 KiB per tokenयाला तुम्ही विचारलेल्या context ने आणि एकाच वेळी चालवल्या जाणाऱ्या requests ने गुणा.
या तक्त्यामागील डेटा
[
{
"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 1 GiB असतो. 32k वर तो 4 GiB असतो, जो 4-bit weights च्या श्रेणीतच येतो. मॉडेलच्या पूर्ण 128k context वर, एका request साठी तो 16 GiB असतो आणि जर चार requests ने तो पूर्ण भरला, तर तो 64 GiB होतो. Weights बदलत नाहीत, फक्त cache बदलतो.
Grouped query attention (GQA) या आकड्यामध्ये मोठी भूमिका बजावते. Llama 3.1 8B मध्ये 8 key/value heads आहेत जे 32 query heads ला सेवा देतात, त्यामुळे चार query heads एक साठवलेली key/value जोडी शेअर करतात. ज्या मॉडेलचा num_key_value_heads त्याच्या num_attention_heads इतका असतो, ते मॉडेल समान parameter count वर चार पट जास्त cache वापरते. दोन 8B मॉडेल्स सर्व्ह करण्याचा खर्च समान असेल असे गृहीत धरण्यापूर्वी ते एक field तपासा.
2k वर चाललेले मॉडेल 32k वर लोड होण्यास नकार का देते
मॉडेल लोड होताना runtime KV cache साठी मेमरी राखून ठेवतो. ही मेमरी तुम्ही प्रत्यक्ष पाठवलेल्या prompt साठी नाही, तर तुम्ही configure केलेल्या context length नुसार ठरवली जाते. Ollama ची default आता एकच संख्या राहिलेली नाही. October 2026 पासून त्याच्या context length documentation नुसार VRAM प्रमाणे ही value ठरते: 24 GiB पेक्षा कमी असलेल्या मशीनवर 4k, 24 ते 48 GiB दरम्यान 32k आणि 48 GiB किंवा त्याहून अधिक VRAM असलेल्या मशीनवर 256k. Cloud models साठी default त्यांच्या maximum इतका असतो. CPU-only VPS किंवा लहान GPU वर सुरुवात 4k पासून होते. ती 32k पर्यंत वाढवल्यास, एकही token येण्यापूर्वी तुम्ही 4 GiB अतिरिक्त allocation मागितलेले असते. 24 GiB card वर 32k आधीच default आहे. त्यामुळे तुम्ही ते मागितले नसले तरी ही मेमरी राखून ठेवली जाते.
OLLAMA_CONTEXT_LENGTH=32768 ollama serveInteractive 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.Ollama किंवा llama.cpp चालवणाऱ्या CPU-only VPS वर allocation सामान्य system RAM मधून होते. Startup वेळी उपलब्ध मेमरी अपुरी असल्याचे कदाचित समजणार नाही. त्याऐवजी kernel चा out-of-memory killer process बंद करतो आणि त्याचा पुरावा kernel ring buffer मध्ये ठेवतो:
dmesg -T | grep -i "killed process"तुमच्या serving process चे नाव दाखवणारी line याचा अर्थ त्या मशीनने उपलब्ध मेमरीपेक्षा जास्त मेमरीचे आश्वासन दिले होते. उपाय म्हणजे मोठी swap file नव्हे, तर लहान context वापरणे. Disk वर paged केलेला KV cache प्रत्येक generated token वेळी वाचावा लागतो. त्यामुळे generation इतकी मंद होते की ती वापरण्यायोग्य राहत नाही. योग्य value कशी निवडावी यासाठी Ollama मधील num_ctx आणि context length वरील आमचे मार्गदर्शक पाहा.
कॉन्करन्सीचा (concurrency) संख्येवर होणारा परिणाम
प्रत्येक इन-फ्लाईट विनंती स्वतःचा KV cache सोबत ठेवते. क्षमता नियोजनामध्ये (capacity planning) बहुतेक वेळा हाच मुद्दा दुर्लक्षित केला जातो. प्रत्येकी 32k कॉन्टेक्स्ट असलेल्या चार वापरकर्त्यांना मॉडेलच्या वेट्सव्यतिरिक्त (weights) 16 GiB मेमरीची आवश्यकता असते.
हे किती काटेकोरपणे पाळले जाते, यात रनटाइम्समध्ये फरक असतो. Ollama आणि llama.cpp मॉडेल लोड होतानाच तुम्ही मागितलेला कॉन्टेक्स्ट रिझर्व्ह करतात, त्यामुळे कोणी वापरले असो वा नसो, मेमरी कमिट केलेली असते. vLLM पूलचे रूपांतर निश्चित आकाराच्या ब्लॉक्समध्ये करते आणि विनंती जशी वाढेल तसे ते वाटप करते, त्यामुळे 500-टोकनची विनंती फक्त 500 टोकन्सइतकीच मेमरी वापरते. दोन्ही पद्धतींमध्ये पूल मर्यादित असतो आणि तो एकदा भरला की, नवीन विनंत्या रन होण्याऐवजी रांगेत (queue) उभ्या राहतात. ही रांग रिस्पॉन्स टाइमवर काय परिणाम करते, हे self-hosted LLM किती कॉन्करंट वापरकर्त्यांना सर्व्ह करू शकते यामध्ये स्पष्ट केले आहे.
KV cache लहान करण्याचे चार मार्ग
- कॉन्टेक्स्टची लांबी (context length) कमी करा. हा सर्वात प्रभावी उपाय आहे आणि सहसा सर्वात स्वस्त पडतो. बहुतेक चॅट वर्कलोड्समध्ये 32k पर्यंतची गरज कधीच भासत नाही.
- कॅशेचेच क्वांटायझेशन (quantise) करा. Ollama चे
OLLAMA_KV_CACHE_TYPEडीफॉल्टनुसारf16वापरते आणिq8_0ला सपोर्ट करते, ज्यामुळे मेमरीचा वापर साधारण निम्म्यावर येतो, तसेचq4_0वापरल्यास तो पावभागावर येतो. llama.cpp मधील याचे समतुल्य पर्याय-ctk q8_0आणि-ctv q8_0हे आहेत. - कमी key/value हेड्स किंवा कमी लेयर्स असलेले मॉडेल निवडा. 40 GB वजनाचे मॉडेल्स डाउनलोड करण्यापूर्वी
config.jsonवाचा. - एका वेळी कमी विनंत्या (requests) सर्व्ह करा आणि उर्वरित विनंत्या रांगेत (queue) ठेवा.
q4_0 वर Llama 3.1 8B चा आकडा प्रति टोकन 128 KiB वरून साधारण 32 KiB पर्यंत खाली येतो, त्यामुळे 32k कॉन्टेक्स्टसाठी 4 GiB ऐवजी फक्त 1 GiB खर्च येतो. ही बचत विनामूल्य नाही. की (keys) आणि व्हॅल्यूज (values) कमी अचूकतेसह साठवल्या जातात, त्यामुळे कायमस्वरूपी वापरण्यापूर्वी तुमच्या स्वतःच्या प्रॉम्प्ट्सवर आउटपुटची तुलना करून खात्री करा.
Provider prompt caching मुळात काय देते
Provider prompt caching हे वेगळ्या उत्पादनासारखे काम करते आणि त्याचे मोजमाप करण्याचे एककही वेगळे असते. तुम्ही स्थिर prefix चिन्हांकित करता. Provider तो साठवतो. त्याच prefix ची अगदी तंतोतंत पुनरावृत्ती करणाऱ्या पुढील calls साठी पूर्ण input price ऐवजी कमी दर आकारला जातो.
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 अंतर्गत ठेवला, तर या व्यवहाराचे स्वरूप स्पष्ट होते.
या तक्त्यामागील डेटा
[
{
"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 premium मुळे पहिल्या call वर 5,000 token equivalents अतिरिक्त आकारले जातात: 25,000; ते uncached स्वरूपात पाठवण्यासाठी लागणाऱ्या 20,000 च्या तुलनेत आहे. या window मधील प्रत्येक पुढील call साठी 20,000 ऐवजी 2,000 आकारले जातात. त्यामुळे 18,000 ची बचत होते. म्हणून 5-minute cache दुसऱ्या call पासूनच फायदेशीर ठरतो.
1-hour cache हा वेगळा पर्याय आहे. Write वेळी त्यासाठी 40,000 आकारले जातात. म्हणजे 20,000 token equivalents चे premium द्यावे लागते. त्यामुळे तो फायदेशीर होण्यासाठी त्या तासात दोन hits आवश्यक असतात. हा प्रश्न model चा नसून तुमच्या traffic pattern चा आहे. Window कशी निवडायची यासह संपूर्ण गणना Claude prompt caching साठी break-even math येथे दिली आहे.
तुम्हाला cache hit मिळेल की नाही हे दोन तपशील ठरवतात. पहिला, model च्या minimum length पेक्षा कमी असलेला prefix कोणतीही सूचना न देता cache केला जात नाही. October 2026 पर्यंत documentation मध्ये दिलेली minimum length Claude Opus 5, Opus 5.5 आणि Sonnet 5.5 साठी 512 tokens आहे. Claude Sonnet 5 साठी ती 1,024 tokens आहे. यापेक्षा लहान request नेहमीच्या पद्धतीने process केली जाते आणि कोणताही error परत केला जात नाही. दुसरा, lifetime ही entry लिहिणाऱ्या किंवा वाचणाऱ्या request च्या सुरुवातीपासून मोजली जाते. प्रत्येक read मुळे अतिरिक्त खर्चाशिवाय lifetime पुन्हा सुरू होते. त्यामुळे सतत वापरात असलेला endpoint 5-minute cache अनिश्चित काळासाठी जिवंत ठेवतो. दर दहा मिनिटांनी एकदा call होणारा endpoint प्रत्येक वेळी write premium भरतो आणि कधीही बचत मिळवत नाही.
गृहीत धरण्याऐवजी response तपासा. usage object मध्ये cache_creation_input_tokens आणि cache_read_input_tokens दिलेले असतात. प्रत्येक call वर read count शून्य असल्यास, तुम्ही writes साठी पैसे देत आहात पण त्यातून काहीही परत मिळत नाही.
दोन cache जिथे एकमेकांना स्पर्श करतात
मोठा system prompt हे ते दोन्ही खर्च जिथे एकत्र येतात ते ठिकाण आहे. त्याचा खर्च एकाच वेळी दोन्ही बाजूंवर होतो.
स्थानिक पातळीवर, f16 वर Llama 3.1 8B server मध्ये 20,000-token system prompt सुमारे 2.4 GiB KV cache व्यापतो. हा cache तो prompt समाविष्ट असलेल्या प्रत्येक समकालीन request साठी स्वतंत्रपणे लागतो. दूरस्थ पातळीवर, त्याच prefix साठी एकदा cache write करावा लागतो. त्यानंतरच्या प्रत्येक call साठी input च्या 0.1 पट खर्च होतो; नवीन models मध्ये हा खर्च त्याहून कमी असू शकतो. स्थानिक खर्च users च्या संख्येनुसार वाढतो. दूरस्थ खर्च traffic नुसार वाढतो आणि idle time मध्ये पुन्हा सुरुवातीच्या स्थितीत येतो.
स्थानिक स्तरावर एक feature आहे. ते provider prompt caching सारखे दिसते आणि त्याच्याशी वारंवार गोंधळले जाते: prefix caching. vLLM documentation मध्ये automatic prefix caching चे वर्णन पुढीलप्रमाणे केले आहे: “existing queries चा KV cache cache करणे, जेणेकरून नवीन query चा prefix existing queries पैकी एखाद्या query शी समान असल्यास तो KV cache थेट पुन्हा वापरता येईल.” सध्याच्या 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 ची पुनरावृत्ती करण्याऐवजी ते पुन्हा वापरले जातात. त्यामुळे memory वापरातही सुधारणा होते. मात्र सध्या live असलेल्या tokens साठी आवश्यक असलेला cache यामुळे कधीही कमी होत नाही. Requests दरम्यान weights resident ठेवणे हा संबंधित पण स्वतंत्र उपाय आहे. त्याचे वर्णन requests दरम्यान Ollama model loaded ठेवणे येथे केले आहे.
तुमच्या स्वतःच्या मशीनवर काय मोजावे
तुमच्या अपेक्षित context वर model load करा. त्यानंतर estimate वर अवलंबून न राहता प्रत्यक्ष आकडे वाचा.
ollama ps
nvidia-smi --query-gpu=memory.used,memory.total --format=csv
free -gollama ps load केलेले model, त्याचा size, तो ज्या context सह load झाला आहे तो context आणि तो GPU वर चालत आहे की CPU वर, हे दाखवते. सर्वप्रथम context column तपासा, कारण आता default तुमच्या VRAM वर अवलंबून असतो. पूर्णपणे GPU वर राहील अशी अपेक्षा असलेल्या model मध्ये CPU split दिसत असल्यास, KV cache मुळे त्याचा काही भाग GPU बाहेर गेला आहे. त्यामुळे generation speed कमी होईल. nvidia-smi खरा VRAM आकडा दाखवते. CPU-only VPS वर free -g हेच काम करते. Context टप्प्याटप्प्याने वाढवा, पुन्हा load करा आणि आकडा कसा बदलतो ते monitor करा. तुमची गणना आणि report झालेला आकडा एकमेकांच्या जवळ असायला हवेत. ते जुळत नसतील, तर हा फरक सहसा formula मधील error नसतो. तो runtime च्या स्वतःच्या compute buffers मुळे असतो.
हे आकडे पाहून तुम्हाला भाड्याने घ्यायचे नसलेले hardware आवश्यक वाटत असल्यास, प्रति token पैसे देण्याशी केलेली तुलना GPU VPS विरुद्ध API tokens येथे दिली आहे.
FAQ
KV cache ही prompt caching सारखीच गोष्ट आहे का?
नाही. KV cache ही serving process मधील प्रति-request memory असते. त्यात सध्याच्या context मधील प्रत्येक token साठी key आणि value vectors ठेवलेले असतात. ती तुमच्या RAM किंवा VRAM मध्ये असते आणि request संपल्यावर मुक्त केली जाते. Provider prompt caching हे billing feature आहे. ते provider च्या infrastructure वर स्थिर prompt prefix साठवते आणि तो पुन्हा पाठवल्यावर कमी दर आकारते. KV cache संपल्यास model load होत नाही. Prompt cache उपलब्ध नसल्यास फक्त तुमचे invoice आणि first token मिळेपर्यंतचा वेळ वाढतो.
माझे model 2k context वर load होते, पण 32k वर का fail होते?
कारण runtime load वेळी संपूर्ण KV cache allocate करते. त्याचा आकार तुम्ही पाठवलेल्या prompt नुसार नाही, तर configure केलेल्या context length नुसार ठरतो. Llama 3.1 8B साठी f16 मध्ये cache प्रत्येक token मागे 128 KiB असतो. त्यामुळे 2k context साठी 0.25 GiB आणि 32k साठी 4 GiB लागतात. दोन्ही परिस्थितींमध्ये weights memory मध्ये बसतात. अपयश reservation मुळे होते. vLLM हे ValueError म्हणून दाखवते. त्यात आवश्यक KV cache memory आणि उपलब्ध memory यांची तुलना, estimated maximum model length सह दिलेली असते. तसेच gpu_memory_utilization वाढवण्याचा किंवा max_model_len कमी करण्याचा सल्ला दिला जातो. Ollama किंवा llama.cpp चालवणाऱ्या CPU-only box वर त्याऐवजी kernel out-of-memory killer process बंद करू शकतो. याची पुष्टी dmesg -T | grep -i "killed process" ने करता येते.
माझ्या model साठी KV cache चा आकार कसा मोजायचा?
2 ला layer count, key/value heads ची संख्या, head dimension आणि प्रत्येक element साठी लागणारे bytes यांचा गुणाकार करा. यामुळे प्रति token bytes मिळतात. त्यानंतर त्या संख्येचा context length आणि concurrent requests ची संख्या यांच्याशी गुणाकार करा. Layer आणि head counts model च्या config.json मधून वाचा. f16 किंवा bf16 साठी प्रत्येक element मागे 2 bytes वापरा. q8_0 cache साधारणपणे त्याच्या निम्मा असतो आणि q4_0 cache साधारणपणे त्याच्या चतुर्थांश असतो.
Prompt caching मुळे माझ्या स्वतःच्या server ला लागणारी memory कमी होते का?
Provider prompt caching मुळे तुमच्या hardware वर कोणताही परिणाम होत नाही, कारण storage provider च्या बाजूला असते. याचा स्थानिक पर्याय prefix caching आहे. तो vLLM आणि llama.cpp server दोन्हीमध्ये उपलब्ध आहे. Shared prefix साठी आधीच मोजलेले key आणि value vectors पुन्हा वापरले जातात. त्यामुळे prefill compute वाचतो आणि first token मिळेपर्यंतचा वेळ कमी होतो. vLLM मध्ये shared blocks ची duplicate प्रत तयार करण्याऐवजी त्यांचा पुनर्वापर केला जातो. त्यामुळे memory वापरातही सुधारणा होते. मात्र सध्या process मध्ये असलेल्या tokens साठी आवश्यक cache यापैकी कोणतेही feature कमी करत नाही. त्यामुळे context आणि concurrency चे गणित किमान आवश्यक memory ठरवत राहते.
मी एखादा prompt फक्त एकदाच पाठवत असल्यास तो cache करणे उपयुक्त आहे का?
नाही. Cache write साठी plain input पेक्षा जास्त शुल्क लागते. October 2026 नुसार 5-minute option साठी ते base rate च्या 1.25 पट आहे. त्यामुळे त्या window मध्ये पुन्हा न पाठवलेला prefix केवळ अतिरिक्त खर्च ठरतो. तोच prefix पुन्हा वापरला जातो तेव्हा caching उपयुक्त ठरते. उदाहरणार्थ, मोठा system prompt किंवा ज्याबद्दल तुम्ही अनेक प्रश्न विचारणार असलेला document. Write साठी शुल्क भरण्याऐवजी cache hits मिळत आहेत याची पुष्टी करण्यासाठी API response मधील cache_read_input_tokens तपासा.