Հարցման քեշավորում

Ինչպես է այն աշխատում

• Նախշարքը՝ ըստ հերթականության — Հարցումը կարդացվում է ըստ հերթականության՝ համակարգային հարցում, գործիքների սահմանումներ, ապա հաղորդագրություններ: Քեշը համընկնում է այդ հաջորդականության սկզբից մինչև առաջին տարբերվող թոքենը:
• Ի՞նչն է համարվում hit — Հարցում, որի նախշարքը սկսվում է նույն բովանդակությամբ, ինչ վերջին հարցումը — սովորաբար նույն զրույցի նախորդ փուլն է, որին կցվել են նոր հաղորդագրություններ: Համընկնող նախշարքը քեշավորված մուտք է; դրանից հետո ամեն ինչ սովորական մուտք է:
• Մանրամասնություն — Cache-ը պահում է prompt-ը 1,568 թոքենանոց բլոկներով, ուստի մոտ 1,500 թոքենից կարճ prompt-ը չի cache-վում։ Պատասխանում cache-ված քանակը ձեր մուտքի քանակն է՝ բազմապատկած prompt-ի cache-ված բաժնով և կլորացված ներքև։ Այն պարտադիր չէ, որ բլոկի չափի բազմապատիկ լինի։
• Առանց hit-ի — Հարցումը, որի սկիզբը cache-ում չէ, հաշվարկվում է սովորական մուտքի գնով։ Cache-ված prompt-ների կյանքի տևողություն չի հրապարակվում, և hit-ը երաշխավորված չէ. կարդացեք usage-ը՝ տեսնելու համար, թե հարցումը ինչ է վերցրել cache-ից։
• Անջատիչ չկա — Հարցումը չի միացնում cache-ը, և ոչ մի դաշտ չի անջատում այն։
• Ո՞ր մոդելները — Յուրաքանչյուր hosted open-weight 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%-ով, կլորացված մինչև $0.001 per 1M: Քեշի գրումը լրացուցիչ ծախսեր չունի, իսկ ելքը հաշվարկվում է սովորական կերպով: Յուրաքանչյուր id-ի քեշավորված սակագնը նշված է Models & pricing աղյուսակում: Մոդելներ և գներ

Կանչի մուտքը գանձվում է (մուտք − cache-ված) × մուտքի գին + cache-ված × cache-ի գին։ Cache-ված քանակը երբեք մեծ չէ մուտքի քանակից։

Օգտագործման մատյանը ցույց է տալիս յուրաքանչյուր կանչի cache-ված մուտքը։ Դրա հաշվարկված թոքենները և արժեքն արդեն ներառում են cache-ի գինը։ Բանալիներ և օգտագործում

Օգտագործման դաշտեր

{
  "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-ում։ Այն պահանջել պետք չէ.

Ինչպես ավտոմատացնել cache hit-երը

• Պահպանեք համակարգային հարցումը և գործիքների սահմանումները բայթ-բայթ կայուն կոչումների միջև: Յուրաքանչյուր կոչման արժեքները, ինչպիսիք են ժամանակի նշումները կամ հարցումների id-ները, տեղադրեք վերջին հաղորդագրության մեջ, ոչ թե համակարգային հարցման:
• Միայն կցեք (append) պատմությանը: Նախորդ փուլերի խմբագրումը, կրճատումը կամ ամփոփումը փոխում է նախշարքը, և առաջին փոփոխությունից հետո ամեն ինչ հաշվարկվում է որպես սովորական մուտք:
• Մի փոխեք գործիքների, հաղորդագրությունների կամ բովանդակության բլոկների հերթականությունը կոչումների միջև, և ամեն անգամ նույն ձևով սերիալիզացրեք JSON-ը (գործիքների սխեմաները, արգումենտները և արդյունքները):
• Զրույցի ընթացքում մնացեք մեկ մոդելի id-ի վրա և հաջորդ կանչն ուղարկեք նախորդից անմիջապես հետո։

API-ն զրույցի սկիզբը կայուն է պահում հետևյալ դեպքերում.

• Զրույցի ավելի ուշ ուղարկված system կամ developer հաղորդագրությունը մնում է իր տեղում։ Այն չի փոխում prompt-ի սկիզբը, ուստի դրանից առաջ եղած փուլերը մնում են cache-ում։
• Նախորդ assistant փուլերում գործիքների կանչերի արգումենտները համեմատվում են ըստ արժեքի։ Այդ JSON-ի բանալիների հերթականությունը և բացատները նշանակություն չունեն։
• Երեք endpoint-ները զրույցը կարդում են նույն ձևով։ Մեկ այլ endpoint-ում շարունակված զրույցը պահում է իր ընդհանուր նախածանցը, երբ բովանդակությունը նույնն է։

Հարցման դաշթեր

Ընդունվում են prompt_cache_key (Chat Completions և Responses) և cache_control դաշթերը Messages բովանդակության բլոկների համար, ուստի գոյություն ունեցող կլիենտային կոդը աշխատում է անփոփոխ: Ոչինչ պարտադիր չէ. քեշավորումն ավտոմատ է և աշխատում է նույն կերպ նրանց առանց:

Թոքենների հաշվարկ

Երկու անվճար endpoint, POST /v1/tokenize և POST /v1/messages/count_tokens, hosted open-weight մոդելների համար հաշվում են տեքստի կամ ամբողջ հարցման թոքենները մինչև ուղարկելը։ Դրանք ունեն իրենց էջը. Թոքենների հաշվարկ