Rule Engine vs LLM di Pipeline Keputusan: Trade-off Skala & Biaya

Menggunakan Large Language Model (LLM) untuk logika bisnis deterministik adalah anti-pattern yang meningkatkan latensi dan biaya cloud. Arsitektur backend modern memerlukan evaluasi ketat antara komputasi berbasis aturan (deterministic rule engine) dan model probabilitas (LLM) pada pipeline pengambilan keputusan (decision pipeline).

Trade-off Teknis: Karakteristik Sistem

Evaluasi keputusan backend umumnya berfokus pada empat variabel kritis: latensi, biaya operasional per skala, determinisme, dan radius dampak kegagalan (failure blast radius).

1. Latensi dan Throughput

Rule engine lokal (seperti JSON Logic, Google CEL, atau Goja) mengevaluasi AST (Abstract Syntax Tree) di memory. Eksekusi berjalan sub-milidetik (0.01 ms hingga 2 ms) pada single CPU core tanpa network I/O. Throughput dapat menembus puluhan ribu request per detik (RPS) per node.

LLM berbasis API eksternal terikat latensi round-trip HTTP, alokasi antrean penyedia model, dan waktu generasi token (time-to-first-token + streaming/generation time). Rata-rata latensi p95 berada di rentang 400 ms hingga 3.000 ms. Throughput dibatasi oleh rate limit API (TPM/RPM) atau kapasitas konkurensi cluster self-hosted (vLLM/TGI).

2. Kalkulasi Biaya Operasional (1 Juta Request)

Asumsikan payload evaluasi keputusan berukuran 500 token konteks (profil user, riwayat transaksi, kondisi limit) dan menghasilkan 50 token output (keputusan, kode aksi, alasan).

• Deterministic Rule Engine (In-Memory/Local Compute): Dieksekusi pada instance compute standar (misal: AWS ECS Fargate 2 vCPU, 4GB RAM seharga ~$36/bulan). Container tunggal dapat memproses 2.000 RPS. Untuk 1.000.000 request, waktu komputasi murni yang dikonsumsi adalah sekitar 500 detik. Biaya riil komputasi: < $0,05 per 1 juta request.
• LLM Tier Ringan (misal: $0,15/1M input token, $0,60/1M output token): 1M request x 500 input token = 500M token ($75). 1M request x 50 token = 50M token ($30). Total biaya: $105 per 1 juta request.
• LLM Tier Menengah/Tinggi (misal: $2,50/1M input, $10,00/1M output): Total biaya: $1.750 per 1 juta request.

Delta biaya antara rule engine in-process dan LLM berkisar antara 2.000x hingga 35.000x lipat.

3. Determinisme dan Blast Radius

Rule engine bersifat 100% deterministik. Input yang identik menghasilkan output yang identik secara konstan, mempermudah audit kepatuhan (compliance), unit testing, dan regresi. Bug logika terisolasi pada cakupan rule yang salah.

LLM bersifat probabilistik. Perubahan parameter temperature, pembaruan checkpoint bobot model oleh vendor, atau modifikasi prompt minor dapat mengubah hasil keputusan. Kegagalan parser (output JSON terpotong atau halusinasi field) dapat merusak downstream pipeline jika validation boundary tidak ketat.

Matriks Keputusan Evaluasi Arsitektur

Gunakan matriks ini sebelum mengintegrasikan LLM ke dalam alur eksekusi keputusan kritis:

Implementasi Hybrid Pattern (Tiered Decisioning)

Pola paling efisien dalam sistem berskala tinggi adalah tiered decisioning. Rule engine lokal berfungsi sebagai filter layer-1 (menangani 90-95% lalu lintas untuk keputusan deterministik). LLM dialokasikan hanya sebagai layer-2 untuk input yang ambigu atau tidak terdefinisi secara terstruktur.

Implementasi TypeScript berikut menunjukkan evaluasi transaksi fraud dengan JSON Logic lokal dan fallback LLM bersyarat:

import jsonLogic from "json-logic-js";

interface TransactionContext {
  userId: string;
  amount: number;
  country: string;
  isVpn: boolean;
  unstructuredRiskNotes?: string;
}

interface DecisionResult {
  action: "APPROVE" | "REJECT" | "REVIEW";
  engine: "RULE_ENGINE" | "LLM_TIER2" | "SAFE_FALLBACK";
  reason: string;
}

// Hard-coded or dynamic rules fetched from DB/Redis cache
const hardBlockRules = {
  or: [
    { ">": [{ var: "amount" }, 50000] },
    { and: [{ var: "isVpn" }, { "==": [{ var: "country" }, "HIGH_RISK_ZONE"] }] }
  ]
};

const fastApproveRules = {
  and: [
    { "<=": [{ var: "amount" }, 1000] },
    { "==": [{ var: "isVpn" }, false] }
  ]
};

async function evaluateDecision(ctx: TransactionContext): Promise<DecisionResult> {
  // Layer 1: Fast deterministic evaluation (< 0.1ms)
  if (jsonLogic.apply(hardBlockRules, ctx)) {
    return { action: "REJECT", engine: "RULE_ENGINE", reason: "Triggered hard rule blacklist." };
  }

  if (jsonLogic.apply(fastApproveRules, ctx)) {
    return { action: "APPROVE", engine: "RULE_ENGINE", reason: "Criteria met fast-path rules." };
  }

  // Layer 2: Escalation to LLM only if ambiguous note exists
  if (ctx.unstructuredRiskNotes) {
    try {
      const llmVerdict = await callLlmWithTimeout(ctx, 1200); // 1.2s strict budget
      return { action: llmVerdict.action, engine: "LLM_TIER2", reason: llmVerdict.reason };
    } catch (error) {
      // Degraded fallback when LLM API times out or rate limits
      return { action: "REVIEW", engine: "SAFE_FALLBACK", reason: "LLM timeout; route to manual review." };
    }
  }

  return { action: "REVIEW", engine: "RULE_ENGINE", reason: "Grey zone without semantic context." };
}

async function callLlmWithTimeout(ctx: TransactionContext, timeoutMs: number): Promise<{ action: "APPROVE" | "REJECT" | "REVIEW"; reason: string }> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeoutMs);

  try {
    // Simulasi pemanggilan API model reasoning (OpenAI/Anthropic/Local vLLM)
    // Structured Outputs (JSON Schema) wajib digunakan di sini
    return { action: "REVIEW", reason: "Manual investigation suggested by semantic analysis." };
  } finally {
    clearTimeout(timer);
  }
}

Mitigasi dan Aturan Arsitektural

1. Jangan gunakan LLM untuk evaluasi logika boolean atau angka: Gunakan Rule Engine (CEL, JsonLogic, Drools) atau compiled expression engine bawaan bahasa pemrograman Anda.
2. Beri batas timeout ketat pada LLM: Panggilan LLM pada alur sinkron wajib memiliki timeout di bawah 1,5 detik dengan deterministik fallback (misal default ke Manual Review atau Safe Deny).
3. Gunakan Structured Output: Jika LLM terpaksa digunakan, kunci respons dengan schema validation (JSON Schema/Zod) untuk mencegah syntax error saat deserialisasi data ke downstream consumer.
4. Caching Keputusan: Gunakan semantic caching atau deterministic input hashing (SHA-256 pada payload) sebelum melakukan request ke LLM guna memangkas konsumsi token yang identik.