AI Engineering Academy · Pelajaran

Penyimpanan Singgahan Awalan Perintah OpenAI

Pelajaran 3 dari 413 langkah

Penyimpanan Singgahan Awalan Perintah OpenAI adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa Itu Caching Awalan Prompt?

Caching awalan prompt adalah pengoptimalan sisi server yang terintegrasi dalam API OpenAI dan secara otomatis memberikan potongan harga untuk token pada awalan prompt yang telah terlihat dalam permintaan sebelumnya baru-baru ini. Berbeda dari caching tingkat aplikasi yang mengembalikan respons tersimpan, caching awalan prompt tetap memanggil model—tetapi dengan harga token input 50 persen lebih rendah untuk bagian awalan yang tersimpan. Fitur ini mengurangi biaya tanpa mengorbankan pembuatan respons baru.

Cara Kerja Caching Awalan di Balik Layar

LLM modern merepresentasikan prompt sebagai cache KV (key-value) di memori GPU. Memproses prompt berarti menghitung kunci dan nilai perhatian untuk setiap token. Jika N token pertama dari dua permintaan berturut-turut identik, OpenAI dapat menggunakan kembali cache KV dari permintaan pertama dan melewati komputasi mahal untuk token-token tersebut. API melakukan ini secara otomatis dan transparan—Anda hanya membayar tarif token tersimpan yang lebih rendah jika ketentuan ini berlaku.

# No code changes needed to enable prefix caching!
# It is automatic on supported models.

# The API response shows you how many tokens were cached:
# response.usage.prompt_tokens_details.cached_tokens

# Example response usage:
# ChatCompletionUsage(
#   prompt_tokens=2048,
#   completion_tokens=256,
#   total_tokens=2304,
#   prompt_tokens_details=PromptTokensDetails(
#     cached_tokens=1984,   # these tokens were served from KV cache
#     audio_tokens=0,
#   )
# )

Memeriksa Cache Hit dalam Respons

Setelah setiap panggilan API, periksa response.usage.prompt_tokens_details.cached_tokens untuk melihat jumlah token input yang dilayani dari cache KV. Jika cached_tokens > 0, Anda membayar tarif diskon 50 persen untuk token-token tersebut. Mencatat nilai ini memungkinkan Anda memantau efisiensi cache aktual dan menghitung penghematan biaya dari caching awalan seiring waktu.

from openai import OpenAI

client = OpenAI()

SYSTEM_PROMPT = 'You are an expert AI engineer assistant. ' * 100  # long system prompt

def call_with_cache_check(user_message: str):
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': SYSTEM_PROMPT},
            {'role': 'user', 'content': user_message},
        ],
    )
    usage = response.usage
    cached = usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0
    print(f'Total prompt tokens: {usage.prompt_tokens}')
    print(f'Cached tokens: {cached} ({100*cached//usage.prompt_tokens}%)')
    return response.choices[0].message.content

Awalan Harus Benar-Benar Identik

Caching awalan hanya berlaku jika N token pertama identik byte demi byte dengan permintaan sebelumnya yang masih baru. Bahkan perubahan satu karakter pada prompt sistem akan membatalkan cache. OpenAI menyimpan cache dalam potongan 128 token—cache hanya berlaku untuk potongan lengkap yang sama persis. Artinya, bagian prompt yang berubah pada setiap permintaan harus ditempatkan setelah awalan yang panjang dan stabil agar jumlah token tersimpan maksimal.

# Optimal structure for prefix caching:
# [LONG STABLE SYSTEM PROMPT] [CACHED DOCUMENTS] [USER QUERY]
#         ↑                              ↑                ↑
#    always same               always same         varies per request
#    → cached at 50%           → cached at 50%     → not cached, full price

# BAD structure (defeats prefix caching):
# [USER QUERY] [CACHED DOCUMENTS] [LONG STABLE SYSTEM PROMPT]
#       ↑                                       ↑
#  changes every request                 never cached because
#  so prefix never matches               it comes after the query

Menyusun Prompt untuk Efisiensi Cache Maksimal

Untuk memaksimalkan rasio cache hit, susun prompt sehingga bagian yang stabil berada di awal. Dalam sistem RAG: (1) prompt sistem yang berisi instruksi dan persona, (2) dokumen yang diambil dan hanya berubah ketika kueri berubah secara signifikan, (3) riwayat percakapan, (4) kueri pengguna di bagian paling akhir. Prompt sistem saja—yang sering kali berukuran 500-2000 token—biasanya akan tersimpan di cache, sehingga menghemat 25-50 persen biaya token input.

def build_rag_prompt_for_caching(
    system_prompt: str,
    retrieved_docs: list[str],
    conversation_history: list[dict],
    user_query: str,
) -> list[dict]:
    # Order: stable → semi-stable → variable
    context_block = '\n\n'.join(
        f'[Document {i+1}]\n{doc}' for i, doc in enumerate(retrieved_docs)
    )
    return [
        # 1. Stable system prompt (always cached after first request)
        {'role': 'system', 'content': system_prompt},
        # 2. Context injection as a user message (cached when same docs retrieved)
        {'role': 'user', 'content': f'Context documents:\n{context_block}'},
        {'role': 'assistant', 'content': 'I have read the documents.'},
        # 3. Conversation history (semi-stable)
        *conversation_history,
        # 4. Current user query (always different → never cached prefix)
        {'role': 'user', 'content': user_query},
    ]

Durasi dan Penghapusan Cache

Cache KV OpenAI dipertahankan di memori GPU dan memiliki kebijakan penghapusan. Awalan yang tidak digunakan kembali dalam waktu sekitar 5-10 menit akan dihapus ketika permintaan lain menggunakan memori GPU. Artinya, manfaat caching awalan paling besar dirasakan oleh aplikasi dengan throughput tinggi yang menerima permintaan sering dengan awalan yang sama. Aplikasi dengan lalu lintas rendah mungkin hanya memperoleh sedikit cache hit karena awalan dihapus di antara permintaan yang berjeda.

Model dan Harga yang Didukung

Per 2025, caching awalan prompt tersedia pada model GPT-4o, GPT-4o-mini, o1, dan o3-mini. Harga token tersimpan adalah 50 persen dari harga token input standar untuk sebagian besar model. Panjang minimum awalan yang dapat disimpan di cache adalah 1024 token—awalan yang lebih pendek tidak menerima diskon. Selalu periksa halaman harga OpenAI untuk tarif terkini karena harga dapat berubah seiring pematangan fitur ini.

# Rough pricing reference (verify at platform.openai.com/pricing)
PRICING = {
    'gpt-4o': {
        'input_per_1M': 2.50,
        'cached_input_per_1M': 1.25,   # 50% off
        'output_per_1M': 10.00,
    },
    'gpt-4o-mini': {
        'input_per_1M': 0.15,
        'cached_input_per_1M': 0.075,  # 50% off
        'output_per_1M': 0.60,
    },
}

def estimate_cost_with_caching(prompt_tokens, cached_tokens, output_tokens, model):
    p = PRICING[model]
    uncached = (prompt_tokens - cached_tokens) * p['input_per_1M'] / 1_000_000
    cached_cost = cached_tokens * p['cached_input_per_1M'] / 1_000_000
    output_cost = output_tokens * p['output_per_1M'] / 1_000_000
    return uncached + cached_cost + output_cost

Caching Prompt Anthropic

Anthropic menyediakan fitur serupa yang disebut caching prompt untuk model Claude, tetapi memerlukan keikutsertaan eksplisit dengan menandai titik pemisah cache dalam prompt menggunakan kolom cache_control. Berbeda dari caching otomatis OpenAI, Anda harus secara eksplisit menandai bagian prompt yang perlu disimpan di cache (hingga 4 titik pemisah cache per permintaan). Token tersimpan dikenai biaya 10 persen dari harga input standar dan disimpan selama 5 menit.

import anthropic

client = anthropic.Anthropic()

LONG_DOCUMENT = 'This is a very long reference document...' * 500  # 2000+ tokens

response = client.messages.create(
    model='claude-sonnet-4-5',
    max_tokens=1024,
    system=[
        {
            'type': 'text',
            'text': 'You are a helpful assistant.',
        },
        {
            'type': 'text',
            'text': LONG_DOCUMENT,
            'cache_control': {'type': 'ephemeral'},  # mark for caching
        }
    ],
    messages=[{'role': 'user', 'content': 'Summarize the document.'}],
)
print(response.usage.cache_read_input_tokens)   # tokens served from cache
print(response.usage.cache_creation_input_tokens)  # tokens written to cache

Menggabungkan Caching Awalan dengan Caching Aplikasi

Caching awalan dan caching tingkat aplikasi bersifat saling melengkapi. Caching awalan mengurangi biaya setiap panggilan API, tetapi tetap memanggil LLM. Cache eksak dan semantik tingkat aplikasi sepenuhnya menghilangkan panggilan API untuk kueri yang berulang. Gunakan caching awalan untuk semua permintaan guna mengurangi biaya input per panggilan, lalu tambahkan caching tingkat aplikasi di atasnya untuk sepenuhnya menghilangkan panggilan pada kueri yang sering diulang. Jika digabungkan, keduanya dapat mengurangi biaya infrastruktur AI sebesar 60-80 persen.

# Three-layer cost optimization stack
#
# Layer 1: Exact cache (Redis, hash-based)
#   → Eliminates 100% of API cost for identical requests
#   → Miss rate: ~60-80% (most queries are unique)
#
# Layer 2: Semantic cache (vector similarity)
#   → Eliminates 100% of API cost for semantically similar requests
#   → Miss rate: ~40-60% of remaining queries
#
# Layer 3: OpenAI prefix caching (automatic)
#   → Reduces input token cost by 50% for long stable prefixes
#   → Applies to ALL remaining API calls that escape layers 1 and 2
#
# Combined effect: 60-80% cost reduction in FAQ/support applications

Mengukur Efisiensi Cache Anda

Pantau rasio efisiensi cache sebagai metrik gabungan: total token dengan harga penuh dibagi total token yang benar-benar ditagihkan. Metrik ini mencakup semua lapisan caching. Catat cached_tokens dari setiap respons API dan jumlahkan setiap minggu. Sistem yang mencapai 50 persen token tersimpan di seluruh panggilan API secara efektif mengurangi separuh biaya token input tanpa memerlukan perubahan kode aplikasi untuk caching awalan.

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass
class CachingMetrics:
    total_prompt_tokens: int = 0
    total_cached_tokens: int = 0
    app_cache_hits: int = 0
    app_cache_misses: int = 0

    @property
    def prefix_cache_ratio(self) -> float:
        if self.total_prompt_tokens == 0:
            return 0
        return self.total_cached_tokens / self.total_prompt_tokens

    @property
    def app_cache_hit_rate(self) -> float:
        total = self.app_cache_hits + self.app_cache_misses
        return self.app_cache_hits / total if total > 0 else 0

    def report(self):
        print(f'App cache hit rate: {self.app_cache_hit_rate:.1%}')
        print(f'Prefix cache ratio: {self.prefix_cache_ratio:.1%}')
        savings_multiplier = (1 - self.app_cache_hit_rate) * (1 - 0.5 * self.prefix_cache_ratio)
        print(f'Effective cost vs no-cache: {savings_multiplier:.1%}')

Saat Caching Awalan Tidak Membantu

Caching awalan tidak memberikan manfaat untuk: (1) prompt pendek di bawah 1024 token (panjang minimum yang dapat disimpan di cache), (2) awalan yang sangat berubah-ubah ketika prompt sistem berubah untuk setiap pengguna atau permintaan, (3) aplikasi dengan lalu lintas rendah ketika cache KV dihapus di antara permintaan, atau (4) ketika Anda sudah membayar tarif token minimum. Dalam kasus ini, fokuskan upaya pengoptimalan pada caching semantik tingkat aplikasi.

Pemeriksaan Singkat

Uji pemahaman Anda tentang caching awalan prompt OpenAI dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa: caching awalan prompt OpenAI secara otomatis memberikan potongan harga 50 persen untuk token input tersimpan ketika awalan prompt cocok dengan permintaan sebelumnya yang masih baru; konten stabil harus ditempatkan di awal struktur pesan Anda (prompt sistem, dokumen, lalu kueri pengguna) untuk memaksimalkan token tersimpan; dan Anthropic memerlukan penanda cache_control eksplisit untuk fitur serupa pada Claude. Gabungkan fitur ini dengan caching tingkat aplikasi untuk pengurangan biaya maksimal. Selanjutnya, kita akan membahas pengelompokan permintaan, perutean model, dan dasbor biaya untuk melengkapi perangkat pengoptimalan kita.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penyimpanan Singgahan Awalan Perintah OpenAI” gratis?

Ya — teks lengkap “Penyimpanan Singgahan Awalan Perintah OpenAI” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penyimpanan Singgahan Awalan Perintah OpenAI”?

Manfaatkan penyimpanan singgahan perintah otomatis OpenAI yang memberikan potongan harga 50 persen untuk awalan perintah sistem panjang yang berulang, lalu susun perintah Anda untuk memaksimalkan tin… Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Penyimpanan Singgahan Awalan Perintah OpenAI” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Penyimpanan Singgahan Persis dengan Redis
Penyimpanan Singgahan Semantik dengan Embedding
Penyimpanan Singgahan Awalan Perintah OpenAI
Pengelompokan, Perutean Model, dan Dasbor Biaya

← Kembali ke AI Engineering Academy