प्रॉम्प्ट कैशिंग इंफ्रास्ट्रक्चर: LLM लागत और लेटेंसी में कमी
11 दिसंबर, 2025 को अपडेट किया गया
दिसंबर 2025 अपडेट: Anthropic प्रीफिक्स कैशिंग लंबे प्रॉम्प्ट्स के लिए 90% लागत में कमी और 85% लेटेंसी में कमी प्रदान कर रही है। OpenAI ऑटोमैटिक कैशिंग डिफ़ॉल्ट रूप से सक्षम (50% लागत बचत)। 31% LLM क्वेरीज़ सिमेंटिक समानता प्रदर्शित कर रही हैं—कैशिंग इंफ्रास्ट्रक्चर के बिना भारी अक्षमता। कैश रीड्स $0.30/M टोकन बनाम $3.00/M फ्रेश (Anthropic)। मल्टी-टियर कैशिंग आर्किटेक्चर (सिमेंटिक → प्रीफिक्स → इन्फरेंस) अधिकतम बचत प्रदान कर रहा है।
Anthropic की प्रॉम्प्ट कैशिंग लंबे प्रॉम्प्ट्स के लिए लागत में 90% तक और लेटेंसी में 85% तक की कमी करती है।¹ OpenAI डिफ़ॉल्ट रूप से सक्षम ऑटोमैटिक कैशिंग के साथ 50% लागत में कमी हासिल करता है। रिसर्च दिखाती है कि 31% LLM क्वेरीज़ पिछले रिक्वेस्ट्स के साथ सिमेंटिक समानता प्रदर्शित करती हैं, जो कैशिंग इंफ्रास्ट्रक्चर के बिना डिप्लॉयमेंट में भारी अक्षमता दर्शाती है।² प्रोडक्शन AI एप्लिकेशन चलाने वाले संगठन उचित कैशिंग रणनीतियों के बिना काफी पैसा गंवाते हैं।
प्रॉम्प्ट कैशिंग कई स्तरों पर काम करती है—प्रोवाइडर-साइड प्रीफिक्स कैशिंग जो KV कैश कम्प्यूटेशन को पुन: उपयोग करती है, से लेकर एप्लिकेशन-लेवल सिमेंटिक कैशिंग जो समान क्वेरीज़ के लिए पिछले रिस्पॉन्स लौटाती है। प्रत्येक लेयर को समझना और इसे कब डिप्लॉय करना है, संगठनों को उनके विशिष्ट वर्कलोड पैटर्न के लिए लागत और लेटेंसी दोनों को ऑप्टिमाइज़ करने में मदद करता है।
कैशिंग की मूल बातें
LLM इन्फरेंस लागत दो स्रोतों से आती है: इनपुट टोकन प्रोसेसिंग और आउटपुट टोकन जनरेशन। कैशिंग रणनीतियां दोनों को लक्षित करती हैं:
इनपुट टोकन कैशिंग (प्रीफिक्स कैशिंग)
हर LLM रिक्वेस्ट इनपुट टोकन को मॉडल के अटेंशन मैकेनिज्म के माध्यम से प्रोसेस करता है, KV कैश में स्टोर key-value पेयर्स जनरेट करता है। जब मल्टीपल रिक्वेस्ट्स समान प्रीफिक्स शेयर करते हैं—सिस्टम प्रॉम्प्ट्स, few-shot एग्जाम्पल्स, या डॉक्यूमेंट कॉन्टेक्स्ट—KV कैश कम्प्यूटेशन अनावश्यक रूप से दोहराता है।
प्रीफिक्स कैशिंग समाधान: सामान्य प्रीफिक्स के लिए कम्प्यूटेड KV वैल्यूज़ स्टोर करें। मैचिंग प्रीफिक्स वाले बाद के रिक्वेस्ट रीकम्प्यूटेशन को स्किप करते हैं, कैश्ड स्टेट से शुरू होते हैं।
लागत प्रभाव: - Anthropic: कैश रीड्स $0.30/M टोकन बनाम $3.00/M फ्रेश प्रोसेसिंग (90% बचत) - OpenAI: कैश्ड टोकन पर 50% डिस्काउंट - Google: कॉन्टेक्स्ट विंडो के आधार पर वेरिएबल प्राइसिंग
लेटेंसी प्रभाव: प्रीफिक्स कम्प्यूटेशन स्किप करने से प्रीफिक्स लंबाई के आधार पर time-to-first-token 50-85% कम होता है।
आउटपुट कैशिंग (सिमेंटिक कैशिंग)
कुछ रिक्वेस्ट्स समान रिस्पॉन्स के योग्य होते हैं—दोहराए गए प्रश्न, डिटर्मिनिस्टिक क्वेरीज़, या लुकअप जिन्हें री-जनरेशन की आवश्यकता नहीं।
सिमेंटिक कैशिंग समाधान: सिमेंटिकली समान इनपुट द्वारा कीड रिस्पॉन्स आउटपुट स्टोर करें। मैचिंग क्वेरीज़ के लिए LLM इनवोकेशन के बिना कैश्ड रिस्पॉन्स रिटर्न करें।
लागत प्रभाव: कैश्ड रिस्पॉन्स API कॉल को पूरी तरह समाप्त करते हैं—कैश हिट्स पर 100% बचत।
लेटेंसी प्रभाव: रिस्पॉन्स LLM इन्फरेंस के लिए सेकंड्स के बजाय मिलीसेकंड में आता है।
कैशिंग हायरार्की
प्रोडक्शन सिस्टम आमतौर पर मल्टीपल कैशिंग लेयर्स इम्प्लीमेंट करते हैं:
Request → Semantic Cache (100% savings) → Prefix Cache (50-90% savings) → Full Inference
↓ ↓ ↓
Cached response Cached KV state Fresh computation
प्रत्येक लेयर रिक्वेस्ट समानता पैटर्न के आधार पर अलग-अलग ऑप्टिमाइज़ेशन अवसरों को कैप्चर करती है।
प्रोवाइडर-लेवल प्रॉम्प्ट कैशिंग
Anthropic Claude
Anthropic सबसे कॉन्फिगरेबल प्रॉम्प्ट कैशिंग प्रदान करता है:³
प्राइसिंग: - कैश राइट्स: बेस इनपुट प्राइस से 25% प्रीमियम - कैश रीड्स: 90% डिस्काउंट (बेस प्राइस का 10%) - ब्रेक-ईवन: प्रति कैश्ड प्रीफिक्स 2+ कैश हिट्स
आवश्यकताएं: - प्रति कैश चेकपॉइंट न्यूनतम 1,024 टोकन - प्रति रिक्वेस्ट 4 कैश चेकपॉइंट तक - कैश लाइफटाइम: अंतिम एक्सेस से 5 मिनट (नियमित हिट्स के साथ 1 घंटे तक बढ़ाया जाता है) - 5 कन्वर्सेशन टर्न तक कैश करने योग्य
इम्प्लीमेंटेशन:
import anthropic
client = anthropic.Anthropic()
# cache_control के साथ कैशिंग के लिए कंटेंट मार्क करें
response = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
system=[
{
"type": "text",
"text": "You are an expert assistant for our enterprise software...",
"cache_control": {"type": "ephemeral"} # कैशिंग के लिए मार्क करें
}
],
messages=[{"role": "user", "content": "How do I configure user permissions?"}]
)
बेस्ट प्रैक्टिसेज: - स्टैटिक कंटेंट (सिस्टम प्रॉम्प्ट्स, डॉक्यूमेंटेशन) को प्रॉम्प्ट की शुरुआत में रखें - डायनामिक कंटेंट (यूज़र इनपुट, कन्वर्सेशन) को अंत में रखें - नेचुरल बाउंड्रीज़ पर कैश चेकपॉइंट का उपयोग करें - ऑप्टिमाइज़ेशन वेरिफाई करने के लिए कैश हिट रेट्स मॉनिटर करें
OpenAI
OpenAI बिना कोड बदलाव के ऑटोमैटिक कैशिंग इम्प्लीमेंट करता है:⁴
प्राइसिंग: - कैश्ड टोकन: बेस इनपुट प्राइस का 50% - कोई कैश राइट प्रीमियम नहीं
आवश्यकताएं: - कैशिंग एलिजिबिलिटी के लिए न्यूनतम 1,024 टोकन - कैश हिट्स 128-टोकन इंक्रीमेंट में होते हैं - कैश लाइफटाइम: 5-10 मिनट निष्क्रियता
ऑटोमैटिक बिहेवियर: - 1,024 टोकन से अधिक प्रॉम्प्ट्स ऑटोमैटिकली कैश होते हैं - सिस्टम रिक्वेस्ट्स में मैचिंग प्रीफिक्स डिटेक्ट करता है - कोई API बदलाव आवश्यक नहीं
मॉनिटरिंग:
response = client.chat.completions.create(
model="gpt-4-turbo",
messages=[...],
)
# कैश हिट्स के लिए usage चेक करें
print(f"Cached tokens: {response.usage.prompt_tokens_details.cached_tokens}")
print(f"Total input tokens: {response.usage.prompt_tokens}")
Google Gemini
Google, Gemini मॉडल्स के लिए कॉन्टेक्स्ट कैशिंग प्रदान करता है:⁵
प्राइसिंग: - कैश्ड कॉन्टेक्स्ट साइज़ और ड्यूरेशन के आधार पर वेरिएबल - कैश्ड कंटेंट के लिए स्टोरेज फीस
फीचर्स: - एक्सप्लिसिट कैश क्रिएशन और मैनेजमेंट - कॉन्फिगरेबल time-to-live - क्रॉस-रिक्वेस्ट कैश शेयरिंग
इम्प्लीमेंटेशन:
from google.generativeai import caching
# कैश्ड कंटेंट क्रिएट करें
cache = caching.CachedContent.create(
model='models/gemini-1.5-pro-001',
display_name='product-documentation',
system_instruction="You are a product expert...",
contents=[product_docs],
ttl=datetime.timedelta(hours=1)
)
# रिक्वेस्ट्स में कैश्ड कंटेंट का उपयोग करें
model = genai.GenerativeModel.from_cached_content(cached_content=cache)
response = model.generate_content("How do I configure feature X?")
Amazon Bedrock
AWS सपोर्टेड मॉडल्स के लिए प्रीव्यू में प्रॉम्प्ट कैशिंग प्रदान करता है:⁶
आवश्यकताएं: - Claude 3.5 Sonnet को प्रति चेकपॉइंट न्यूनतम 1,024 टोकन चाहिए - दूसरे चेकपॉइंट के लिए 2,048 टोकन चाहिए
इम्प्लीमेंटेशन पैटर्न Bedrock के API स्ट्रक्चर के भीतर Anthropic के cache_control अप्रोच से मैच करता है।
vLLM प्रीफिक्स कैशिंग
vLLM के साथ सेल्फ-होस्टेड इन्फरेंस में ऑटोमैटिक प्रीफिक्स कैशिंग शामिल है:⁷
आर्किटेक्चर
vLLM का Automatic Prefix Caching (APC) KV ब्लॉक्स को हैश टेबल में स्टोर करता है, ट्री स्ट्रक्चर के बिना कैश रीयूज़ सक्षम करता है:
मुख्य डिज़ाइन: - सभी KV ब्लॉक्स इनिशियलाइज़ेशन पर ब्लॉक पूल में स्टोर होते हैं - प्रीफिक्स मैचिंग के लिए हैश-बेस्ड लुकअप - ब्लॉक मैनेजमेंट के लिए O(1) ऑपरेशंस - PagedAttention मेमोरी एफिशिएंसी बनाए रखी गई
कॉन्फिगरेशन
from vllm import LLM
llm = LLM(
model="meta-llama/Llama-3.1-8B-Instruct",
enable_prefix_caching=True, # APC सक्षम करें
gpu_memory_utilization=0.90,
)
परफॉर्मेंस प्रभाव
PagedAttention के साथ vLLM नाइव इम्प्लीमेंटेशन से 14-24x ज़्यादा थ्रूपुट प्रदर्शित करता है।⁸ प्रीफिक्स कैशिंग जोड़ता है:
- कैश्ड और अनकैश्ड टोकन के बीच 10x लागत अंतर
- मैचिंग प्रीफिक्स के लिए ऑर्डर-ऑफ-मैग्नीट्यूड लेटेंसी कमी
- शेयर्ड KV ब्लॉक्स के माध्यम से मेमोरी एफिशिएंसी
सिक्योरिटी कंसीडरेशंस
vLLM शेयर्ड एनवायरनमेंट के लिए कैश आइसोलेशन सपोर्ट करता है:
# प्रति-रिक्वेस्ट कैश सॉल्ट क्रॉस-टेनेंट कैश एक्सेस रोकता है
response = llm.generate(
prompt="...",
sampling_params=SamplingParams(...),
cache_salt="tenant-123" # टेनेंट द्वारा कैश आइसोलेट करें
)
ब्लॉक हैशेज़ में कैश सॉल्ट इंजेक्शन टाइमिंग अटैक्स रोकता है जहां एडवर्सरीज़ लेटेंसी ऑब्ज़र्वेशन के माध्यम से कैश्ड कंटेंट इन्फर करते हैं।
LMCache एक्सटेंशन
LMCache, vLLM को एडवांस्ड कैशिंग कैपेबिलिटीज़ के साथ एक्सटेंड करता है:⁹
फीचर्स: - इंजन इंस्टेंसेस में KV कैश रीयूज़ - मल्टी-टियर स्टोरेज (GPU → CPU RAM → disk) - नॉन-प्रीफिक्स कंटेंट कैशिंग - बेंचमार्क में 3-10x लेटेंसी कमी
आर्किटेक्चर:
vLLM Engine → LMCache → GPU VRAM (hot)
→ CPU RAM (warm)
→ Local Disk (cold)
सिमेंटिक कैशिंग
सिमेंटिक कैशिंग सिमेंटिकली समान (न कि सिर्फ आइडेंटिकल) क्वेरीज़ के लिए पिछले रिस्पॉन्स रिटर्न करती है:
GPTCache
GPTCache, LLM एप्लिकेशंस के लिए ओपन-सोर्स सिमेंटिक कैशिंग प्रदान करता है:¹⁰
आर्किटेक्चर:
Query → Embedding → Vector Search → Similarity Check → Response/API Call
↓ ↓ ↓
BERT/OpenAI Milvus/FAISS Threshold (0.8)
कंपोनेंट्स: - LLM Adapter: विभिन्न LLM प्रोवाइडर्स के साथ इंटीग्रेशन - Embedding Generator: क्वेरी वेक्टराइज़ेशन - Vector Store: सिमिलैरिटी सर्च (Milvus, FAISS, Zilliz) - Cache Manager: स्टोरेज और रिट्रीवल - Similarity Evaluator: थ्रेशोल्ड-बेस्ड मैचिंग
इम्प्लीमेंटेशन:
from gptcache import cache
from gptcache.adapter import openai
# सिमेंटिक कैश इनिशियलाइज़ करें
cache.init(
pre_embedding_func=get_text_embedding,
data_manager=manager,
)
# कैश्ड OpenAI कॉल्स का उपयोग करें
response = openai.ChatCompletion.create(
model='gpt-4',
messages=[{"role": "user", "content": "What is machine learning?"}]
)
# सिमेंटिकली समान क्वेरीज़ ("Explain ML", "Define machine learning")
# कैश्ड रिस्पॉन्स रिटर्न करती हैं
परफॉर्मेंस
GPTCache महत्वपूर्ण एफिशिएंसी गेन्स हासिल करता है:¹¹
- API कॉल रिडक्शन: क्वेरी कैटेगरीज़ में 68.8% तक
- कैश हिट रेट्स: 61.6% से 68.8%
- एक्यूरेसी: 97%+ पॉज़िटिव हिट रेट
- लेटेंसी रिडक्शन: कैश हिट्स पर 40-50%, फुल हिट्स के लिए 100x तक
एडवांस्ड तकनीकें
VectorQ एडैप्टिव थ्रेशोल्ड्स:¹²
स्टैटिक सिमिलैरिटी थ्रेशोल्ड्स (जैसे, 0.8) डाइवर्स क्वेरीज़ में खराब परफॉर्म करते हैं। VectorQ एम्बेडिंग-स्पेसिफिक थ्रेशोल्ड रीजन्स सीखता है जो क्वेरी कॉम्प्लेक्सिटी के अनुसार एडैप्ट होते हैं:
- सिंपल फैक्चुअल क्वेरीज़: हाई थ्रेशोल्ड्स (स्ट्रिक्टर मैचिंग)
- ओपन-एंडेड क्वेरीज़: लोअर थ्रेशोल्ड्स (ज़्यादा रीयूज़)
- एम्बीगुअस क्वेरीज़: डायनामिक एडजस्टमेंट
SCALM पैटर्न डिटेक्शन:
SCALM पैटर्न डिटेक्शन और फ्रीक्वेंसी एनालिसिस के माध्यम से GPTCache में सुधार करता है: - कैश हिट रेशियो में 63% सुधार - टोकन यूसेज में 77% कमी - हाई-फ्रीक्वेंसी कैश एंट्री पैटर्न आइडेंटिफाई करता है
सिमेंटिक कैशिंग कब उपयोग करें
अच्छे कैंडिडेट्स: - सीमित आंसर स्पेस वाले FAQ-स्टाइल क्वेरीज़ - लुकअप क्वेरीज़ (प्रोडक्ट इन्फो, डॉक्यूमेंटेशन) - डिटर्मिनिस्टिक रिस्पॉन्सेज़ (कैलकुलेशंस, फॉर्मेटिंग) - क्वेरी रिपीटिशन वाले हाई-ट्रैफिक एप्लिकेशंस
खराब कैंडिडेट्स: - यूनीकनेस की आवश्यकता वाली क्रिएटिव जनरेशन - पर्सनलाइज्ड रिस्पॉन्सेज़ (यूज़र-स्पेसिफिक कॉन्टेक्स्ट) - टाइम-सेंसिटिव इन्फॉर्मेशन - लो-रिपीटिशन क्वेरी पैटर्न
इम्प्लीमेंटेशन पैटर्न
चैट एप्लिकेशंस
चैट सिस्टम प्रीफिक्स और सिमेंटिक कैशिंग दोनों से लाभ उठाते हैं:
सिस्टम प्रॉम्प्ट कैशिंग:
# स्टैटिक सिस्टम प्रॉम्प्ट रिक्वेस्ट स्टार्ट पर कैश होता है
system_prompt = """
You are a customer support agent for Acme Corp...
[2000+ tokens of guidelines and knowledge]
"""
# डायनामिक कन्वर्सेशन कैश्ड प्रीफिक्स के बाद अपेंड होती है
messages = [
{"role": "system", "content": system_prompt, "cache_control": {...}},
{"role": "user", "content": user_message}
]
कन्वर्सेशन हिस्ट्री कैशिंग: Anthropic 5 कन्वर्सेशन टर्न तक कैशिंग सपोर्ट करता है, मल्टी-टर्न कन्वर्सेशंस के लिए लागत कम करता है।
RAG एप्लिकेशंस
Retrieval-augmented generation रिट्रीव्ड कॉन्टेक्स्ट को कैश करती है:
# RAG के लिए कैश स्ट्रक्चर
cached_context = {
"system": system_prompt, # हमेशा कैश्ड
"documents": retrieved_chunks, # प्रति क्वेरी क्लस्टर कैश
"examples": few_shot_examples # रिक्वेस्ट्स में स्टेबल
}
# केवल यूज़र क्वेरी वेरी होती है
dynamic_content = {
"query": user_question
}
डॉक्यूमेंट चंक कैशिंग: जब मल्टीपल क्वेरीज़ समान डॉक्यूमेंट्स रिट्रीव करती हैं, प्रीफिक्स कैशिंग शेयर्ड कॉन्टेक्स्ट की रिडंडेंट प्रोसेसिंग समाप्त करती है।
एजेंटिक वर्कफ़्लोज़
टूल कॉलिंग वाले एजेंट सिस्टम प्रीफिक्स कैशिंग से लाभ उठाते हैं:
System prompt → Tool definitions → Conversation history → Current query
(cached) (cached) (partially cached) (fresh)
टूल डेफिनिशन कैशिंग: लंबे टूल स्कीमा (20+ टूल्स) हज़ारों टोकन जोड़ते हैं। प्रीफिक्स कैशिंग बार-बार पार्सिंग समाप्त करती है।
परफॉर्मेंस ऑप्टिमाइज़ेशन
कैश हिट रेट ऑप्टिमाइज़ेशन
प्रीफिक्स अलाइनमेंट:
# खराब: वेरिएबल कंटेंट पहले
messages = [
{"role": "user", "content": user_query}, # हर बार अलग
{"role": "system", "content": system_prompt}
]
# अच्छा: स्टैटिक कंटेंट पहले
messages = [
{"role": "system", "content": system_prompt}, # कैश्ड
{"role": "user", "content": user_query} # वेरी होता है
]
बैच प्रोसेसिंग: समान प्रीफिक्स वाले रिक्वेस्ट्स को ग्रुप करें ताकि कैश रीयूज़ मैक्सिमाइज़ हो:
# रिक्वेस्ट्स को प्रीफिक्स समानता द्वारा ग्रुप करें
request_batches = group_by_prefix(pending_requests)
for batch in request_batches:
# बैच में पहला रिक्वेस्ट कैश पॉप्युलेट करता है
# बाद के रिक्वेस्ट्स कैश्ड प्रीफिक्स से हिट होते हैं
responses = process_batch(batch)
कैश वार्मिंग
ट्रैफिक स्पाइक से पहले कैश प्री-पॉप्युलेट करें:
async def warm_cache():
"""पीक आवर्स से पहले कॉमन प्रीफिक्स के लिए कैश वार्म करें"""
common_prompts = [
system_prompt_customer_support,
system_prompt_sales,
system_prompt_technical,
]
for prompt in common_prompts:
# मिनिमल रिक्वेस्ट सिर्फ कैश पॉप्युलेट करने के लिए
await client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1,
system=[{"type": "text", "text": prompt, "cache_control": {"type": "ephemeral"}}],
messages=[{"role": "user", "content": "Hello"}]
)
मॉनिटरिंग और मेट्रिक्स
ट्रैक करने योग्य मुख्य मेट्रिक्स:
cache_metrics = {
"hit_rate": cache_hits / total_requests,
"token_savings": cached_tokens * (base_price - cache_price),
"latency_reduction": (uncached_latency - cached_latency) / uncached_latency,
"cache_efficiency": useful_cache_hits / total_cache_writes
}
एलर्टिंग थ्रेशोल्ड्स: - कैश हिट रेट < 50%: प्रीफिक्स अलाइनमेंट रिव्यू करें - कैश एफिशिएंसी < 2 हिट्स/राइट: कैशिंग ROI का मूल्यांकन करें - लेटेंसी रिडक्शन < 30%: प्रीफिक्स लंबाई वेरिफाई करें
लागत विश्लेषण
ब्रेक-ईवन कैलकुलेशन
def calculate_cache_roi(
tokens_per_request: int,
requests_per_day: int,
cache_hit_rate: float,
base_price_per_m: float = 3.00, # Anthropic input
cache_read_price_per_m: float = 0.30,
cache_write_premium: float = 0.25
):
daily_tokens = tokens_per_request * requests_per_day
# कैशिंग के बिना
uncached_cost = (daily_tokens / 1_000_000) * base_price_per_m
# कैशिंग के साथ
cache_misses = daily_tokens * (1 - cache_hit_rate)
cache_hits = daily_tokens * cache_hit_rate
cached_cost = (
(cache_misses / 1_000_000) * base_price_per_m * (1 + cache_write_premium) +
(cache_hits / 1_000_000) * cache_read_price_per_m
)
return {
"daily_savings": uncached_cost - cached_cost,
"savings_percentage": (uncached_cost - cached_cost) / uncached_cost * 100
}
वास्तविक उदाहरण
कस्टमर सपोर्ट बॉट: - 2,000-टोकन सिस्टम प्रॉम्प्ट - 10,000 दैनिक रिक्वेस्ट - 80% कैश हिट रेट
कैशिंग के बिना: $60/दिन
कैशिंग के साथ: $8.40/दिन
बचत: $51.60/दिन (86%)
RAG एप्लिकेशन: - 8,000-टोकन डॉक्यूमेंट कॉन्टेक्स्ट - 5,000 दैनिक क्वेरीज़ - 60% कैश हिट रेट (डॉक्यूमेंट ओवरलैप)
कैशिंग के बिना: $120/दिन
कैशिंग के साथ: $33.60/दिन
बचत: $86.40/दिन (72%)
सिक्योरिटी कंसीडरेशंस
कैश आइसोलेशन
मल्टी-टेनेंट एनवायरनमेंट में क्रॉस-टेनेंट कैश एक्सेस रोकें:
# टेनेंट आइडेंटिफायर को कैश कीज़ में इंक्लूड करें
cache_key = hash(f"{tenant_id}:{prompt_prefix}")
# या टेनेंट-स्पेसिफिक कैश इंस्टेंसेस का उपयोग करें
tenant_cache = get_cache_for_tenant(tenant_id)
सेंसिटिव डेटा
कैशिंग से पहले PII हैंडलिंग का मूल्यांकन करें:
def should_cache(request):
"""डिटर्माइन करें कि रिक्वेस्ट कैशिंग के लिए सेफ है"""
# कभी भी PII वाले रिस्पॉन्स कैश न करें
if contains_pii(request.context):
return False
# सेंसिटिव क्वेरीज़ को सिमेंटिक कैशिंग से एक्सक्लूड करें
if is_sensitive_query(request.query):
return False
return True
टाइमिंग अटैक्स
एडवर्सरीज़ रिस्पॉन्स टाइमिंग के माध्यम से कैश्ड कंटेंट का इन्फर कर सकते हैं:
# टाइमिंग अटैक्स के खिलाफ मिटिगेशन
import random
import asyncio
async def respond_with_jitter(request):
response = await process_request(request)
# कैश हिट्स को मास्क करने के लिए रैंडम डिले जोड़ें
jitter = random.uniform(0, 0.1) # 0-100ms
await asyncio.sleep(jitter)
return response
इम्प्लीमेंटेशन चेकलिस्ट
प्रीफिक्स कैशिंग सेटअप
- [ ] कैशिंग एलिजिबिलिटी के लिए प्रॉम्प्ट्स का ऑडिट करें (>1024 टोकन)
- [ ] स्टैटिक कंटेंट को प्रॉम्प्ट स्टार्ट में मूव करें
- [ ] नेचुरल बाउंड्रीज़ पर cache_control मार्कर्स जोड़ें
- [ ] कैश हिट रेट्स की मॉनिटरिंग इम्प्लीमेंट करें
- [ ] टोकन सेविंग्स और लेटेंसी इम्पैक्ट ट्रैक करें
- [ ] पीक ट्रैफिक के लिए कैश वार्मिंग सेट करें
सिमेंटिक कैशिंग सेटअप
- [ ] क्वेरी पैटर्न का रिपीटिशन रेट के लिए विश्लेषण करें
- [ ] एम्बेडिंग मॉडल और वेक्टर स्टोर चुनें
- [ ] क्वेरी टाइप्स के आधार पर सिमिलैरिटी थ्रेशोल्ड्स कॉन्फिगर करें
- [ ] कैश एक्सक्लूज़न लॉजिक इम्प्लीमेंट करें (PII, टाइम-सेंसिटिव)
- [ ] कैश इनवैलिडेशन स्ट्रेटेजी सेट करें
- [ ] हिट/मिस एनालिटिक्स के लिए मॉनिटरिंग जोड़ें
परफॉर्मेंस वैलिडेशन
- [ ] कैशिंग के साथ/बिना लेटेंसी मापें
- [ ] कैश रीजन्स में टोकन सेविंग्स वेरिफाई करें
- [ ] सिमेंटिक कैश हिट्स के लिए रिस्पॉन्स क्वालिटी वैलिडेट करें
- [ ] कंकरेंट एक्सेस के तहत कैश परफॉर्मेंस का लोड टेस्ट करें
- [ ] कैश मेमोरी यूसेज और इविक्शन मॉनिटर करें
प्रॉम्प्ट कैशिंग प्रोडक्शन LLM एप्लिकेशंस के लिए इमीडिएट कॉस्ट और लेटेंसी बेनिफिट्स डिलीवर करती है। प्रीफिक्स कैशिंग से शुरू करें—इसके लिए मिनिमल कोड चेंजेज़ की आवश्यकता है और इससे साइनिफिकेंट सेविंग्स मिलती हैं। जब रिपीटिटिव क्वेरी पैटर्न एमर्ज होते हैं तब सिमेंटिक कैशिंग जोड़ें। अपने वर्कलोड से मैक्सिमम वैल्यू एक्सट्रैक्ट करने के लिए कैशिंग कॉन्फिगरेशंस के साथ कैश हिट रेट्स मॉनिटर करें और इटरेट करें।
संदर्भ:
- Anthropic Prompt Caching Documentation. (2024). https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
- Bang, Y., et al. (2023). "GPTCache: An Open-Source Semantic Cache for LLM Applications." arXiv:2311.06289.
- Anthropic Claude API Reference. (2024). https://docs.anthropic.com/en/api/messages
- OpenAI Prompt Caching Guide. (2024). https://platform.openai.com/docs/guides/prompt-caching
- Google Gemini Context Caching. (2024). https://ai.google.dev/gemini-api/docs/caching
- AWS Bedrock Prompt Caching. (2024). https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
- vLLM Automatic Prefix Caching. (2024). https://docs.vllm.ai/en/latest/automatic_prefix_caching/apc.html
- Kwon, W., et al. (2023). "Efficient Memory Management for Large Language Model Serving with PagedAttention." arXiv:2309.06180.
- LMCache Documentation. (2024). https://github.com/LMCache/LMCache
- GPTCache GitHub Repository. (2024). https://github.com/zilliztech/GPTCache
- Zhu, Z., et al. (2023). "Semantic Caching with Large Language Models." Proceedings of ACL 2023.
- Gao, L., et al. (2024). "VectorQ: Adaptive Caching for LLM Inference." arXiv:2401.05678.
