Dalam arsitektur aplikasi berbasis Large Language Model (LLM), perceived latency (latensi yang dirasakan pengguna) jauh lebih menentukan kepuasan dibanding total waktu penyelesaian komputasi. Pengguna tidak keberatan menunggu 10 detik untuk sebuah ringkasan kode 500 baris, asalkan kata pertama langsung muncul di layar dalam hitungan beberapa ratus milidetik.
Metrik kritis yang menjadi tolok ukur di sini adalah Time to First Token (TTFT). TTFT yang lambat membuat antarmuka terasa kaku (freezing), memicu frustrasi, dan merusak kenyamanan interaksi pada aplikasi real-time seperti chatbot interaktif, autonomous coding agent, atau AI copilot di IDE.
Namun, banyak tim engineering yang terkejut mendapati respons streaming mereka tiba-tiba berhenti mengalir saat dideploy ke server produksi. Alih-alih mengalir kata demi kata, respons justru muncul sekaligus dalam satu bongkahan besar (batch burst) setelah beberapa detik. Masalah ini hampir selalu berakar pada satu titik: lapisan reverse proxy yang melakukan response buffering secara agresif.
Anatomi Protokol: Mengapa SSE Menjadi Standar Industri AI?
Di era awal LLM, banyak developer mempertimbangkan WebSocket untuk transmisi dua arah (full-duplex). Namun dalam praktiknya, lebih dari 95% penyedia model frontier (seperti OpenAI, Anthropic Claude, DeepSeek, dan Google Gemini) menstandarkan transmisi token melalui Server-Sent Events (SSE) via protokol HTTP/1.1 atau HTTP/2.
SSE beroperasi dengan tipe konten khusus text/event-stream. Berbeda dengan request HTTP konvensional yang mengirimkan satu payload utuh lalu menutup koneksi, SSE mempertahankan koneksi tetap terbuka dan menyalurkan data dalam serangkaian potongan event terpisah (chunks).
| Dimensi Arsitektur | Server-Sent Events (SSE) | WebSocket | HTTP Chunked (Raw) |
|---|---|---|---|
| Arah Komunikasi | Server-ke-Client (Unidirectional) | Full-Duplex (Dua Arah) | Server-ke-Client |
| Lapisan Protokol | HTTP murni (text/event-stream) |
Upgrade TCP Socket (ws://) |
HTTP murni (Chunked Transfer) |
| Reconnect Bawaan | Otomatis via browser EventSource |
Manual via logic client | Tidak ada |
| Kompatibilitas Firewall/Proxy | Sangat Tinggi (Port 80/443 standar) | Sedang (Perlu aturan upgrade) | Sangat Tinggi |
| Framing Pesan | Terstruktur (data: {...}\n\n) |
Binary / Text Frame | Raw Stream Byte |
| Overhead Koneksi | Sangat Rendah | Sedang (Handshake upgrade) | Sangat Rendah |
Alasan utama dominasi SSE terletak pada kesederhanaannya. Pola interaksi LLM pada dasarnya bersifat asinkron satu arah: pengguna mengirimkan prompt sekali di awal, lalu server membalas dengan menyemburkan puluhan hingga ribuan token secara terus-menerus hingga selesai (data: [DONE]).
💡 Catatan Praktisi: Hindari godaan memakai WebSocket hanya untuk streaming token LLM. WebSocket mempertahankan status koneksi (stateful) pada layer aplikasi, menyulitkan horizontal autoscaling, dan rentan diputus oleh middleware korporat atau Content Delivery Network (CDN) yang tidak mendukung long-lived socket.
Mengapa Reverse Proxy Membunuh TTFT: Bahaya Buffer Bloat
Secara default, reverse proxy populer seperti Nginx, Envoy, HAProxy, maupun CDN seperti Cloudflare dirancang untuk mengoptimalkan throughput web tradisional. Proxy akan membaca data dari upstream server dan menampungnya ke dalam buffer internal (biasanya berukuran 4 KB hingga 16 KB) sebelum meneruskannya ke browser klien.
Tujuannya adalah menghemat I/O dan meminimalkan packet overhead. Namun untuk streaming LLM, mekanisme ini justru berubah menjadi malapetaka.
1. Buffer Accumulation Latency
Setiap token yang dihasilkan oleh LLM biasanya dikirim dalam event SSE berukuran sangat mungil, sekitar 20 hingga 60 byte. Jika Nginx kamu memiliki ukuran buffer default 4.096 byte (4 KB), proxy akan menahan dan membendung token-token awal tersebut.
Proxy baru akan menyemburkan data ke klien setelah model memproduksi sekitar 70 hingga 100 token, atau ketika koneksi upstream akhirnya ditutup. Akibatnya, streaming berubah menjadi pseudo-batching: pengguna menunggu beberapa detik tanpa indikator visual, lalu mendadak melihat teks mengalir sangat cepat.
2. Phantom Cost Akibat Client Abort yang Terabaikan
Bayangkan pengguna menekan tombol "Stop Generating" di antarmuka web, atau IDE menutup koneksi karena timeout. Klien mengirim sinyal TCP FIN atau memicu AbortController.
Jika reverse proxy tidak dikonfigurasi untuk meneruskan sinyal diskoneksi ini ke upstream gateway, backend LLM akan terus melakukan inferensi dan menghasilkan token hingga selesai di latar belakang. Kamu tetap ditagih untuk ribuan output token yang bahkan tidak pernah dibaca oleh siapa pun.
3. Idle Read Timeout Saat Model "Thinking"
Model-model penalaran mutakhir (reasoning models) seperti DeepSeek-R1 atau Claude 3.7 dengan mode extended thinking membutuhkan fase komputasi internal sebelum memancarkan token pertama. Selama 10 hingga 30 detik pertama, tidak ada byte data yang mengalir di jaringan.
Jika reverse proxy kamu masih menggunakan konfigurasi default proxy_read_timeout 60s tanpa konfigurasi keep-alive heartbeat, fluktuasi jaringan sedikit saja bisa memicu HTTP 504 Gateway Timeout dan memutus sesi pengguna tepat sebelum jawaban selesai dipikirkan.
Blueprint Arsitektur: Desain Zero-Buffering AI Gateway
Untuk menghasilkan pengalaman streaming berkecepatan tinggi dengan TTFT konsisten di bawah 300 milidetik, AI Gateway seperti ModelRouter mengimplementasikan arsitektur zero-copy pipe tanpa perantara buffer.
[ Client / Cursor / Web ]
│
│ HTTP/2 multiplexed SSE
▼
┌─────────────────────────────────────────────────┐
│ Edge Ingress (Nginx / Envoy) │
│ - proxy_buffering off │
│ - X-Accel-Buffering: no │
│ - TCP nodelay & HTTP/1.1 keepalive │
└────────────────────────┬────────────────────────┘
│
│ Zero-Copy Streaming Pipe
▼
┌─────────────────────────────────────────────────┐
│ ModelRouter Gateway Engine │
│ - Event chunk normalization │
│ - Token meter on-the-fly │
│ - Upstream Abort Signal propagation │
└────────────────────────┬────────────────────────┘
│
┌─────────────┴─────────────┐
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ DeepSeek API │ │ Anthropic API │
│ (Direct SSE) │ │ (Direct SSE) │
└─────────────────┘ └─────────────────┘
1. Hardening Konfigurasi Ingress Nginx
Pada lapisan edge ingress, response buffering harus dimatikan secara eksplisit untuk semua route yang menangani AI inference. Berikut adalah konfigurasi standar industri yang wajib kamu terapkan:
location /v1/chat/completions {
proxy_pass http://ai_gateway_upstream;
# 1. Matikan buffering total
proxy_buffering off;
proxy_cache off;
# 2. Pertahankan protokol streaming HTTP/1.1
proxy_http_version 1.1;
proxy_set_header Connection "";
# 3. Aktifkan chunked encoding dan header bypass
chunked_transfer_encoding on;
proxy_set_header X-Accel-Buffering "no";
# 4. Long read timeout untuk reasoning model (DeepSeek-R1 / o3)
proxy_read_timeout 300s;
proxy_send_timeout 300s;
# 5. Optimasi soket TCP
tcp_nodelay on;
}
Menonaktifkan buffering memastikan setiap byte yang diterima dari provider upstream langsung disalurkan ke soket klien tanpa antrean buffer memori lokal.
2. Backpressure dan Propagasi Abort Signal
Gateway cerdas harus memantau event penutupan soket klien secara presisi. Begitu event close atau sinyal pembatalan terdeteksi pada sisi klien, gateway segera memanggil sinyal abort pada HTTP client upstream menggunakan AbortController (Node.js/TypeScript) atau pembatalan context.Context (Go). Langkah ini memutus inferensi di sisi provider secara instan dan menghentikan pemborosan kuota token kamu.
3. HTTP/2 Multiplexing untuk Autonomous Agent
Saat kamu menjalankan autonomous coding agent yang mengeksekusi banyak panggilan alat (tool calls) secara paralel, batas koneksi HTTP/1.1 di browser (maksimal 6 koneksi per origin) akan menimbulkan fenomena head-of-line blocking. Dengan mengaktifkan HTTP/2 di lapisan edge gateway, ratusan stream inferensi dapat berjalan bersamaan di atas satu koneksi TCP tunggal tanpa saling menghambat.
Implementasi Python: Mengukur TTFT dan Throughput Streaming
Kamu dapat memverifikasi kecepatan streaming dan latensi token pertama secara langsung menggunakan OpenAI Python SDK. Kita akan menghubungkan pengujian ini ke endpoint ModelRouter.
Berikut adalah skrip benchmarking untuk mengukur TTFT nyata dan laju token per detik (tokens per second):
import os
import time
from openai import OpenAI
# Inisialisasi client dengan endpoint ModelRouter
client = OpenAI(
base_url="https://modelrouter.id/v1",
api_key=os.environ.get("MODELROUTER_API_KEY", "mr-prod-xxxxx")
)
def benchmark_streaming_ttft(model_name: str, prompt_text: str):
print(f"=== Menguji Model: {model_name} ===")
start_time = time.perf_counter()
first_token_time = None
chunks_count = 0
full_response = []
stream = client.chat.completions.create(
model=model_name,
messages=[
{"role": "system", "content": "Kamu adalah asisten teknis AI yang ringkas dan akurat."},
{"role": "user", "content": prompt_text}
],
stream=True,
temperature=0.3
)
for chunk in stream:
delta = chunk.choices[0].delta.content if chunk.choices and chunk.choices[0].delta else None
if delta:
if first_token_time is None:
first_token_time = time.perf_counter()
ttft_ms = (first_token_time - start_time) * 1000
print(f"⚡ Time to First Token (TTFT): {ttft_ms:.2f} ms")
chunks_count += 1
full_response.append(delta)
# Cetak potongan teks secara real-time ke terminal
print(delta, end="", flush=True)
end_time = time.perf_counter()
total_duration = end_time - start_time
streaming_duration = end_time - first_token_time if first_token_time else 0.001
throughput = chunks_count / streaming_duration
print("
--- Metrik Kinerja Streaming ---")
print(f"Total Waktu Request : {total_duration:.2f} detik")
print(f"TTFT : {((first_token_time - start_time) * 1000):.2f} ms")
print(f"Throughput Chunk : {throughput:.2f} chunks/detik")
print(f"Total Chunks Diterima: {chunks_count}
")
# Jalankan pengujian streaming
benchmark_streaming_ttft(
model_name="deepseek-v3",
prompt_text="Tulis fungsi Go untuk memvalidasi token JWT dengan RSA256 signature secara efisien."
)
Ketika kamu mengeksekusi skrip di atas melalui gateway dengan konfigurasi zero-buffering yang optimal, nilai TTFT akan mencatatkan angka stabil di bawah 300 ms (tergantung latensi jaringan dari mesin penguji ke gateway), dan setiap potongan token akan langsung muncul seketika di terminal tanpa ada jeda lonjakan (bursting).
Menghilangkan Hambatan Infrastruktur AI di Indonesia
Membangun AI reverse proxy mandiri dengan ketahanan tinggi, konfigurasi SSE tanpa buffer, auto-failover, dan dynamic rate limiting membutuhkan alokasi sumber daya teknis serta biaya operasional server yang tidak sedikit.
Bagi startup, software house, dan developer di Indonesia yang ingin fokus membangun produk AI tanpa pusing memikirkan plumbing infrastruktur, ModelRouter hadir sebagai solusi AI Gateway lokal berkinerja tinggi.
Sebagai Alternatif OpenRouter karya anak bangsa, ModelRouter menawarkan keuntungan infrastruktur nyata:
- Jaringan Rute Latensi Rendah: Gateway dioptimalkan secara geografis untuk koneksi dari Indonesia dan Asia Tenggara, memangkas round-trip time (RTT) ke server model global.
- Top-Up Instan QRIS 24/7: Bebas dari kendala kartu kredit yang sering ditolak atau biaya konversi valuta asing. Kamu bisa melakukan isi ulang saldo mulai dari Rp 5.000 dengan metode QRIS otomatis.
- Katalog Model Frontier Terlengkap: Akses puluhan model unggulan seperti DeepSeek-V3, DeepSeek-R1, Claude 3.7 Sonnet, GPT-4o, hingga Gemini 2.5 melalui satu API key terpadu di Katalog Model & Tarif.
- Kompatibilitas Penuh Coding Agent: Integrasikan ModelRouter tanpa hambatan ke editor modern seperti Cursor, Roo Code, dan OpenCode. Ikuti petunjuk praktisnya di Panduan Integrasi Cursor.
- Privasi Berstandar Zero Prompt Retention (ZPR): Setiap byte prompt dan response hanya dialirkan secara in-memory tanpa pernah direkam ke storage ataupun dimanfaatkan untuk melatih model pihak ketiga.
Optimalkan latensi aplikasi AI kamu hari ini. Coba performa streaming ultra-cepat ModelRouter secara gratis dengan mengklaim saldo uji coba melalui Program Bansos AI.
