Cara Membangun Smart AI Gateway Sendiri: Optimasi Load Balancing LLM dengan Node.js

Halo, tech enthusiasts dan rekan-rekan developer Dahono!

Saat membangun aplikasi berbasis Generative AI skala besar, tantangan terbesar bukanlah sekadar memanggil API OpenAI atau Anthropic. Masalah sebenarnya muncul ketika aplikasi Anda mulai dibanjiri trafik: bagaimana jika API utama down? Bagaimana cara membagi beban (load balancing) antara beberapa provider LLM untuk menghemat biaya dan menghindari rate limit?

Di sinilah kita membutuhkan AI Gateway. Pada artikel praktis ini, kita akan membahas cara membangun AI Gateway sederhana namun tangguh menggunakan Node.js dan Express.js yang dilengkapi sistem failover dan load balancing otomatis.

Prasyarat

Sebelum kita mulai menulis kode, pastikan Anda telah menyiapkan:

Node.js (versi 18 ke atas)
Pemahaman dasar tentang Express.js
API Key dari minimal dua provider LLM (misal: OpenAI dan Anthropic)

Langkah 1: Inisialisasi Proyek

Buat direktori baru untuk proyek kita dan inisialisasi modul Node.js:

mkdir ai-gateway-tutorial
cd ai-gateway-tutorial
npm init -y

Install dependensi yang kita butuhkan, yaitu express, axios, dan dotenv untuk mengelola environment variables:

npm install express axios dotenv

Langkah 2: Konfigurasi Environment Variables

Buat file .env di akar direktori Anda untuk menyimpan kunci API secara aman:

PORT=3000
OPENAI_API_KEY=sk-your-openai-key-here
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key-here

Langkah 3: Menulis Logika Gateway & Load Balancer

Buat file bernama server.js. Di sini kita akan membuat server Express yang bertindak sebagai jembatan cerdas. Kita akan membuat routing dasar yang mendistribusikan request secara bergantian (round-robin) ke OpenAI atau Anthropic, lengkap dengan mekanisme failover jika salah satu provider mengalami gangguan.

const express = require('express');
const axios = require('axios');
require('dotenv').config();

const app = express();
app.use(express.json());

const PORT = process.env.PORT || 3000;

// Daftar upstream LLM
const PROVIDERS = [
  {
    name: 'OpenAI',
    url: 'https://api.openai.com/v1/chat/completions',
    headers: (key) => ({ 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' }),
    apiKey: process.env.OPENAI_API_KEY,
    transformBody: (body) => ({
      model: 'gpt-4o-mini',
      messages: body.messages
    })
  },
  {
    name: 'Anthropic',
    url: 'https://api.anthropic.com/v1/messages',
    headers: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' }),
    apiKey: process.env.ANTHROPIC_API_KEY,
    transformBody: (body) => ({
      model: 'claude-3-haiku-20240307',
      max_tokens: 1024,
      messages: body.messages
    })
  }
];

let currentIndex = 0;

// Fungsi Round-Robin Load Balancer dengan Failover
async function routeRequest(reqBody, retries = PROVIDERS.length) {
  const provider = PROVIDERS[currentIndex];
  // Geser index untuk request berikutnya (Round-Robin)
  currentIndex = (currentIndex + 1) % PROVIDERS.length;

  try {
    console.log(`[Gateway] Mengarahkan trafik ke: ${provider.name}`);
    const response = await axios.post(
      provider.url,
      provider.transformBody(reqBody),
      { headers: provider.headers(provider.apiKey), timeout: 10000 }
    );
    return { provider: provider.name, data: response.data };
  } catch (error) {
    console.warn(`[Warning] ${provider.name} gagal: ${error.message}. Mencoba provider lain...`);
    
    if (retries > 0) {
      // Rekursif untuk mencoba provider cadangan
      return routeRequest(reqBody, retries - 1);
    }
    throw new Error('Semua AI provider sedang tidak tersedia.');
  }
}

// Endpoint utama AI Gateway
app.post('/v1/chat', async (req, res) => {
  try {
    if (!req.body.messages) {
      return res.status(400).json({ error: 'Payload harus menyertakan array messages.' });
    }

    const result = await routeRequest(req.body);
    res.json({
      gateway_status: 'success',
      handled_by: result.provider,
      response: result.data
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  });
});

app.listen(PORT, () => {
  console.log(`🚀 Dahono AI Gateway berjalan di http://localhost:${PORT}`);
});

Langkah 4: Menguji Gateway Anda

Jalankan server Node.js Anda dengan perintah:

node server.js

Sekarang, Anda bisa mengirimkan POST request menggunakan cURL atau Postman ke http://localhost:3000/v1/chat:

curl -X POST http://localhost:3000/v1/chat \
-H "Content-Type: application/json" \
-d '{
  "messages": [
    {"role": "user", "content": "Halo, berikan sapaan singkat dalam bahasa Indonesia!"}
  ]
}'

Anda akan melihat bahwa gateway secara otomatis memilih provider secara bergiliran dan menangani potensi kegagalan koneksi secara mulus.

Solusi Enterprise: Jangan Repot Membuat Sendiri, Gunakan Dahono Router!

Meskipun membuat gateway sederhana dengan Node.js sangat bagus untuk memahami konsep dasarnya, mengelola sistem di tingkat production membutuhkan fitur yang jauh lebih kompleks seperti:

Rate Limiting tingkat lanjut per tenant.
Caching respons untuk menghemat biaya token hingga 40%.
Analytics dan Monitoring Latency secara real-time.
Fallback otomatis lintas puluhan model AI global.

Jika Anda ingin menghemat waktu pengembangan dan langsung menggunakan infrastruktur AI gateway yang handal, aman, dan siap skala enterprise, Anda wajib melirik Dahono Router. Solusi AI Gateway kami dirancang khusus untuk mengoptimalkan performa LLM perusahaan Anda tanpa kerumitan infrastruktur.

Selain itu, jika Anda membutuhkan implementasi AI khusus untuk sektor hukum, eksplorasi juga inovasi kami di Dahono Labs atau konsultasikan kebutuhan non-litigasi Anda melalui Dahono Consulting.