ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಶಿಂಗ್

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

• ಕ್ರಮಬದ್ಧ ಪ್ರಿಫಿಕ್ಸ್ — ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಈ ಕ್ರಮದಲ್ಲಿ ಓದಲಾಗುತ್ತದೆ: ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್, ಟೂಲ್ ಡೆಫಿನಿಷನ್‌ಗಳು, ನಂತರ ಸಂದೇಶಗಳು. ಕ್ಯಾಶ್ವು ಆ ಅನುಕ್ರಮದ ಪ್ರಾರಂಭದಿಂದ ಮೊದಲ ವ್ಯತ್ಯಾಸದ ಟೋಕನ್ ವರೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
• ಹಿಟ್ ಎಂದು ಯಾವುದನ್ನು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ — ಇತ್ತೀಚಿನ ವಿನಂತಿಯಂತೆಯೇ ಪ್ರಾಂಪ್ಟ್ ಪ್ರಾರಂಭವಾಗುವ ವಿನಂತಿಯನ್ನು ಹಿಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ — ಸಾಮಾನ್ಯವಾಗಿ ಹೊಸ ಸಂದೇಶಗಳನ್ನು ಸೇರಿಸಿದ ಅದೇ ಸಂಭಾಷಣೆಯ ಹಿಂದಿನ ತಿರುವು. ಹೊಂದಿಕೆಯಾಗುವ ಪ್ರಿಫಿಕ್ಸ್ ಕ್ಯಾಶ್ಡ್ ಇನ್‌ಪುಟ್ ಆಗಿದೆ; ಅದರ ನಂತರದ ಎಲ್ಲವೂ ಸಾಮಾನ್ಯ ಇನ್‌ಪುಟ್ ಆಗಿದೆ.
• ಗ್ರಾನುಲಾರಿಟಿ — ಕ್ಯಾಶ್ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು 1,568 ಟೋಕನ್‌ಗಳ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಹಿಡಿದಿಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಸುಮಾರು 1,500 ಟೋಕನ್‌ಗಳಿಗಿಂತ ಚಿಕ್ಕ ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ. ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿನ ಕ್ಯಾಶ್ ಎಣಿಕೆ ನಿಮ್ಮ ಇನ್‌ಪುಟ್ ಎಣಿಕೆಯನ್ನು ಪ್ರಾಂಪ್ಟ್‌ನ ಕ್ಯಾಶ್ ಪಾಲಿನಿಂದ ಗುಣಿಸಿ, ಕೆಳಕ್ಕೆ ಪೂರ್ಣಾಂಕ ಮಾಡಿದ್ದು. ಇದು ಬ್ಲಾಕ್ ಗಾತ್ರದ ಗುಣಕವೇ ಆಗಿರಬೇಕೆಂದಿಲ್ಲ.
• ಹಿಟ್ ಇಲ್ಲದಿದ್ದರೆ — ಆರಂಭ ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಇಲ್ಲದ ವಿನಂತಿಗೆ ಸಾಮಾನ್ಯ ಇನ್‌ಪುಟ್ ದರದಲ್ಲಿ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ. ಕ್ಯಾಶ್ ಆದ ಪ್ರಾಂಪ್ಟ್‌ಗಳಿಗೆ ಯಾವುದೇ ಜೀವಿತಾವಧಿ ಪ್ರಕಟಿಸಿಲ್ಲ ಮತ್ತು ಹಿಟ್‌ಗೆ ಖಾತರಿ ಇಲ್ಲ: ವಿನಂತಿಯು ಕ್ಯಾಶ್‌ನಿಂದ ಏನು ಪಡೆಯಿತು ಎಂದು ನೋಡಲು usage ಓದಿ.
• ಸ್ವಿಚ್ ಇಲ್ಲ — ವಿನಂತಿ ಆಯ್ಕೆ ಮಾಡಬೇಕಿಲ್ಲ, ಮತ್ತು ಯಾವ ಫೀಲ್ಡ್ ಕೂಡ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಆಫ್ ಮಾಡುವುದಿಲ್ಲ.
• ಯಾವ ಮಾಡೆಲ್‌ಗಳು — ಪ್ರತಿಯೊಂದು ಹೋಸ್ಟೆಡ್ ಓಪನ್-ವೇಟ್ id. GET /v1/models ಅವುಗಳ capabilities.prompt_caching: true ಮತ್ತು pricing.cached_input_per_million_usd ಅನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. Shannon ಮಾಡೆಲ್‌ಗಳು ಒಂದೇ ಫ್ಲಾಟ್ ದರವನ್ನು ಬಿಲ್ ಮಾಡುತ್ತವೆ.

ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಕ್ಯಾಶ್ ಹಿಟ್ ನೋಡಿ

ಒಂದೇ ಉದ್ದದ ಸಿಸ್ಟಂ ಪ್ರಾಂಪ್ಟ್‌ನಿಂದ ಆರಂಭವಾಗುವ ಎರಡು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಿ ಮತ್ತು ಪ್ರತಿಯೊಂದರ ಬಳಕೆಯನ್ನು ಪ್ರಿಂಟ್ ಮಾಡಿ. ಮೊದಲ ಸಂಖ್ಯೆ ವಿನಂತಿಯ ಇನ್‌ಪುಟ್, ಎರಡನೆಯದು ಅದರಲ್ಲಿ ಕ್ಯಾಶ್‌ನಿಂದ ಓದಿದ ಭಾಗ.

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ಯ ಕ್ಯಾಶ್ಡ್ ದರವು ಮಾಡೆಲ್ಸ್ ಮತ್ತು ಪ್ರೈಸಿಂಗ್ ಟೇಬಲ್‌ನಲ್ಲಿದೆ. ಮಾಡೆಲ್‌ಗಳು ಮತ್ತು ಬೆಲೆ

ಕರೆಯ ಇನ್‌ಪುಟ್‌ಗೆ ಶುಲ್ಕ (input − cached) × input ದರ + cached × cached ದರ ಪ್ರಕಾರ. ಕ್ಯಾಶ್ ಎಣಿಕೆ ಇನ್‌ಪುಟ್ ಎಣಿಕೆಗಿಂತ ಎಂದಿಗೂ ದೊಡ್ಡದಾಗುವುದಿಲ್ಲ.

ಬಳಕೆಯ ಲಾಗ್ ಪ್ರತಿ ಕರೆಯ ಕ್ಯಾಶ್ ಇನ್‌ಪುಟ್ ಅನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಅದರ ಬಿಲ್ ಮಾಡಿದ ಟೋಕನ್‌ಗಳು ಮತ್ತು ವೆಚ್ಚದಲ್ಲಿ ಕ್ಯಾಶ್ ದರ ಈಗಾಗಲೇ ಸೇರಿದೆ. ಕೀಗಳು ಮತ್ತು ಬಳಕೆ

ಬಳಕೆಯ ಕ್ಷೇತ್ರಗಳು

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

ಸ್ಟ್ರೀಮ್ ಮಾಡಿದ ಪ್ರತಿಕ್ರಿಯೆ ತನ್ನ ಅಂತಿಮ ಬಳಕೆಯಲ್ಲಿ ಅದೇ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನೀವು ಅದನ್ನು ಕೇಳಬೇಕಿಲ್ಲ:

ಹೆಚ್ಚಿನ ಕ್ಯಾಶ್ ಹಿಟ್‌ಗಳನ್ನು ಪಡೆಯುವುದು

• ಕಾಲೋಣ ಕರಸಾಲಗಳಾದಾಗ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ಟೂಲ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಬೈಟ್-ಫಾರ್-ಬೈಟ್ ಸ್ಥಿರವಾಗಿರಿಸಿ. ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಅಥವಾ ರಿಕ್ವೆಸ್ಟ್ idಗಳಂತಹ ಪ್ರತಿ-ಕಾಲದ ಮೌಲ್ಯಗಳನ್ನು ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್‌ನಲ್ಲಿ ಇರಿಸುವ ಬದಲು ಇತ್ತೀಚಿನ ಸಂದೇಶದ ಕೊನೆಯಲ್ಲಿ ಇರಿಸಿ.
• ಇತಿಹಾಸಕ್ಕೆ ಕೇವಲ ಸೇರಿಸು (append). ಹಿಂದಿನ ತಿರುವುಗಳನ್ನು ಎಡಿಟ್ ಮಾಡುವುದು, ಕತ್ತರಿಸುವುದು ಅಥವಾ ಸಾರಾಂಶ ಮಾಡುವುದು ಪ್ರಿಫಿಕ್ಸ್ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ, ಮತ್ತು ಮೊದಲ ಬದಲಾವಣೆಯ ನಂತರದ ಎಲ್ಲವನ್ನೂ ಸಾಮಾನ್ಯ ಇನ್‌ಪುಟ್ ಆಗಿ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ.
• ಕಾಲೋಣಗಳ ನಡುವೆ ಟೂಲ್ಸ್, ಸಂದೇಶಗಳು ಅಥವಾ ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಮರು-ಕ್ರಮಗೊಳಿಸಬೇಡಿ, ಮತ್ತು JSON (ಟೂಲ್ ಸ್ಕೀಮಾಗಳು, ಟೂಲ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ಫಲಿತಾಂಶಗಳು) ಅನ್ನು ಪ್ರತಿ ಬಾರಿ ಒಂದೇ ರೀತಿಯಾಗಿ ಸೀರಿಯಲೈಸ್ ಮಾಡಿ.
• ಒಂದು ಸಂಭಾಷಣೆಗೆ ಒಂದೇ ಮಾಡೆಲ್ id ಬಳಸಿ, ಮತ್ತು ಅನುಸರಣಾ ಕರೆಯನ್ನು ಹಿಂದಿನ ಕರೆಯ ಸ್ವಲ್ಪ ಸಮಯದಲ್ಲೇ ಕಳುಹಿಸಿ.

ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ API ಸಂಭಾಷಣೆಯ ಆರಂಭವನ್ನು ಸ್ಥಿರವಾಗಿಡುತ್ತದೆ:

• ಸಂಭಾಷಣೆಯಲ್ಲಿ ನಂತರ ಕಳುಹಿಸಿದ system ಅಥವಾ developer ಸಂದೇಶ ತನ್ನ ಸ್ಥಾನದಲ್ಲೇ ಉಳಿಯುತ್ತದೆ. ಅದು ಪ್ರಾಂಪ್ಟ್‌ನ ಆರಂಭವನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದರ ಮೊದಲಿನ ತಿರುವುಗಳು ಕ್ಯಾಶ್ ಆಗಿಯೇ ಇರುತ್ತವೆ.
• ಹಿಂದಿನ assistant ತಿರುವುಗಳಲ್ಲಿನ ಟೂಲ್ ಕರೆಗಳ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಮೌಲ್ಯದ ಮೂಲಕ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಆ JSON ನ ಕೀ ಕ್ರಮ ಮತ್ತು ಅಂತರ ಮುಖ್ಯವಲ್ಲ.
• ಮೂರು ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳು ಸಂಭಾಷಣೆಯನ್ನು ಒಂದೇ ರೀತಿ ಓದುತ್ತವೆ. ಬೇರೆ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಮುಂದುವರಿಸಿದ ಸಂಭಾಷಣೆ ಕಂಟೆಂಟ್ ಒಂದೇ ಆಗಿದ್ದರೆ ತನ್ನ ಹಂಚಿಕೆಯ ಪ್ರಿಫಿಕ್ಸ್ ಅನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ವಿನಂತಿ ಕ್ಷೇತ್ರಗಳು

prompt_cache_key (Chat Completions ಮತ್ತು Responses) ಮತ್ತು Messages content blocks ಮೇಲೆ cache_control ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲೈಂಟ್ ಕೋಡ್ ಬದಲಾಗದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇವುಗಳಲ್ಲಿ ಯಾವುದೂ ಅಗತ್ಯವಿಲ್ಲ: caching ಸ್ವಯಂಚಾಲಿತವಾಗಿದೆ ಮತ್ತು ಇವುಗಳಿಲ್ಲದೆಯೂ একইভাবে ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಟೋಕನ್‌ಗಳ ಎಣಿಕೆ

ಎರಡು ಉಚಿತ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳು, POST /v1/tokenize ಮತ್ತು POST /v1/messages/count_tokens, ನೀವು ಕಳುಹಿಸುವ ಮೊದಲು ಹೋಸ್ಟ್ ಮಾಡಲಾದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳಿಗೆ ಪಠ್ಯ ಅಥವಾ ಸಂಪೂರ್ಣ ವಿನಂತಿಯ ಟೋಕನ್‌ಗಳನ್ನು ಎಣಿಸುತ್ತವೆ. ಅವುಗಳಿಗೆ ಸ್ವಂತ ಪುಟವಿದೆ: ಟೋಕನ್ ಎಣಿಕೆ