பிராம்ப்ட் கேச்சிங்

இது எவ்வாறு செயல்படுகிறது

• முன்னொட்டு வரிசை — பிராம்ப்ட் இந்த வரிசையில் படிக்கப்படுகிறது: சிஸ்டம் பிராம்ப்ட், டூல் வரையறைகள், பிறகு செய்திகள். இந்த வரிசையின் தொடக்கத்திலிருந்து முதல் மாறுபட்ட டோக்கன் வரை உள்ள பகுதி கேச்சில் பொருந்தும்.
• ஹிட் (Hit) என எது கணக்கிடப்படும் — சமீபத்திய கோரிக்கையின் அதே உள்ளடக்கத்துடன் தொடங்கும் ஒரு கோரிக்கை — பொதுவாக புதிய செய்திகள் இணைக்கப்பட்ட அதே உரையாடலின் முந்தைய சுற்று. பொருந்தும் முன்னொட்டு கேச் செய்யப்பட்ட உள்ளீடாகும்; அதற்குப் பிறகு உள்ள அனைத்தும் வழக்கமான உள்ளீடு.
• துல்லியம் (Granularity) — cache ஒரு prompt-ஐ 1,568 டோக்கன் blocks-ஆக வைத்திருக்கும், எனவே சுமார் 1,500 டோக்கன்களுக்குக் குறைவான prompt cache செய்யப்படாது. பதிலிலுள்ள cache எண்ணிக்கை என்பது உங்கள் உள்ளீட்டு எண்ணிக்கையை prompt-ன் cache செய்யப்பட்ட பங்கால் பெருக்கிக் கீழே முழுதாக்கியது. அது block அளவின் மடங்காக இருக்க வேண்டியதில்லை.
• hit இல்லாதபோது — தொடக்கம் cache-ல் இல்லாத கோரிக்கைக்கு வழக்கமான உள்ளீட்டு விலையில் கட்டணம் விதிக்கப்படும். cache செய்யப்பட்ட prompts-க்கு ஆயுட்காலம் வெளியிடப்படவில்லை, hit உறுதியும் இல்லை: கோரிக்கை cache-லிருந்து என்ன எடுத்தது என்பதை அறிய usage-ஐப் படியுங்கள்.
• சுவிட்ச் இல்லை — கோரிக்கை இதில் சேர வேண்டியதில்லை, caching-ஐ அணைக்க எந்தப் புலமும் இல்லை.
• எந்த மாடல்கள் — ஒவ்வொரு ஹோஸ்டட் ஓபன்-வெயிட் id-யும். GET /v1/models அவற்றின் capabilities.prompt_caching: true மற்றும் pricing.cached_input_per_million_usd ஆகியவற்றை அறிக்கையிடுகிறது. Shannon மாடல்கள் ஒரே நிலையான விலையை வசூலிக்கின்றன.

பதிலில் cache hit-ஐப் பாருங்கள்

ஒரே நீண்ட system prompt-டன் தொடங்கும் இரண்டு கோரிக்கைகளை அனுப்பி, ஒவ்வொன்றின் usage-ஐயும் அச்சிடுங்கள். முதல் எண் கோரிக்கையின் உள்ளீடு, இரண்டாவது அதில் cache-லிருந்து படிக்கப்பட்ட பகுதி.

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% வசூலிக்கப்படும், இது 1M-க்கு $0.001 என முழுமைப்படுத்தப்படுகிறது. கேச்சில் எழுதுவதற்கு கூடுதல் கட்டணம் இல்லை, மற்றும் வெளியீடு வழக்கம்போல வசூலிக்கப்படுகிறது. ஒவ்வொரு id-யின் கேச் விகிதம் 'Models & pricing' அட்டவணையில் உள்ளது. மாடல்கள் & விலை

ஒரு அழைப்பின் உள்ளீட்டுக்கான கட்டணம்: (உள்ளீடு − cache செய்தது) × உள்ளீட்டு விலை + cache செய்தது × cache விலை. cache எண்ணிக்கை உள்ளீட்டு எண்ணிக்கையை விடப் பெரிதாக இருக்காது.

usage பதிவு ஒவ்வொரு அழைப்பின் cache செய்த உள்ளீட்டைப் பட்டியலிடும். அதன் கட்டணம் விதிக்கப்பட்ட டோக்கன்களிலும் செலவிலும் cache விலை ஏற்கனவே சேர்ந்துள்ளது. Keys & usage

பயன்பாட்டு புலங்கள்

{
  "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
  }
}

streamed பதிலின் இறுதி usage-லும் அதே புலங்கள் இருக்கும். அதற்காக நீங்கள் தனியாகக் கேட்கத் தேவையில்லை:

அதிக கேச் ஹிட்களைப் பெறுவது எப்படி

• கால்களுக்கு இடையே சிஸ்டம் பிராம்ப்ட் மற்றும் டூல் வரையறைகளை அப்படியே வைத்திருங்கள். டைம்ஸ்டாம்புகள் அல்லது ரிக்வெஸ்ட் ஐடிக்கள் போன்ற மதிப்புகளை சிஸ்டம் பிராம்ப்டில் வைக்காமல், சமீபத்திய செய்தியின் முடிவில் வைக்கவும்.
• வரலாற்றின் முடிவில் மட்டும் சேர்க்கவும் (append). முந்தைய சுற்றுகளைத் திருத்துவது, கத்தரிப்பது அல்லது சுருக்குவது முன்னொட்டை மாற்றும், மேலும் முதல் மாற்றத்திற்குப் பிறகு உள்ள அனைத்தும் வழக்கமான உள்ளீடாக வசூலிக்கப்படும்.
• கால்களுக்கு இடையே டூல்ஸ், செய்திகள் அல்லது உள்ளடக்கத் தொகுப்புகளை மறுவரிசைப்படுத்த வேண்டாம், மேலும் JSON (டூல் ஸ்கீமாக்கள், டூல் ஆர்குமென்ட்கள் மற்றும் முடிவுகள்) ஒவ்வொரு முறையும் ஒரே மாதிரியாக சீரியலைஸ் செய்யவும்.
• ஓர் உரையாடலுக்கு ஒரே மாடல் id-யில் இருங்கள், அடுத்த அழைப்பை முந்தையதற்குப் பிறகு விரைவில் அனுப்புங்கள்.

பின்வரும் சூழல்களில் API உரையாடலின் தொடக்கத்தை நிலையாக வைத்திருக்கும்:

• உரையாடலில் பின்னர் அனுப்பப்படும் system அல்லது developer செய்தி தன் இடத்திலேயே இருக்கும். அது prompt-ன் தொடக்கத்தை மாற்றாது, எனவே அதற்கு முந்தைய சுற்றுகள் cache-ல் இருக்கும்.
• முந்தைய assistant சுற்றுகளிலுள்ள tool அழைப்புகளின் arguments மதிப்பால் ஒப்பிடப்படும். அந்த JSON-ன் key வரிசையும் இடைவெளியும் முக்கியமில்லை.
• மூன்று endpoint-களும் உரையாடலை ஒரே முறையில் படிக்கின்றன. வேறொரு endpoint-ல் தொடரும் உரையாடல், உள்ளடக்கம் ஒன்றாக இருந்தால் பகிர்ந்த முன்னொட்டை வைத்திருக்கும்.

கோரிக்கை புலங்கள் (Request fields)

prompt_cache_key (Chat Completions மற்றும் Responses) மற்றும் Messages உள்ளடக்கத் தொகுதிகளில் cache_control ஆகியவை ஏற்றுக்கொள்ளப்படுகின்றன, எனவே இருக்கும் கிளைன்ட் கோட் மாற்றமின்றி இயங்கும். இவை இரண்டும் அவசியமில்லை: கேச்சிங் (caching) தானியங்கி முறையில் செயல்படும்.

டோக்கன்களைக் கணக்கிடுதல்

இரண்டு இலவச endpoint-கள், POST /v1/tokenize மற்றும் POST /v1/messages/count_tokens, ஹோஸ்ட் செய்யப்பட்ட open-weight மாடல்களுக்கு ஒரு உரையின் அல்லது முழுக் கோரிக்கையின் டோக்கன்களை அனுப்பும் முன்பே எண்ணும். அவற்றுக்குத் தனிப் பக்கம் உண்டு: Token எண்ணிக்கை