Panduan Google Cloud: Bagaimana Menerapkan Vertex AI Context Caching: Cutting Enterprise LLM di Production?
Ringkasan: Vertex AI Context Caching memungkinkan enterprise menyimpan system prompt masif, korpus RAG (Retrieval-Augmented Generation), dan riwayat percakapan panjang di dalam memori berkecepatan tinggi untuk digunakan ulang secara persisten. Dengan menghindari komputasi ulang token yang sama pada setiap request, arsitektur ini memangkas biaya inferensi LLM secara drastis dan secara signifikan mengurangi Time to First Token (TTFT) pada beban kerja high-throughput.
Apa yang Baru Dirilis Google Cloud & Masalah Enterprise yang Diselesaikan
Dalam arsitektur Large Language Model (LLM) berbasis Transformer, salah satu hambatan komputasi terbesar adalah mekanisme self-attention. Secara fundamental, setiap kali sebuah request dikirimkan ke model, LLM bersifat stateless. Model tidak memiliki memori bawaan tentang request sebelumnya. Jika sebuah aplikasi mengirimkan dokumen hukum setebal 1.000 halaman (sekitar 1 juta token) sebagai konteks, model harus menghitung ulang representasi matematis dari seluruh dokumen tersebut—yang dikenal sebagai Key-Value (KV) Cache—sebelum dapat menghasilkan satu token output pun.
Proses komputasi ulang ini membutuhkan operasi Floating Point (FLOPs) yang sangat masif. Pada skala enterprise, hal ini menciptakan dua masalah kritis:
- Latensi yang Tidak Dapat Diterima: Time to First Token (TTFT) untuk memproses 1 juta token dapat memakan waktu belasan hingga puluhan detik, menghancurkan User Experience (UX) pada aplikasi real-time.
- Unit Economics yang Merugikan: Membayar harga penuh untuk memproses 1 juta token input yang sama berulang kali pada setiap request akan menghancurkan margin profitabilitas produk AI.
Untuk menyelesaikan masalah fundamental ini, Google Cloud merilis fitur Context caching overview di Vertex AI. Alih-alih membuang KV Cache setelah request selesai, Vertex AI memungkinkan engineer untuk menserialisasi dan menyimpan KV Cache tersebut di infrastruktur memori Google secara persisten dengan Time-to-Live (TTL) yang dapat dikonfigurasi. Ketika request berikutnya datang dan merujuk pada cache yang sama, model langsung melompati fase pemrosesan konteks (fase pre-fill) dan langsung masuk ke fase decode (generasi teks). Hasilnya adalah penurunan latensi yang eksponensial dan diskon harga token input yang sangat agresif.
Use Case Nyata di Lapangan: Ide Implementasi Praktis
Untuk memahami bagaimana kapabilitas ini mengubah desain sistem di lapangan, berikut adalah tiga pola implementasi real-world yang secara aktif diadopsi oleh enterprise:
1. Analisis Dokumen Finansial & Kepatuhan Hukum (High-Throughput)
- Masalah Sehari-hari: Analis di bank investasi atau firma hukum sering kali harus mengajukan puluhan pertanyaan terhadap satu dokumen prospektus atau kontrak yang sama (misalnya, dokumen S-1 setebal 500 halaman). Tanpa caching, setiap pertanyaan (seperti "Apa risiko likuiditas di Q3?" lalu "Siapa auditor utamanya?") memaksa sistem untuk mengirim ulang seluruh dokumen 500 halaman tersebut ke LLM.
- Cara Kerja di Praktik: Sistem mengunggah dokumen ke Vertex AI Context Cache saat analis pertama kali membuka dokumen di UI. Cache diberi TTL selama 1 jam. Seluruh pertanyaan yang diajukan analis selama sesi tersebut hanya mengirimkan teks pertanyaan pendek (sekitar 50 token) beserta ID dari cache dokumen.
- Dampak Nyata: TTFT turun dari 15 detik menjadi kurang dari 2 detik. Biaya inferensi per pertanyaan turun drastis karena token input dari dokumen ditagih dengan tarif cached input yang jauh lebih murah, bukan tarif input standar.
2. Agen AI Multi-Turn dengan Konteks Panjang (Customer Operations)
- Masalah Sehari-hari: Chatbot layanan pelanggan tingkat lanjut sering kali diinstruksikan dengan system prompt yang sangat panjang (berisi SOP perusahaan, panduan eskalasi, dan persona) ditambah dengan riwayat percakapan pengguna yang terus bertambah. Seiring berjalannya percakapan, payload yang dikirim ke API LLM membengkak, memicu batas kuota dan lonjakan biaya.
- Cara Kerja di Praktik: System prompt statis dan riwayat percakapan dasar di-cache. Saat pengguna membalas, aplikasi hanya mengirimkan cache ID dan pesan terbaru pengguna. Jika percakapan berlanjut sangat panjang, cache dapat diperbarui secara berkala (misalnya, setiap 10 giliran percakapan) untuk memasukkan riwayat terbaru.
- Dampak Nyata: Menjaga latensi respons tetap konsisten di bawah 1 detik terlepas dari seberapa panjang percakapan telah berlangsung, serta mencegah cost overrun pada sesi pelanggan yang panjang.
3. Analisis Codebase & CI/CD Pipeline (Developer Productivity)
- Masalah Sehari-hari: Tim engineering ingin menggunakan LLM untuk melakukan code review otomatis pada setiap Pull Request (PR). Namun, agar LLM memahami konteks PR, ia harus membaca seluruh repositori kode (yang bisa mencapai ratusan ribu token). Mengirimkan seluruh repositori pada setiap PR sangat lambat dan mahal.
- Cara Kerja di Praktik: Pada awal hari kerja atau saat ada commit ke branch utama, pipeline CI/CD secara otomatis membangun Context Cache dari seluruh repositori kode. Setiap PR yang dibuat pada hari itu dievaluasi oleh LLM dengan merujuk pada cache repositori tersebut, ditambah dengan diff spesifik dari PR.
- Dampak Nyata: Code review otomatis dapat berjalan dalam hitungan detik per PR, memungkinkan integrasi yang mulus ke dalam pipeline CI/CD tanpa memperlambat developer velocity.
Arsitektur Referensi di Google Cloud
Merancang sistem yang memanfaatkan Context Caching membutuhkan pergeseran paradigma dari arsitektur LLM yang sepenuhnya stateless menjadi arsitektur yang sadar akan state (sesi). Kita harus memisahkan lapisan komputasi aplikasi dari lapisan penyimpanan konteks LLM.
Berikut adalah topologi arsitektur referensi tingkat produksi di Google Cloud:
flowchart LR
Client([Client Application]) -->|HTTPS / gRPC| LB[Cloud Load Balancing]
LB --> IAP[Identity-Aware Proxy]
subgraph "VPC Service Controls Perimeter"
IAP --> CR[Cloud Run API Gateway]
subgraph "State Management"
CR <-->|Read/Write Session State| Redis[(Memorystore for Redis)]
CR <-->|Fetch RAG Documents| BQ[(BigQuery / Cloud Storage)]
end
subgraph "Vertex AI (Managed AI Platform)"
CR -->|"1. Create Cache (TTL)"| VXC[Vertex AI Context Cache]
CR -->|"2. Generate Content (Cache ID + Prompt)"| VXM[Gemini 2.5 Pro Model]
VXC -.->|KV Cache Injection| VXM
end
end
CR -->|Audit Logs| CL[Cloud Logging]
classDef gcp fill:#e8f0fe,stroke:#4285f4,stroke-width:2px,color:#1a73e8;
class CR,VXC,VXM,Redis,BQ,LB,IAP,CL gcp;
Dekonstruksi Komponen Arsitektur
- Cloud Run API Gateway: Bertindak sebagai lapisan orkestrasi stateless. Cloud Run menerima request dari pengguna, memverifikasi autentikasi, dan menentukan apakah cache LLM sudah ada untuk sesi atau dokumen tersebut. Jika belum, Cloud Run akan mengambil data dari storage dan memerintahkan Vertex AI untuk membuat cache.
- Memorystore for Redis: Menyimpan pemetaan antara ID Sesi Pengguna atau ID Dokumen dengan
Cache ID yang dikembalikan oleh Vertex AI. Karena Cloud Run bersifat stateless dan dapat melakukan scale-out ke ratusan instans, Redis memastikan semua instans Cloud Run mengetahui cache mana yang harus digunakan.
- Vertex AI Context Cache: Layanan terkelola yang menyimpan KV Cache dari model Gemini. Cache ini terikat pada region spesifik dan memiliki siklus hidup (TTL) yang dikelola secara otomatis oleh infrastruktur Google.
- VPC Service Controls (VPC-SC): Memastikan bahwa data sensitif yang di-cache di Vertex AI tidak dapat diakses dari luar perimeter jaringan perusahaan, mencegah eksfiltrasi data bahkan jika kredensial Service Account bocor.
Arsitektur ini secara langsung mendukung prinsip-prinsip yang diuraikan dalam Well-Architected Framework: Cost optimization pillar, di mana optimalisasi penggunaan sumber daya (dalam hal ini, komputasi token LLM) diselaraskan dengan nilai bisnis melalui penggunaan caching yang cerdas.
Implementasi Langkah demi Langkah
Untuk mengimplementasikan arsitektur di atas, kita menggunakan Vertex AI SDK untuk Python. Kode berikut mendemonstrasikan pola Check-or-Create yang harus diimplementasikan di dalam microservice Cloud Run Anda.
Penting untuk dicatat bahwa pada tahun 2026, model produksi aktif yang direkomendasikan untuk beban kerja penalaran kompleks adalah gemini-2.5-pro.
import os
import datetime
from google.cloud import aiplatform
from vertexai.preview.generative_models import GenerativeModel, Part
from vertexai.preview import caching
# 1. Inisialisasi Project dan Region
PROJECT_ID = os.environ.get("GOOGLE_CLOUD_PROJECT")
LOCATION = "us-central1"
aiplatform.init(project=PROJECT_ID, location=LOCATION)
def get_or_create_document_cache(document_uri: str, cache_display_name: str) -> caching.CachedContent:
"""
Mengecek apakah cache sudah ada (biasanya ID disimpan di Redis).
Jika belum, buat cache baru dengan TTL 60 menit.
"""
# Dalam produksi, Anda akan mengecek Redis di sini untuk mencari Cache ID.
# Untuk contoh ini, kita asumsikan cache belum ada dan kita membuatnya.
print(f"Creating new context cache for {document_uri}...")
# Mendefinisikan konten yang akan di-cache (misalnya PDF besar di Cloud Storage)
document_part = Part.from_uri(
uri=document_uri,
mime_type="application/pdf"
)
# Membuat cache dengan TTL eksplisit
cached_content = caching.CachedContent.create(
model_name="gemini-2.5-pro",
system_instruction="Anda adalah analis finansial senior. Jawab pertanyaan hanya berdasarkan dokumen yang diberikan.",
contents=[document_part],
display_name=cache_display_name,
ttl=datetime.timedelta(minutes=60),
)
print(f"Cache created successfully. Cache ID: {cached_content.name}")
return cached_content
def query_cached_document(cached_content: caching.CachedContent, user_prompt: str) -> str:
"""
Melakukan inferensi menggunakan cache yang sudah ada.
"""
# Inisialisasi GenerativeModel dengan merujuk pada objek cache
model = GenerativeModel.from_cached_content(cached_content=cached_content)
# Generate konten. Perhatikan bahwa kita HANYA mengirimkan prompt pengguna,
# dokumen besar sudah berada di memori model.
response = model.generate_content(user_prompt)
return response.text
# --- Contoh Eksekusi ---
if __name__ == "__main__":
# URI dokumen besar di Cloud Storage
CORPUS_URI = "gs://my-enterprise-bucket/financial_reports/Q3_massive_report.pdf"
# 1. Buat atau ambil cache
my_cache = get_or_create_document_cache(CORPUS_URI, "q3_report_cache")
# 2. Lakukan query dengan latensi rendah dan biaya rendah
answer = query_cached_document(
cached_content=my_cache,
user_prompt="Berdasarkan laporan tersebut, apa 3 faktor utama yang mempengaruhi margin operasional?"
)
print(f"LLM Response:\n{answer}")
Manajemen Siklus Hidup Cache
Dalam lingkungan produksi, Anda tidak boleh membiarkan cache menumpuk tanpa batas. Meskipun TTL akan menghapus cache secara otomatis setelah waktu habis, praktik terbaik adalah secara eksplisit memanggil cached_content.delete() dari aplikasi Anda segera setelah sesi pengguna berakhir atau dokumen tidak lagi relevan. Hal ini mencegah tagihan penyimpanan cache yang tidak perlu.
Kesiapan Production: FinOps, Kuota & Guardrails Keamanan
Mengadopsi Context Caching mengubah model ekonomi dari aplikasi AI Anda. Alih-alih hanya membayar biaya per-token secara linear, Anda sekarang mengelola biaya infrastruktur hibrida: Anda membayar biaya penyimpanan cache per jam (seperti menyewa RAM), ditambah biaya token input yang didiskon secara signifikan.
Untuk memvalidasi dampak ekonomi ini, kita harus melakukan simulasi deterministik menggunakan data dari Agent Platform Pricing dan Cloud Run pricing.
📊 Simulasi FinOps & TCO Produksi: Enterprise RAG: 1M Token Context dengan 10.000 Query per Bulan (Berdasarkan Informasi SKU Google Terbaru)
Asumsi Beban Kerja Produksi (us-central1 / asia-southeast1):
- Korpus RAG / System Prompt sebesar 1.000.000 token
- Volume trafik: 10.000 request per bulan
- Output: 5.000 token per request
- Cache dipertahankan aktif 24/7 (730 jam/bulan)
- Cloud Run API Gateway: 10 detik per request, 1 vCPU, 1 GiB RAM
| Opsi Arsitektur |
Rincian Rumus & Harga Satuan SKU (Resmi) |
Estimasi Biaya Bulanan |
| Standard Inference (Tanpa Caching) |
Standard Input Tokens (1M per req): $1.25/1M input tokens × 10,000 = $12,500.00
Output Tokens (5k per req): $10/1M output tokens × 50 = $500.00
Cloud Run vCPU (10s per req): $2.4e-05/vCPU-second × 100,000 = $2.40
Cloud Run Memory (10s per req): $2.5e-06/GiB-second × 100,000 = $0.25 |
$13,002.65 / mo |
| Context Caching Enabled |
Cache Storage (1M tokens * 730h): $4.5/1M tokens-hour × 730 = $3,285.00
Cached Input Tokens (1M per req): $0.3125/1M cached input tokens × 10,000 = $3,125.00
Output Tokens (5k per req): $10/1M output tokens × 50 = $500.00
Cloud Run vCPU (10s per req): $2.4e-05/vCPU-second × 100,000 = $2.40
Cloud Run Memory (10s per req): $2.5e-06/GiB-second × 100,000 = $0.25 |
$6,912.65 / mo |
| Dampak Net FinOps (Penghematan Bulanan) |
Berdasarkan informasi SKU Google terbaru |
Penghematan 46.8% ($6,090.00 / bulan) |
Sumber Harga Resmi Google Cloud (2026.09): cloud.google.com, cloud.google.com
Analisis Titik Impas (Break-Even Point)
Secara arsitektural, metrik terpenting yang harus Anda pantau adalah Titik Impas Kepadatan Request (Request Density Break-Even).
Menyimpan 1 juta token di cache Gemini 2.5 Pro memakan biaya $4.50 per jam.
Tanpa cache, mengirim 1 juta token memakan biaya $1.25. Dengan cache, biayanya turun menjadi $0.3125.
Ini berarti setiap request yang menggunakan cache menghemat $0.9375 ($1.25 - $0.3125).
Untuk membenarkan biaya penyimpanan $4.50 per jam, Anda harus melakukan setidaknya:
$4.50 / $0.9375 = 4.8 request per jam terhadap konteks yang sama.
Jika dokumen Anda hanya di-query 1 atau 2 kali dalam satu jam, caching akan meningkatkan biaya Anda. Jika dokumen Anda di-query 10, 100, atau 1.000 kali per jam (seperti pada simulasi di atas), caching akan menghasilkan penghematan eksponensial. Oleh karena itu, TTL dinamis sangat krusial. Jangan mengatur TTL ke 24 jam jika pengguna hanya aktif selama 30 menit.
Guardrails Keamanan & Kuota
Saat memindahkan beban kerja ini ke produksi, beberapa guardrails infrastruktur harus ditegakkan:
- Isolasi IAM (Identity and Access Management): Service Account yang digunakan oleh Cloud Run harus memiliki prinsip least privilege. Berikan role
roles/aiplatform.user secara ketat. Perlu diingat bahwa siapa pun yang memiliki akses ke Cache ID dan memiliki izin IAM yang tepat dapat melakukan query terhadap data yang di-cache.
- VPC Service Controls: Karena cache berada di infrastruktur terkelola Google, pastikan Vertex AI API dimasukkan ke dalam perimeter VPC-SC Anda. Ini memastikan bahwa meskipun seorang developer mengetahui Cache ID, mereka tidak dapat memanggil API tersebut dari laptop lokal mereka di luar jaringan perusahaan.
- Manajemen Kuota: Vertex AI memberlakukan kuota pada jumlah total token yang dapat di-cache secara bersamaan di sebuah project dan region. Pantau metrik
aiplatform.googleapis.com/cached_content/total_tokens di Cloud Monitoring. Jika Anda merancang sistem multi-tenant di mana setiap pelanggan memiliki cache mereka sendiri, Anda harus merancang strategi eviction (penghapusan) yang agresif atau meminta peningkatan kuota melalui Google Cloud Support sebelum peluncuran produksi.