ప్రాంప్ట్ క్యాషింగ్

ఇది ఎలా పనిచేస్తుంది

• ప్రిఫిక్స్, క్రమంలో — ప్రాంప్ట్ ఈ క్రమంలో చదవబడుతుంది: సిస్టమ్ ప్రాంప్ట్, టూల్ డెఫినిషన్స్, ఆపై మెసేజ్‌లు. క్యాష్ ఆ సీక్వెన్స్ ప్రారంభం నుండి మొదటి భిన్నమైన టోకెన్ వరకు మ్యాచ్ అవుతుంది.
• హిట్‌గా ఏమి పరిగణించబడుతుంది — ఇటీవలి రిక్వెస్ట్‌తో సమానమైన కంటెంట్‌తో ప్రారంభమయ్యే ప్రాంప్ట్ రిక్వెస్ట్ — సాధారణంగా కొత్త మెసేజ్‌లు జోడించబడిన అదే సంభాషణ యొక్క మునుపటి టర్న్. మ్యాచ్ అయిన ప్రిఫిక్స్ క్యాష్డ్ ఇన్‌పుట్‌గా పరిగణించబడుతుంది; దాని తర్వాత ఉన్నవన్నీ రెగ్యులర్ ఇన్‌పుట్‌లు.
• గ్రాన్యులారిటీ — క్యాష్ ప్రాంప్ట్‌ను 1,568 tokens బ్లాక్‌లుగా ఉంచుతుంది, కాబట్టి సుమారు 1,500 tokens కంటే చిన్న ప్రాంప్ట్ క్యాష్ చేయబడదు. సమాధానంలో క్యాష్ చేసిన సంఖ్య అంటే మీ ఇన్‌పుట్ సంఖ్యను ప్రాంప్ట్‌లో క్యాష్ చేసిన వాటా తో గుణించి, కిందికి పూర్తి చేసినది. ఇది తప్పనిసరిగా బ్లాక్ పరిమాణం యొక్క గుణిజం కాదు.
• హిట్ లేకపోతే — ప్రారంభ భాగం క్యాష్‌లో లేని రిక్వెస్ట్‌కు సాధారణ ఇన్‌పుట్ రేటుతో బిల్ చేయబడుతుంది. క్యాష్ చేసిన ప్రాంప్ట్‌లకు జీవితకాలం ప్రచురించబడలేదు మరియు హిట్ హామీ ఇవ్వబడదు: రిక్వెస్ట్ క్యాష్ నుండి ఏమి తీసుకుందో చూడటానికి usage చదవండి.
• స్విచ్ లేదు — రిక్వెస్ట్ ఎంచుకోవాల్సిన అవసరం లేదు, మరియు క్యాషింగ్‌ను ఆఫ్ చేసే ఫీల్డ్ ఏదీ లేదు.
• ఏ మోడల్స్ — ప్రతి హోస్టెడ్ ఓపెన్-వెయిట్ id. GET /v1/models వాటి కోసం capabilities.prompt_caching: true మరియు pricing.cached_input_per_million_usd ని రిపోర్ట్ చేస్తుంది. Shannon మోడల్స్ ఒకే ఫ్లాట్ రేట్‌ను బిల్లింగ్ చేస్తాయి.

సమాధానంలో క్యాష్ హిట్‌ను చూడండి

ఒకే పొడవైన system prompt తో మొదలయ్యే రెండు రిక్వెస్ట్‌లను పంపి, ప్రతిదాని usage ను ప్రింట్ చేయండి. మొదటి సంఖ్య రిక్వెస్ట్ ఇన్‌పుట్, రెండవది అందులో క్యాష్ నుండి చదివిన భాగం.

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 టేబుల్‌లో ఉంది. మోడల్స్ & ధరలు

కాల్ యొక్క ఇన్‌పుట్‌కు ఛార్జ్ ఇలా ఉంటుంది: (ఇన్‌పుట్ − క్యాష్ చేసినది) × ఇన్‌పుట్ రేటు + క్యాష్ చేసినది × క్యాష్ రేటు. క్యాష్ చేసిన సంఖ్య ఇన్‌పుట్ సంఖ్య కంటే ఎప్పుడూ పెద్దది కాదు.

usage లాగ్ ప్రతి కాల్ యొక్క క్యాష్ చేసిన ఇన్‌పుట్‌ను జాబితా చేస్తుంది. దాని బిల్ చేసిన tokens మరియు ఖర్చులో క్యాష్ రేటు ఇప్పటికే చేర్చబడింది. Keys & usage

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

స్ట్రీమ్ చేసిన సమాధానం తన చివరి usage లో అవే ఫీల్డ్‌లను కలిగి ఉంటుంది. మీరు దాన్ని అడగాల్సిన అవసరం లేదు:

మరిన్ని క్యాష్ హిట్‌లను పొందడం ఎలా

• కాల్స్ అంతటా సిస్టమ్ ప్రాంప్ట్ మరియు టూల్ డెఫినిషన్లను బైట్-బైట్ స్థిరంగా ఉంచండి. టైమ్‌స్టాంప్‌లు లేదా రిక్వెస్ట్ ids వంటి ప్రతి-కాల్ విలువలను సిస్టమ్ ప్రాంప్ట్‌లో కాకుండా, చివరి మెసేజ్ చివరలో ఉంచండి.
• హిస్టరీకి కేవలం అపెండ్ (జోడించడం) చేయండి. మునుపటి టర్న్స్‌ను ఎడిట్ చేయడం, ట్రిమ్ చేయడం లేదా సారాంశం చేయడం వల్ల ప్రిఫిక్స్ మారుతుంది, మరియు మొదటి మార్పు తర్వాత ఉన్నవన్నీ రెగ్యులర్ ఇన్‌పుట్‌గా బిల్లింగ్ చేయబడతాయి.
• కాల్స్ మధ్య టూల్స్, మెసేజ్‌లు లేదా కంటెంట్ బ్లాక్‌లను రీఆర్డర్ చేయవద్దు, మరియు JSON (టూల్ స్కీమాలు, టూల్ ఆర్గ్యుమెంట్స్ మరియు ఫలితాలు) ను ప్రతిసారీ ఒకే విధంగా సీరియలైజ్ చేయండి.
• ఒక సంభాషణ కోసం ఒకే మోడల్ id ని వాడండి, మరియు తదుపరి కాల్‌ను ముందు కాల్ తర్వాత త్వరగా పంపండి.

ఈ సందర్భాల్లో API సంభాషణ ప్రారంభాన్ని స్థిరంగా ఉంచుతుంది:

• సంభాషణలో తర్వాత పంపిన system లేదా developer మెసేజ్ తన స్థానంలోనే ఉంటుంది. ఇది ప్రాంప్ట్ ప్రారంభాన్ని మార్చదు, కాబట్టి దానికి ముందు ఉన్న టర్న్‌లు క్యాష్‌లోనే ఉంటాయి.
• మునుపటి assistant టర్న్‌లలోని టూల్ కాల్స్ ఆర్గ్యుమెంట్‌లు విలువ ద్వారా పోల్చబడతాయి. ఆ JSON లోని కీల క్రమం మరియు స్పేసింగ్ పట్టింపు కాదు.
• మూడు ఎండ్‌పాయింట్‌లు సంభాషణను ఒకే విధంగా చదువుతాయి. మరో ఎండ్‌పాయింట్‌లో కొనసాగించిన సంభాషణ, కంటెంట్ ఒకటే అయితే, ఉమ్మడి ప్రిఫిక్స్‌ను నిలుపుకుంటుంది.

రిక్వెస్ట్ ఫీల్డ్స్

prompt_cache_key (Chat Completions మరియు Responses) మరియు Messages కంటెంట్ బ్లాక్‌లపై cache_control అంగీకరించబడతాయి, కాబట్టి ప్రస్తుత క్లయింట్ కోడ్ మార్పు లేకుండా రన్ అవుతుంది. ఈ రెండూ తప్పనిసరి కాదు: క్యాషింగ్ ఆటోమేటిక్‌గా జరుగుతుంది మరియు అవి లేకపోయినా అదే విధంగా పనిచేస్తుంది.

టోకెన్ల గణన

రెండు ఉచిత ఎండ్‌పాయింట్‌లు, POST /v1/tokenize మరియు POST /v1/messages/count_tokens, మీరు పంపే ముందే హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్ కోసం ఒక టెక్స్ట్ లేదా మొత్తం రిక్వెస్ట్ యొక్క tokens ను లెక్కిస్తాయి. వాటికి ప్రత్యేక పేజీ ఉంది: Token లెక్కింపు