Masalah Unit Economics pada Model Frontier

Mengirimkan semua query pengguna langsung ke model frontier (seperti GPT-4o atau Claude 3.5 Sonnet) menimbulkan inefisiensi unit economics yang masif. Pada lingkungan produksi, distribusi kompleksitas prompt umumnya mengikuti prinsip Pareto: 70–80% permintaan hanya berupa ekstraksi entitas, klasifikasi teks sederhana, parsing JSON, atau pertanyaan berulang (FAQ). Sisanya (20–30%) benar-benar membutuhkan penalaran multi-langkah atau pemahaman konteks mendalam.

Model frontier mengenakan biaya rata-rata $2.50 hingga $5.00 per 1 juta input token dan $10.00 hingga $15.00 per 1 juta output token. Sebaliknya, model kelas bawah (small model/SLM) seperti GPT-4o-mini atau Llama 3.1 8B berharga sekitar $0.15 hingga $0.60 per 1 juta token. Menjalankan query deterministik atau berulang pada model frontier mengakibatkan pembengkakan biaya cloud API tanpa peningkatan output bisnis yang signifikan.

Arsitektur Model Cascading Tiga Lapis

Model cascading adalah pola arsitektur di mana permintaan inferensi dievaluasi secara berjenjang dari komponen komputasi termurah dan tercepat ke komponen yang paling mahal.

1. Layer 1: Semantic Caching (Redis Vector Similarity)

Query dicek terhadap cache berbasis embedding vektor sebelum menyentuh LLM manapun. Jika cosine similarity antara prompt baru dan riwayat query melampaui batas ambang (threshold, misal ≥ 0.95), gateway langsung mengembalikan respons dari Redis. Latensi terpangkas dari 1200ms menjadi <20ms dengan biaya token nol.

2. Layer 2: Heuristic & Deterministic Routing (SLM Tier)

Jika query melewati cache, router mengevaluasi kompleksitas input berdasarkan kriteria terukur:

  • Panjang token dan rasio instruksi terhadap data.
  • Kebutuhan output terstruktur (regex/schema match).
  • Klasifikasi intent menggunakan model lokal kecil (misal: DeBERTa/BERT atau regex sederhana).

Query dengan kompleksitas rendah diarahkan ke model efisien (SLM atau small API model).

3. Layer 3: Escalation & Frontier Fallback

Model frontier hanya dipanggil jika:

  • Router mengklasifikasikan prompt sebagai penalaran kompleks atau penulisan kode tingkat tinggi.
  • Respons dari Layer 2 gagal melewati evaluasi sintaksis/skema (JSON schema invalid, guardrail rejection, atau logit confidence score di bawah threshold).

Implementasi Router Deterministik Minimal

Berikut implementasi referensi router inferensi bertingkat menggunakan Python. Router ini mengecek cache, menerapkan evaluasi heuristik, lalu mengeskalasi permintaan jika diperlukan.

import os
import re
import json
from typing import Dict, Any, Optional

# ponytail: mock client interfaces; upgrade to official SDKs (openai, redis-py) in production.
class MockRedisVectorCache:
    def __init__(self):
        self.store = {
            "apa itu api": "API (Application Programming Interface) adalah antarmuka komputasi."
        }

    def get_exact_or_semantic(self, query: str, threshold: float = 0.95) -> Optional[str]:
        # Simulasi pencarian vektor: normalisasi teks sederhana
        normalized = query.strip().lower()
        return self.store.get(normalized, None)

class LLMGatewayRouter:
    def __init__(self, cache: MockRedisVectorCache):
        self.cache = cache
        self.frontier_keywords = re.compile(
            r"\b(analisis|debug|refactor|arsitektur|evaluasi|bukti|derive)\b", 
            re.IGNORECASE
        )

    def route_request(self, prompt: str) -> Dict[str, Any]:
        # Rung 1: Semantic Cache Layer
        cached_result = self.cache.get_exact_or_semantic(prompt)
        if cached_result:
            return {"tier": "cache", "cost_usd": 0.0, "response": cached_result}

        # Rung 2: Deterministic Routing Heuristic
        token_estimate = len(prompt.split()) * 1.3
        requires_deep_reasoning = bool(self.frontier_keywords.search(prompt)) or token_estimate > 1500

        if not requires_deep_reasoning:
            try:
                response = self._call_small_tier(prompt)
                if self._validate_response(response):
                    return {"tier": "slm", "cost_usd": 0.0002, "response": response}
            except Exception:
                # Log error and fallthrough to Layer 3
                pass

        # Rung 3: Frontier Fallback
        response = self._call_frontier_tier(prompt)
        return {"tier": "frontier", "cost_usd": 0.006, "response": response}

    def _validate_response(self, response: str) -> bool:
        # Validasi output minimal; kegagalan memicu fallback ke frontier
        return len(response.strip()) > 0 and "ERROR:" not in response

    def _call_small_tier(self, prompt: str) -> str:
        # Simulasi pemanggilan SLM (e.g., Llama-3.1-8b atau GPT-4o-mini)
        return f"[SLM Response] Diproses untuk: {prompt}"

    def _call_frontier_tier(self, prompt: str) -> str:
        # Simulasi pemanggilan model frontier (e.g., Claude 3.5 Sonnet / GPT-4o)
        return f"[Frontier Response] Penalaran mendalam untuk: {prompt}"

# Runnable verification check
if __name__ == "__main__":
    router = LLMGatewayRouter(cache=MockRedisVectorCache())
    
    # Test case 1: Cache hit
    res1 = router.route_request("apa itu api")
    assert res1["tier"] == "cache", f"Expected cache, got {res1['tier']}"

    # Test case 2: Simple query to SLM
    res2 = router.route_request("Terjemahkan kata 'apple' ke bahasa Indonesia")
    assert res2["tier"] == "slm", f"Expected slm, got {res2['tier']}"

    # Test case 3: Complex query escalated to Frontier
    res3 = router.route_request("Analisis bug race-condition pada implementasi mutex ini")
    assert res3["tier"] == "frontier", f"Expected frontier, got {res3['tier']}"

    print("Semua pengujian routing deterministik lolos.")
Dilewati: Implementasi Redis VSS embedding pipeline dan retry handler. Tambahkan dependensi redisvl dan model sentence-transformers jika query bervariasi secara sintaksis.

Estimasi Efisiensi Biaya dan Latensi

Simulasi beban kerja 1.000.000 request per bulan dengan karakteristik beban:

  • 30% query FAQ/repetitif (Semantic Cache).
  • 50% query instruksi sederhana/ekstraksi data (SLM Tier).
  • 20% query penalaran kompleks/kode (Frontier Tier).

Perhitungan Biaya

  • Arsitektur Monolitik (100% Frontier):
    1.000.000 * $0.006 = $6.000 USD
  • Arsitektur Cascading Gateway:
    • Cache (300.000 req): $0
    • SLM (500.000 req): 500.000 * $0.0002 = $100 USD
    • Frontier (200.000 req): 200.000 * $0.006 = $1.200 USD
    • Total: $1.300 USD (Penghematan ~78.3%)

Dampak terhadap Latensi

P50 latensi sistem turun drastis karena 30% request dilayani dalam tempo sub-50ms oleh Redis, dan 50% permintaan dilayani oleh model kecil dengan rata-rata time-to-first-token (TTFT) 2-3x lebih cepat dibanding model frontier.

Trade-off Arsitektur & Observabilitas

Penerapan model cascading menghadirkan kompleksitas baru yang perlu dikelola:

  • Penalti Latensi Dua Kali (Double-Call Overhead): Jika Layer 2 gagal atau menghasilkan output berkualitas rendah yang memicu fallback ke Layer 3, latensi total request adalah penjumlahan latensi Layer 2 + Layer 3. Strategi evaluasi harus bersifat fast-fail.
  • Drift pada Akurasi Respons: Pemilihan threshold semantic caching yang terlalu longgar (<0.90) dapat mengembalikan jawaban usang yang tidak relevan dengan konteks pengguna terkini.
  • Maintenance Router vs Direct API: Mengelola gateway sendiri menuntut dependensi tambahan (Redis, routing logic, model hosting) dibanding langsung memanggil satu endpoint API.

Metrik Observabilitas Kritis

Pastikan sistem telemetri (OpenTelemetry/Prometheus) memonitor tiga metrik utama:

  1. gateway_cache_hit_ratio: Rasio query yang diselesaikan di Layer 1.
  2. gateway_tier_escalation_rate: Persentase query yang dialihkan dari Layer 2 ke Layer 3 akibat kegagalan validasi. Angka di atas 15% menandakan aturan router terlalu permisif atau SLM tidak memadai.
  3. cost_per_successful_request: Biaya rata-rata token per HTTP 200 untuk mengukur tren pengeluaran seiring evolusi prompt aplikasi.