Prompt caching

එය ක්‍රියා කරන ආකාරය

• Prefix, අනුපිළිවෙලින් — Prompt එක අනුපිළිවෙලින් කියවනු ලැබේ: system prompt, tool definitions, පසුව පණිවිඩ. Cache එක එම අනුපිළිවෙල ආරම්භයේ සිට වෙනස් වන පළමු token එක දක්වා ගැලපේ.
• Hit එකක් ලෙස ගණනය වන්නේ කුමක්ද — මෑතකදී සිදුකළ ඉල්ලීමක අන්තර්ගතයට සමාන අන්තර්ගතයකින් ආරම්භ වන prompt එකක් සහිත ඉල්ලීමකි — සාමාන්‍යයෙන් අලුත් පණිවිඩ එකතු කළ එම සංවාදයේම පෙර වටයකි. ගැලපෙන prefix එක cached input වේ; ඉන් පසුව ඇති සියල්ල සාමාන්‍ය input වේ.
• සියුම් බව (Granularity) — Cache එක prompt එකක් tokens 1,568 blocks වලින් තබා ගන්නා බැවින්, tokens 1,500ක් පමණ වලට වඩා කෙටි prompt එකක් cache නොවේ. පිළිතුරක cached ගණන යනු ඔබේ input ගණන prompt එකේ cached කොටස අනුපාතයෙන් ගුණ කර පහළට වටයා ගත් අගයයි. එය block ප්‍රමාණයේ ගුණාකාරයක් වීම අවශ්‍ය නොවේ.
• Hit එකක් නැතිව — ආරම්භය cache එකේ නැති ඉල්ලීමකට සාමාන්‍ය input rate එකෙන් බිල් කෙරේ. Cached prompts සඳහා ආයු කාලයක් ප්‍රකාශයට පත් කර නැති අතර hit එකක් සහතික නොවේ: ඉල්ලීමක් cache එකෙන් ගත් දේ බැලීමට usage කියවන්න.
• switch එකක් නැත — ඉල්ලීමකින් එයට සහභාගී වීමක් නැති අතර, caching අක්‍රිය කරන field එකක් ද නැත.
• කුමන models ද — සෑම hosted open-weight id එකක්ම. GET /v1/models මගින් capabilities.prompt_caching: true සහ pricing.cached_input_per_million_usd වාර්තා කරයි. Shannon models එක් ස්ථාවර අනුපාතයකට බිල් කරයි.

පිළිතුරක cache hit එකක් බලන්න

එකම දිගු system prompt එකකින් ආරම්භ වන ඉල්ලීම් දෙකක් යවා, ඒ සෑම එකක්ම usage මුද්‍රණය කරන්න. පළමු අංකය ඉල්ලීමේ input එක වන අතර දෙවැන්න එයින් 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

මිල ගණන්

Cached input tokens model එකේ input අනුපාතයෙන් 25% කින් බිල් කරන අතර, එය 1M එකකට $0.001 දක්වා වටයා ඇත. Cache එකට ලිවීමට අමතර පිරිවැයක් නැත, output එක සාමාන්‍ය පරිදි බිල් කෙරේ. එක් එක් id එකක cached අනුපාතය Models & pricing වගුවේ ඇත. Models සහ මිල ගණන්

Call එකක input අය කරන්නේ (input − cached) × input rate + cached × cached rate ලෙසයි. Cached ගණන කිසි විටෙකත් input ගණනට වඩා විශාල නොවේ.

Usage log එක සෑම call එකක්ම cached input ලැයිස්තුගත කරයි. එහි බිල් කළ tokens සහ පිරිවැයට cached rate එක දැනටමත් ඇතුළත්ය. යතුරු සහ භාවිතය

භාවිතා කරන fields

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

Stream කළ පිළිතුරක අවසාන usage හි එම fields ම ඇත. ඔබට එය ඉල්ලීම අවශ්‍ය නැත:

වැඩි cache hits ලබා ගැනීම

• Calls හරහා system prompt සහ tool definitions byte-සමාන ලෙස ස්ථාවරව තබා ගන්න. timestamps හෝ request ids වැනි එක් එක් call එකට අදාළ අගයන් system prompt එකේ නොව, නවතම පණිවිඩයේ අවසානයට ඇතුළත් කරන්න.
• ඉතිහාසයට (history) අලුත් දේ එකතු (append) පමණක් කරන්න. පෙර වට සංස්කරණය කිරීම, කපා හැරීම හෝ සාරාංශ කිරීම මගින් prefix එක වෙනස් වන අතර, පළමු වෙනසින් පසුව ඇති සියල්ල සාමාන්‍ය input ලෙස බිල් කරනු ලැබේ.
• Calls අතර tools, පණිවිඩ හෝ content blocks නැවත පිළිවෙලින් සකස් නොකරන්න, සහ JSON (tool schemas, tool arguments සහ results) සෑම විටම එකම ආකාරයට serialise කරන්න.
• සංවාදයක් සඳහා එකම model id එකක රැඳී සිටින්න, සහ පසු call එක ඊට පෙර call එකෙන් ඉක්මනින් යවන්න.

මෙම අවස්ථාවලදී API එක සංවාදයක ආරම්භය ස්ථාවරව තබා ගනී:

• සංවාදයක පසුව යවන system හෝ developer පණිවිඩයක් එහි ස්ථානයේම රැඳෙයි. එය prompt එකේ ආරම්භය වෙනස් නොකරන බැවින්, ඊට පෙර turns cached ලෙසම පවතී.
• පෙර assistant turns වල tool calls හි arguments සංසන්දනය කරන්නේ අගය අනුවය. එම JSON හි key පිළිවෙල සහ පරතරය වැදගත් නොවේ.
• Endpoints තුනම සංවාදයක් එකම ආකාරයට කියවයි. වෙනත් endpoint එකක දිගටම කරගෙන ගිය සංවාදයක අන්තර්ගතය එකම නම්, එහි බෙදාගත් prefix එක රැඳී පවතී.

ඉල්ලීම් ක්ෂේත්‍ර (Request fields)

prompt_cache_key (Chat Completions සහ Responses) සහ Messages content blocks හි cache_control පිළිගනු ලැබේ, එබැවින් පවතින client code වෙනස් කිරීමකින් තොරව ක්‍රියා කරයි. මේවා අත්‍යවශ්‍ය නොවේ: caching ස්වයංක්‍රීයව සිදුවන අතර ඒවා නොමැතිවද එකලෙස ක්‍රියා කරයි.

Tokens ගණනය කිරීම

නොමිලේ endpoints දෙකක් වන POST /v1/tokenize සහ POST /v1/messages/count_tokens, ඔබ යැවීමට පෙර අපගේ සේවාදායකවල ධාවනය වන open-weight models සඳහා පෙළක හෝ සම්පූර්ණ ඉල්ලීමක tokens ගණනය කරයි. ඒවාට තමන්ගේම පිටුවක් ඇත: Token ගණන් කිරීම