પ્રોમ્પ્ટ કેશિંગ

તે કેવી રીતે કામ કરે છે

• પ્રીફિક્સ, ક્રમ મુજબ — પ્રોમ્પ્ટ ક્રમમાં વાંચવામાં આવે છે: સિસ્ટમ પ્રોમ્પ્ટ, ટૂલ ડેફિનેશન્સ, અને પછી મેસેજ. કેશ તે સિક્વન્સની શરૂઆતથી પ્રથમ અલગ ટોકન સુધી મેચ થાય છે.
• હિટ તરીકે શું ગણવામાં આવે છે — એક વિનંતી જેનો પ્રોમ્પ્ટ તાજેતરની વિનંતી જેવી જ સામગ્રીથી શરૂ થાય છે — સામાન્ય રીતે નવા મેસેજ ઉમેરેલા સમાન વાતચીતનો અગાઉનો ટર્ન. મેચિંગ પ્રીફિક્સ એ કેશ્ડ ઇનપુટ છે; તેની પછીનું બધું નિયમિત ઇનપુટ છે.
• ગ્રેન્યુલારિટી (ઝીણવટ) — કેશ prompt ને 1,568 ટોકન્સના બ્લોક્સમાં રાખે છે, તેથી આશરે 1,500 ટોકન્સથી ટૂંકો prompt કેશ થતો નથી. જવાબમાં કેશ્ડ ગણતરી એટલે તમારી ઇનપુટ ગણતરી ગુણ્યા prompt નો કેશ્ડ હિસ્સો, નીચે ગોળ કરેલી. તે બ્લોક કદનો ગુણાંક હોય તે જરૂરી નથી.
• હિટ વિના — જે રિક્વેસ્ટની શરૂઆત કેશમાં નથી તેનું બિલ સામાન્ય ઇનપુટ દરે થાય છે. કેશ્ડ prompt માટે કોઈ આયુષ્ય જાહેર કરેલ નથી અને હિટની ખાતરી નથી: રિક્વેસ્ટે કેશમાંથી શું લીધું તે જોવા usage વાંચો.
• કોઈ સ્વિચ નથી — રિક્વેસ્ટ opt-in કરતી નથી, અને કોઈ ફીલ્ડ કેશિંગ બંધ કરતું નથી.
• કયા મોડેલ્સ — દરેક હોસ્ટેડ ઓપન-વેઇટ id. GET /v1/models તેમના માટે capabilities.prompt_caching: true અને pricing.cached_input_per_million_usd રિપોર્ટ કરે છે. Shannon મોડેલ્સ એક ફ્લેટ રેટ બિલ કરે છે.

જવાબમાં કેશ હિટ જુઓ

સમાન લાંબા system prompt થી શરૂ થતી બે રિક્વેસ્ટ મોકલો અને દરેકનો વપરાશ છાપો. પહેલો આંકડો રિક્વેસ્ટનું ઇનપુટ છે, બીજો તેનો કેશમાંથી વંચાયેલો ભાગ છે.

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 ટેબલમાં છે. મોડેલ્સ અને કિંમત

કોલના ઇનપુટનો ચાર્જ (input − cached) × input દર + cached × cached દર મુજબ લાગે છે. કેશ્ડ ગણતરી ઇનપુટ ગણતરી કરતાં ક્યારેય મોટી હોતી નથી.

વપરાશ લોગ દરેક કોલનું કેશ્ડ ઇનપુટ યાદી કરે છે. તેના બિલ થયેલા ટોકન્સ અને ખર્ચમાં કેશ્ડ દર પહેલેથી શામેલ છે. 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
  }
}

સ્ટ્રીમ થતા જવાબના અંતિમ usage માં સમાન ફીલ્ડ હોય છે. તમારે તે માંગવું પડતું નથી:

વધુ કેશ હિટ્સ મેળવવા માટે

• કોલ્સ દરમિયાન સિસ્ટમ પ્રોમ્પ્ટ અને ટૂલ ડેફિનેશન્સને બાઇટ-ફોર-બાઇટ સ્ટેબલ રાખો. ટાઇમસ્ટેમ્પ અથવા રિક્વેસ્ટ ids જેવા પ્રતિ-કોલ મૂલ્યોને સિસ્ટમ પ્રોમ્પ્ટમાં નહીં, પરંતુ છેલ્લા મેસેજમાં અંતે મૂકો.
• માત્ર હિસ્ટ્રીમાં ઉમેરો (append). અગાઉના ટર્ન્સને એડિટ કરવા, ટ્રિમ કરવા અથવા સમરાઇઝ કરવાથી પ્રીફિક્સ બદલાય છે, અને પ્રથમ ફેરફાર પછીનું બધું નિયમિત ઇનપુટ તરીકે બિલ કરવામાં આવે છે.
• કોલ્સ વચ્ચે ટૂલ્સ, મેસેજ અથવા કન્ટેન્ટ બ્લોક્સનો ક્રમ બદલશો નહીં, અને JSON (ટૂલ સ્કીમા, ટૂલ આર્ગ્યુમેન્ટ્સ અને પરિણામો) ને દર વખતે એક જ રીતે સિરિયલાઇઝ કરો.
• આખી વાતચીત માટે એક જ મોડેલ id પર રહો, અને આગલો કોલ તેના પહેલાના કોલ પછી જલદી મોકલો.

આ કિસ્સાઓમાં API વાતચીતની શરૂઆતને સ્થિર રાખે છે:

• વાતચીતમાં પછીથી મોકલેલો system અથવા developer મેસેજ તેની જગ્યાએ જ રહે છે. તે prompt ની શરૂઆત બદલતો નથી, તેથી તેની પહેલાંના ટર્ન્સ કેશ્ડ રહે છે.
• અગાઉના assistant ટર્ન્સમાં ટૂલ કોલના આર્ગ્યુમેન્ટ્સ કિંમતથી સરખાવાય છે. તે JSON ના કીનો ક્રમ અને સ્પેસિંગ મહત્વના નથી.
• ત્રણે એન્ડપોઇન્ટ્સ વાતચીત એક જ રીતે વાંચે છે. બીજા એન્ડપોઇન્ટ પર ચાલુ રાખેલી વાતચીત, કન્ટેન્ટ સમાન હોય ત્યારે, તેનો સહિયારો પ્રીફિક્સ જાળવે છે.

રિક્વેસ્ટ ફીલ્ડ્સ

prompt_cache_key (Chat Completions અને Responses) અને Messages કન્ટેન્ટ બ્લોક્સ પર cache_control સ્વીકારવામાં આવે છે, જેથી હાલનો ક્લાયન્ટ કોડ બદલ્યા વગર ચાલે છે. બંને જરૂરી નથી: કેશિંગ ઓટોમેટિક છે અને તેના વગર પણ તે રીતે જ કામ કરે છે.

ટોકન્સની ગણતરી

બે મફત એન્ડપોઇન્ટ્સ, POST /v1/tokenize અને POST /v1/messages/count_tokens, તમે મોકલો તે પહેલાં હોસ્ટેડ open-weight મોડેલ્સ માટે ટેક્સ્ટ અથવા આખી રિક્વેસ્ટના ટોકન્સ ગણે છે. તેમનું પોતાનું પેજ છે: ટોકન ગણતરી