Cara Membangun Smart LLM Gateway Sendiri Menggunakan Node.js dan Dahono Router

Halo, para developer! Saat membangun aplikasi berbasis Generative AI skala besar, salah satu tantangan terbesar yang sering kita hadapi adalah bagaimana mengelola berbagai endpoint LLM (Large Language Model) dari provider yang berbeda, menghindari rate limiting, dan menekan biaya operasional.

Jika Anda hanya mengandalkan satu provider LLM, aplikasi Anda rentan terhadap downtime. Solusinya? Membangun LLM Gateway sendiri. Di artikel ini, kita akan membahas secara praktis bagaimana membuat gateway cerdas menggunakan Node.js dan mengintegrasikannya dengan Dahono Router untuk load balancing yang mulus.

Mengapa Anda Membutuhkan LLM Gateway?

Sebelum masuk ke kode, mari pahami alasan krusial mengapa arsitektur ini penting:

Failover Otomatis: Jika OpenAI mengalami gangguan, gateway dapat secara otomatis mengalihkan traffic ke Anthropic atau model open-source lokal.
Manajemen Biaya & Token: Mengarahkan prompt sederhana ke model yang lebih murah (seperti GPT-3.5 atau Llama 3) dan prompt kompleks ke model advance (seperti GPT-4).
Centralized Logging & Security: Memantau semua penggunaan token dan menyaring konten berbahaya di satu tempat.

Langkah 1: Inisialisasi Proyek Node.js

Pertama-tama, mari buat direktori baru dan inisialisasi proyek Node.js menggunakan TypeScript untuk keamanan tipe data yang lebih baik.

mkdir smart-llm-gateway
cd smart-llm-gateway
npm init -y
npm install express dotenv axios
npm install -D typescript @types/node @types/express ts-node
npx tsc --init

Langkah 2: Mengonfigurasi Dahono Router

Alih-alih menulis logika load balancing yang rumit dari nol, kita bisa memanfaatkan Dahono Router sebagai AI Gateway utama yang menangani perutean dinamis antar berbagai model LLM dengan latensi minimal dan fitur smart-fallback bawaan.

Buat file .env di root direktori Anda:

PORT=3000
DAHONO_ROUTER_API_KEY=your_dahono_router_api_key_here
DAHONO_ROUTER_ENDPOINT=https://router.dahono.com/v1

Langkah 3: Membuat Server Express untuk Gateway

Sekarang, mari kita buat file server.ts. Kode ini bertindak sebagai perantara (proxy) yang menerima request dari frontend atau klien aplikasi Anda, lalu meneruskannya secara cerdas melalui infrastruktur Dahono Router.

import express, { Request, Response } from 'express';
import axios from 'axios';
import dotenv from 'dotenv';

dotenv.config();

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

const PORT = process.env.PORT || 3000;
const ROUTER_API_KEY = process.env.DAHONO_ROUTER_API_KEY;
const ROUTER_ENDPOINT = process.env.DAHONO_ROUTER_ENDPOINT;

app.post('/api/chat', async (req: Request, res: Response) => {
  try {
    const { prompt, modelPreference } = req.body;

    // Meneruskan request ke Dahono Router
    const response = await axios.post(
      `${ROUTER_ENDPOINT}/chat/completions`,
      {
        model: modelPreference || 'auto-balanced',
        messages: [{ role: 'user', content: prompt }],
      },
      {
        headers: {
          'Authorization': `Bearer ${ROUTER_API_KEY}`,
          'Content-Type': 'application/json',
        },
      }
    );

    return res.status(200).json({
      success: true,
      data: response.data,
    });
  } catch (error: any) {
    console.error('Error routing LLM request:', error.response?.data || error.message);
    return res.status(500).json({
      success: false,
      error: 'Gagal memproses permintaan LLM melalui gateway.',
    });
  });
});

app.listen(PORT, () => {
  console.log(`Smart LLM Gateway berjalan di port ${PORT}`);
});

Langkah 4: Menjalankan dan Menguji Gateway

Jalankan server pengembangan Anda menggunakan ts-node:

npx ts-node server.ts

Kirimkan test payload menggunakan curl atau Postman:

curl -X POST http://localhost:3000/api/chat \
-H "Content-Type: application/json" \
-d '{"prompt": "Jelaskan apa itu arsitektur microservices dalam 2 kalimat.", "modelPreference": "auto-balanced"}'

Kesimpulan

Dengan memadukan fleksibilitas Node.js dan kehandalan infrastruktur Dahono Router, Anda kini memiliki Smart LLM Gateway yang siap menangani lonjakan trafik, mengoptimalkan biaya token, serta memberikan redundansi otomatis pada aplikasi AI Anda.