ការរក្សាទុក Prompt

របៀបដែលវាដំណើរការ

• Prefix តាមលំដាប់ — Prompt ត្រូវបានអានតាមលំដាប់៖ system prompt, tool definitions, រួចហើយទើបដល់សារ (messages)។ Cache ផ្គូផ្គងចាប់ពីការចាប់ផ្តើមនៃលំដាប់នោះ រហូតដល់ token ដំបូងដែលខុសគ្នា។
• អ្វីដែលរាប់ថាជា hit — Request ដែល prompt របស់វាចាប់ផ្តើមដោយមាតិកាដូចគ្នាទៅនឹង request ថ្មីៗ — ជាទូទៅគឺជាការសន្ទនាមុន ដែលមានសារថ្មីៗបន្ថែមនៅខាងក្រោម។ Prefix ដែលផ្គូផ្គងគ្នាគឺជា cached input; រាល់អ្វីៗបន្ទាប់ពីនោះគឺជា regular input។
• កម្រិតលម្អិត (Granularity) — cache រក្សា prompt ជា block ទំហំ 1,568 token ដូច្នេះ prompt ដែលខ្លីជាងប្រហែល 1,500 token មិនត្រូវបាន cache ទេ។ ចំនួន cached ក្នុងចម្លើយ គឺចំនួន input របស់អ្នកគុណនឹងភាគរយ cached នៃ prompt ហើយបង្គត់ចុះ។ វាមិនចាំបាច់ជាពហុគុណនៃទំហំ block ទេ។
• ដោយគ្មាន hit — request ដែលការចាប់ផ្តើមរបស់វាមិនមាននៅក្នុង cache ត្រូវបានគិតថ្លៃតាមតម្លៃ input ធម្មតា។ គ្មានអាយុកាលណាត្រូវបានផ្សព្វផ្សាយសម្រាប់ prompt ក្នុង cache ទេ ហើយ hit មិនត្រូវបានធានាទេ៖ សូមអាន usage ដើម្បីមើលអ្វីដែល request បានយកពី cache។
• គ្មានកុងតាក់ — request មិនចាំបាច់ជ្រើសចូល ហើយគ្មាន field ណាបិទ caching ទេ។
• Model ណាខ្លះ — រាល់ hosted open-weight id ទាំងអស់។ GET /v1/models រាយការណ៍ capabilities.prompt_caching: true និង pricing.cached_input_per_million_usd សម្រាប់ពួកវា។ Shannon models គិតថ្លៃក្នុងអត្រាតែមួយ។

មើល cache hit ក្នុងចម្លើយ

ផ្ញើ request ពីរដែលចាប់ផ្តើមដោយ system prompt វែងដូចគ្នា ហើយបោះពុម្ព usage នៃមួយៗ។ លេខទីមួយគឺ input នៃ request លេខទីពីរគឺផ្នែកនៃវាដែលអានពី 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 គិតថ្លៃ ២៥% នៃអត្រា input របស់ model, គណនាជិតបំផុតដល់ $0.001 ក្នុង ១M។ ការសរសេរចូល cache មិនអស់ថ្លៃបន្ថែមទេ ហើយ output ត្រូវបានគិតថ្លៃដូចធម្មតា។ អត្រា cached នៃ id នីមួយៗមាននៅក្នុងតារាង Models & pricing។ ម៉ូដែល និងតម្លៃ

input នៃការហៅមួយត្រូវបានគិតថ្លៃជា (input − cached) × តម្លៃ input + cached × តម្លៃ cached។ ចំនួន cached មិនដែលធំជាងចំនួន input ទេ។

usage log រាយ input ក្នុង cache នៃការហៅនីមួយៗ។ token ដែលបានគិតថ្លៃ និងតម្លៃរបស់វារួមបញ្ចូលតម្លៃ cached រួចហើយ។ Keys & usage

ចីឡូនៃការប្រើប្រាស់ (Usage 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 មាន field ដូចគ្នាក្នុង usage ចុងក្រោយរបស់វា។ អ្នកមិនចាំបាច់សុំវាទេ៖

វិធីទទួលបាន cache hits កាន់តែច្រើន

• រក្សា system prompt និង tool definitions ឱ្យនៅថេរ (stable) តាម byte ក្នុងពេលហៅ API នីមួយៗ។ ដាក់តម្លៃដែលផ្លាស់ប្តូរតាម call ដូចជា timestamps ឬ request ids នៅផ្នែកខាងចុងនៃសារចុងក្រោយ មិនមែននៅក្នុង system prompt នោះទេ។
• គ្រាន់តែបន្ថែម (append) ទៅក្នុង history។ ការកែសម្រួល, កាត់បន្ថយ ឬសង្ខេបសារមុនៗនឹងផ្លាស់ប្តូរ prefix ហើយរាល់អ្វីៗបន្ទាប់ពីការផ្លាស់ប្តូរដំបូងនឹងត្រូវបានគិតថ្លៃជា regular input។
• កុំផ្លាស់ប្តូរលំដាប់ tools, messages ឬ content blocks រវាងការហៅ API និងធ្វើការ serialize JSON (tool schemas, tool arguments និង results) តាមរបៀបតែមួយជានិច្ច។
• ប្រើ model id តែមួយសម្រាប់ការសន្ទនាមួយ ហើយផ្ញើការហៅបន្តឱ្យឆាប់បន្ទាប់ពីការហៅមុន។

API រក្សាការចាប់ផ្តើមនៃការសន្ទនាឱ្យនៅស្ថិតស្ថេរក្នុងករណីទាំងនេះ៖

• សារ system ឬ developer ដែលផ្ញើក្រោយក្នុងការសន្ទនា នៅទីតាំងរបស់វា។ វាមិនផ្លាស់ប្តូរការចាប់ផ្តើមរបស់ prompt ទេ ដូច្នេះវគ្គមុនវានៅតែ cache។
• អាគុយម៉ង់នៃការហៅ tool ក្នុងវគ្គ assistant មុនៗ ត្រូវបានប្រៀបធៀបតាមតម្លៃ។ លំដាប់ key និងចន្លោះនៃ JSON នោះមិនសំខាន់ទេ។
• endpoint ទាំងបីអានការសន្ទនាតាមរបៀបដូចគ្នា។ ការសន្ទនាដែលបន្តនៅ endpoint ផ្សេងរក្សា prefix រួមរបស់វា នៅពេលមាតិកាដូចគ្នា។

ចម្បែងនៃសំណើ (Request fields)

prompt_cache_key (Chat Completions និង Responses) និង cache_control នៅលើ Messages content blocks ត្រូវបានទទួលយក ដូច្នេះកូដ client ដែលមានស្រាប់ដំណើរការដោយគ្មានការផ្លាស់ប្តូរ។ វាមិនចាំបាច់មានទាំងពីរនោះទេ៖ ការធ្វើ caching គឺស្វ័យប្រវត្តិ និងដំណើរការដូចគ្នា បើគ្មានពួកវា។

ការគណនា tokens

endpoint ឥតគិតថ្លៃពីរ គឺ POST /v1/tokenize និង POST /v1/messages/count_tokens រាប់ token នៃអត្ថបទ ឬនៃ request ទាំងមូលសម្រាប់ម៉ូដែល open-weight ដែលបង្ហោះ មុនពេលអ្នកផ្ញើវា។ ពួកវាមានទំព័រផ្ទាល់ខ្លួន៖ ការរាប់ token