प्रॉम्प्ट कैशिंग

यह कैसे काम करता है

• प्रीफ़िक्स, क्रम में — प्रॉम्प्ट को क्रम में पढ़ा जाता है: सिस्टम प्रॉम्प्ट, टूल डेफिनिशन, और फिर संदेश। कैश उस अनुक्रम की शुरुआत से पहले टोकन तक मेल खाता है जो भिन्न होता है।
• हिट क्या माना जाता है — एक ऐसी रिक्वेस्ट जिसका प्रॉम्प्ट हालिया रिक्वेस्ट के समान सामग्री से शुरू होता है — आमतौर पर एक ही बातचीत का पिछला टर्न जिसमें नए संदेश जोड़े गए हों। मेल खाने वाला प्रीफ़िक्स कैश्ड इनपुट है; उसके बाद सब कुछ रेगुलर इनपुट है।
• ग्रैन्युलैरिटी — कैश प्रॉम्प्ट को 1,568 टोकन के ब्लॉक में रखता है, इसलिए लगभग 1,500 टोकन से छोटा प्रॉम्प्ट कैश नहीं होता। उत्तर में कैश्ड गिनती आपकी इनपुट गिनती को प्रॉम्प्ट के कैश्ड हिस्से से गुणा करके, नीचे की ओर पूर्णांकित की जाती है। यह ज़रूरी नहीं कि ब्लॉक साइज़ का गुणज हो।
• हिट के बिना — जिस अनुरोध की शुरुआत कैश में नहीं है, उसका बिल सामान्य इनपुट दर पर बनता है। कैश्ड प्रॉम्प्ट की कोई अवधि प्रकाशित नहीं है और हिट की गारंटी नहीं है: अनुरोध ने कैश से क्या लिया, यह देखने के लिए usage पढ़ें।
• कोई स्विच नहीं — अनुरोध ऑप्ट-इन नहीं करता, और कोई फ़ील्ड कैशिंग बंद नहीं करता।
• कौन से मॉडल — प्रत्येक होस्टेड ओपन-वेट id। GET /v1/models उनके लिए capabilities.prompt_caching: true और pricing.cached_input_per_million_usd रिपोर्ट करता है। Shannon मॉडल एक फ्लैट रेट बिल करते हैं।

उत्तर में कैश हिट देखें

एक ही लंबे सिस्टम प्रॉम्प्ट से शुरू होने वाले दो अनुरोध भेजें और हर एक का उपयोग प्रिंट करें। पहली संख्या अनुरोध का इनपुट है, दूसरी उसका वह हिस्सा है जो कैश से पढ़ा गया।

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

handbook = open("handbook.txt").read()  # a long text that stays the same


def ask(question):
    response = client.chat.completions.create(
        model="Kimi-K3-3BIT-REAP",
        messages=[
            {"role": "system", "content": handbook},
            {"role": "user", "content": question},
        ],
    )
    usage = response.usage
    print(usage.prompt_tokens, usage.prompt_tokens_details.cached_tokens)


ask("What is the refund policy?")
ask("Who approves travel?")  # same start: read the second number

import { readFileSync } from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });

const handbook = readFileSync("handbook.txt", "utf8"); // a long text that stays the same

async function ask(question) {
  const response = await client.chat.completions.create({
    model: "Kimi-K3-3BIT-REAP",
    messages: [
      { role: "system", content: handbook },
      { role: "user", content: question },
    ],
  });
  const usage = response.usage;
  console.log(usage.prompt_tokens, usage.prompt_tokens_details.cached_tokens);
}

await ask("What is the refund policy?");
await ask("Who approves travel?"); // same start: read the second number

# handbook.txt is a long text that stays the same. jq builds the JSON body from it
# and prints the usage object of the reply. Run it twice with different questions.
jq -Rs '{
    model: "Kimi-K3-3BIT-REAP",
    messages: [
      {role: "system", content: .},
      {role: "user", content: "What is the refund policy?"}
    ]
  }' handbook.txt \
  | curl -s https://api.shannon-ai.com/v1/chat/completions \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d @- \
  | jq .usage

कीमत

कैश किए गए इनपुट टोकन मॉडल की इनपुट रेट के 25% पर बिल किए जाते हैं, जिसे $0.001 प्रति 1M तक राउंड किया जाता है। कैश में लिखने की कोई अतिरिक्त लागत नहीं है, और आउटपुट सामान्य रूप से बिल किया जाता है। प्रत्येक id की कैश रेट 'Models & pricing' टेबल में है। मॉडल और कीमतें

एक कॉल के इनपुट का शुल्क इस तरह लगता है: (इनपुट − कैश्ड) × इनपुट दर + कैश्ड × कैश्ड दर। कैश्ड गिनती कभी इनपुट गिनती से बड़ी नहीं होती।

उपयोग लॉग हर कॉल का कैश्ड इनपुट सूचीबद्ध करता है। उसके बिल किए गए टोकन और लागत में कैश्ड दर पहले से शामिल है। Keys और उपयोग

उपयोग फ़ील्ड

{
  "usage": {
    "prompt_tokens": 20000,
    "completion_tokens": 812,
    "total_tokens": 20812,
    "prompt_tokens_details": {
      "cached_tokens": 18000
    },
    "completion_tokens_details": {
      "reasoning_tokens": 604
    }
  }
}

{
  "usage": {
    "input_tokens": 20000,
    "input_tokens_details": {
      "cached_tokens": 18000
    },
    "output_tokens": 812,
    "output_tokens_details": {
      "reasoning_tokens": 604
    },
    "total_tokens": 20812
  }
}

{
  "usage": {
    "input_tokens": 2000,
    "cache_read_input_tokens": 18000,
    "cache_creation_input_tokens": 0,
    "output_tokens": 812
  }
}

स्ट्रीम किया गया उत्तर अपने अंतिम usage में वही फ़ील्ड रखता है। आपको इसे माँगना नहीं पड़ता:

अधिक कैश हिट्स प्राप्त करना

• कॉल्स के दौरान सिस्टम प्रॉम्प्ट और टूल डेफिनिशन को बाइट-दर-बाइट स्थिर रखें। टाइमस्टैम्प या रिक्वेस्ट ids जैसे प्रति-कॉल मानों को नवीनतम संदेश के अंत में रखें, सिस्टम प्रॉम्प्ट में नहीं।
• केवल हिस्ट्री में अपेंड करें। पिछले टर्न को एडिट करना, ट्रिम करना या समराइज करना प्रीफ़िक्स को बदल देता है, और पहले बदलाव के बाद सब कुछ रेगुलर इनपुट के रूप में बिल किया जाता है।
• कॉल्स के बीच टूल्स, संदेशों या कंटेंट ब्लॉक्स को पुनर्व्यवस्थित न करें, और JSON (टूल स्कीमा, टूल आर्गुमेंट्स और परिणाम) को हर बार एक ही तरह से सीरियलाइज़ करें।
• एक बातचीत के लिए एक ही मॉडल id पर बने रहें, और अगली कॉल पिछली कॉल के तुरंत बाद भेजें।

API इन मामलों में बातचीत की शुरुआत स्थिर रखता है:

• बातचीत में बाद में भेजा गया system या developer संदेश अपनी जगह पर रहता है। यह प्रॉम्प्ट की शुरुआत नहीं बदलता, इसलिए उससे पहले के टर्न कैश्ड रहते हैं।
• पिछले assistant टर्न की टूल कॉल के आर्गुमेंट मान के आधार पर तुलना किए जाते हैं। उस JSON में key का क्रम और स्पेसिंग मायने नहीं रखती।
• तीनों endpoints बातचीत को एक ही तरह पढ़ते हैं। किसी दूसरे endpoint पर जारी रखी गई बातचीत अपना साझा प्रीफ़िक्स तब बनाए रखती है जब कंटेंट वही हो।

रिक्वेस्ट फ़ील्ड्स

prompt_cache_key (Chat Completions और Responses) और Messages कंटेंट ब्लॉक्स पर cache_control स्वीकार किए जाते हैं, ताकि मौजूदा क्लाइंट कोड बिना बदलाव के चल सके। इनमें से कोई भी अनिवार्य नहीं है: कैशिंग ऑटोमैटिक है और इनके बिना भी समान रूप से काम करती है।

टोकन गणना (Counting tokens)

दो मुफ़्त endpoints, POST /v1/tokenize और POST /v1/messages/count_tokens, आपके भेजने से पहले होस्टेड ओपन-वेट मॉडल के लिए किसी टेक्स्ट या पूरे अनुरोध के टोकन गिनते हैं। इनका अपना पेज है: टोकन गिनती