Implementasi Retrieval-Augmented Generation (RAG) Menggunakan LLM Lokal

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap enterprise modern, kebutuhan akan kecerdasan buatan generatif yang aman, privat, dan terisolasi dari jaringan publik menjadi prioritas utama. Perusahaan tidak dapat lagi mengandalkan Model Bahasa Besar (LLM) publik yang di-hosting di cloud eksternal tanpa risiko kebocoran kekayaan intelektual, data finansial, atau informasi identitas pribadi (PII). Implementasi Retrieval-Augmented Generation (RAG) menggunakan LLM lokal (seperti Llama 3, Mistral, atau Qwen yang berjalan di perangkat keras on-premise) menjawab tantangan ini dengan menggabungkan kapabilitas penalaran generatif model bahasa dengan basis pengetahuan spesifik perusahaan (Enterprise Knowledge Base) yang disimpan dalam Vector Database lokal.

Namun, bottleneck performa dan keamanan seringkali muncul pada aspek infrastruktur penunjang. Sebelum penerapan arsitektur RAG lokal yang matang, organisasi sering mengalami masalah serius:

• Halusinasi Model: LLM memberikan jawaban yang tampak meyakinkan namun tidak akurat secara faktual karena tidak memiliki akses langsung ke dokumen internal terbaru.
• Latensi Tinggi: Proses inferensi model lokal yang membebani GPU/CPU tanpa optimasi kuantisasi (GGUF/AWQ) menyebabkan waktu tanggap (Time-to-First-Token) mencapai puluhan detik.
• Bottleneck Penyimpanan & Pencarian Vektor: Keterbatasan arsitektur penyimpanan membuat pencarian kemiripan kosinus (Cosine Similarity) memakan waktu lama pada dataset dokumen skala besar.
• Celah Keamanan Web & API: Titik endpoint API yang menghubungkan frontend web dengan layanan inferensi lokal sering kali rentan terhadap serangan Denial of Service (DoS) dan injeksi prompt.

Perbandingan Kondisi: Sebelum vs Sesudah RAG Lokal Enterprise

[!IMPORTANT] Keamanan data internal perusahaan adalah mutlak. Pastikan seluruh lalu lintas jaringan antara klien web, server aplikasi backend, dan engine LLM lokal diisolasi menggunakan enkripsi TLS internal (mTLS) dan dilindungi oleh Web Application Firewall (WAF).

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur RAG under the hood bekerja melalui dua fase utama: Fase Ingesti (Offline Indexing) dan Fase Inferensi (Online Querying). Diagram ASCII di bawah ini menggambarkan alur data secara menyeluruh dari dokumen mentah hingga respons yang dihasilkan oleh LLM lokal.

[ Dokumen Sumber (PDF, Markdown, DB) ]
               │
               ▼
┌──────────────────────────────┐
│      Ingestion Pipeline      │
│  (Text Splitting & Cleaning) │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│    Embedding Model Lokal     │
│     (e.g., BGE-M3 / Nomic)   │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│     Vector Database (Milvus) │
│   (Simpan Embedding Vektor)  │
└──────────────────────────────┘

───────────────── GARIS PEMISAH FASE INGESTI & INFERENSI ─────────────────

[ Klien Web / UI ] ──(HTTP POST)──> [ Web Server (Nginx / Caddy) ]
                                              │
                                              ▼
                                   [ Backend API (Node.js/Go/PHP) ]
                                              │
                    ┌─────────────────────────┴─────────────────────────┐
                    │                                                   │
                    ▼ (Query Embedding)                                 ▼ (Prompt Construction)
     ┌──────────────────────────────┐                     ┌──────────────────────────────┐
     │    Vector Database (Milvus)  │                     │   LLM Lokal (Ollama / vLLM)  │
     │ (Pencarian Top-K Kemiripan)  │                     │  (Inferensi & Generasi Teks) │
     └──────────────┬───────────────┘                     └──────────────┬───────────────┘
                    │                                                   │
                    └───────────────────< Context >─────────────────────┘
                                              │
                                              ▼
                               [ Respons Kembali ke Klien (SSE) ]

Alur Eksekusi Detail

1. Dokumen Ingesti: File teks mentah dipotong menjadi potongan-potongan kecil (chunks) dengan ukuran optimal (misal: 512 token dengan overlap 50 token) untuk menjaga konteks semantik.
2. Vektorisasi: Setiap chunk dikonversi menjadi representasi vektor numerik menggunakan model embedding open-source.
3. Indeksasi Vector DB: Vektor disimpan bersama metadata aslinya (URL sumber, judul dokumen, akses kontrol) di dalam Vector Database seperti Milvus atau Qwen Vector.
4. Permintaan Pengguna: Pengguna mengirimkan kueri melalui antarmuka web. Backend menerima kueri, mengubahnya menjadi vektor menggunakan model embedding yang sama.
5. Pencarian Konteks (Retrieval): Vector DB melakukan pencarian Approximate Nearest Neighbor (ANN) menggunakan algoritma HNSW (Hierarchical Navigable Small World) untuk mengambil top-K dokumen yang paling relevan.
6. Augmentasi & Generasi: Backend menggabungkan kueri asli pengguna dengan dokumen konteks yang ditemukan ke dalam sebuah prompt template standar, lalu dikirim ke LLM lokal untuk menghasilkan jawaban akhir.

3. Perbandingan Komparatif / Analisis Pendekatan

Memilih komponen infrastruktur yang tepat sangat menentukan keberhasilan implementasi RAG di lingkungan produksi. Berikut adalah analisis perbandingan mendalam antara beberapa teknologi utama untuk Vector Database dan Engine LLM Lokal.

[!TIP] Untuk perusahaan dengan kebijakan keamanan ketat yang melarang penggunaan layanan cloud eksternal, kombinasi Milvus (Self-Hosted via Docker Compose) dan vLLM / Ollama adalah standar emas arsitektur on-premise.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum melakukan deployment sistem RAG lokal, pastikan infrastruktur server memenuhi spesifikasi minimum perangkat keras dan perangkat lunak berikut:

Spesifikasi Minimum Hardware

• CPU: 16 Core vCPU (Intel Xeon / AMD EPYC generasi terbaru dengan dukungan AVX-512)
• RAM: 64 GB ECC RAM (Direkomendasikan 128 GB untuk menampung Vector DB dan model embedding di memori)
• GPU: NVIDIA Enterprise GPU (Contoh: NVIDIA A10G, L4, atau RTX 4090/6000 Ada Generation dengan VRAM minimum 24GB)
• Storage: 1 TB NVMe SSD (High IOPS untuk operasi pembacaan indeks vektor)

Prangkat Lunak & Sistem Operasi

• OS: Ubuntu Server 22.04 LTS (Kernel Linux 5.15+)
• Containerization: Docker Engine v24.0+ & Docker Compose v2.20+
• Driver NVIDIA: NVIDIA Driver v535+ & NVIDIA Container Toolkit

Verifikasi Awal Perangkat Keras

Jalankan perintah berikut di terminal server untuk memastikan GPU dan Docker terdeteksi dengan benar:

# Verifikasi informasi GPU NVIDIA
nvidia-smi

# Verifikasi dukungan NVIDIA Container Toolkit pada Docker
docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

5. Panduan Implementasi Langkah demi Langkah

Berikut adalah panduan lengkap implementasi sistem RAG menggunakan Docker Compose yang mencakup Milvus Vector Database, Ollama (LLM Engine), dan aplikasi backend Node.js sebagai jembatan logika RAG.

Langkah 1: Konfigurasi Docker Compose (docker-compose.yml)

Buat file konfigurasi direktori proyek /opt/enterprise-rag/docker-compose.yml:

version: '3.8'

services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.0
    container_name: milvus-etcd
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
      - ETCD_SNAPSHOT_COUNT=50000
    command: etcd -advertise-client-urls http://0.0.0.0:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    volumes:
      - etcd-data:/etcd
    networks:
      - rag-net

  minio:
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    container_name: milvus-minio
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data
    volumes:
      - minio-data:/minio_data
    networks:
      - rag-net

  milvus:
    image: milvusdb/milvus:v2.3.0
    container_name: milvus-standalone
    command: milvus run standalone
    environment:
      - ETCD_ENDPOINTS=etcd:2379
      - minio.address=minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio
    volumes:
      - milvus-data:/var/lib/milvus
    networks:
      - rag-net

  ollama:
    image: ollama/ollama:latest
    container_name: ollama-engine
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    networks:
      - rag-net

volumes:
  etcd-data:
  minio-data:
  milvus-data:
  ollama-data:

networks:
  rag-net:
    driver: bridge

Langkah 2: Menjalankan Layanan dan Mengunduh Model

Jalankan perintah berikut untuk menghidupkan kontainer:

# Masuk ke direktori proyek
cd /opt/enterprise-rag

# Jalankan kontainer di latar belakang
docker compose up -d

# Tunggu beberapa detik, lalu unduh model LLM (misal: Llama 3 8B) dan model embedding ke dalam kontainer Ollama
docker exec -it ollama-engine ollama pull llama3
docker exec -it ollama-engine ollama pull nomic-embed-text

Langkah 3: Implementasi Backend RAG (server.js)

Buat file aplikasi backend Node.js untuk menangani ingest dokumen dan pemrosesan query RAG di /opt/enterprise-rag/server.js:

const express = require('express');
const { MilvusClient } = require('@zilliz/milvus2-sdk-node');
const axios = require('axios');

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

const port = 3000;
const milvusAddress = 'localhost:19530';
const ollamaBaseUrl = 'http://localhost:11434';
const COLLECTION_NAME = 'enterprise_knowledge';

const milvusClient = new MilvusClient({ address: milvusAddress });

// Helper: Generate Embedding menggunakan Ollama
async function getEmbedding(text) {
    try {
        const response = await axios.post(`${ollamaBaseUrl}/api/embeddings`, {
            model: 'nomic-embed-text',
            prompt: text
        });
        return response.data.embedding;
    } catch (error) {
        console.error('Gagal menghasilkan embedding:', error.message);
        throw error;
    }
}

// Endpoint Ingest Dokumen
app.post('/api/ingest', async (req, res) => {
    try {
        const { document_id, text } = req.body;
        const vector = await getEmbedding(text);

        // Pastikan koleksi ada
        const hasCollection = await milvusClient.hasCollection({ collection_name: COLLECTION_NAME });
        if (!hasCollection.value) {
            await milvusClient.createCollection({
                collection_name: COLLECTION_NAME,
                fields: [
                    { name: 'id', data_type: 'Int64', is_primary_key: true, auto_id: true },
                    { name: 'document_id', data_type: 'VarChar', max_length: 100 },
                    { name: 'text_chunk', data_type: 'VarChar', max_length: 2048 },
                    { name: 'vector', data_type: 'FloatVector', dim: 768 }
                ]
            });
        }

        // Masukkan data ke Milvus
        const insertResult = await milvusClient.insert({
            collection_name: COLLECTION_NAME,
            data: [{
                document_id: document_id,
                text_chunk: text,
                vector: vector
            }]
        });

        res.status(200).json({ status: 'success', insertResult });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// Endpoint Query RAG
app.post('/api/query', async (req, res) => {
    try {
        const { query } = req.body;
        const queryVector = await getEmbedding(query);

        // Cari dokumen paling relevan di Milvus
        const searchResult = await milvusClient.search({
            collection_name: COLLECTION_NAME,
            vector: queryVector,
            limit: 3,
            output_fields: ['text_chunk', 'document_id']
        });

        // Ekstraksi konteks
        const retrievedContexts = searchResult.results.map(item => item.text_chunk).join('\n\n');

        // Susun Prompt Augmented
        const prompt = `Anda adalah asisten AI perusahaan. Jawab pertanyaan berikut HANYA berdasarkan konteks yang diberikan di bawah ini. Jika informasi tidak ditemukan dalam konteks, katakan bahwa Anda tidak tahu.\n\nKonteks:\n${retrievedContexts}\n\nPertanyaan: ${query}\nJawaban:`;

        // Kirim ke LLM Lokal via Ollama
        const llmResponse = await axios.post(`${ollamaBaseUrl}/api/generate`, {
            model: 'llama3',
            prompt: prompt,
            stream: false
        });

        res.status(200).json({
            query,
            context_used: searchResult.results,
            answer: llmResponse.data.response
        });

    } data (error) {
        res.status(500).json({ error: error.message });
    }
});

app.listen(port, () => {
    console.log(`Enterprise RAG Backend berjalan di port ${port}`);
});

6. Bedah Kode & Penjelasan Detail Baris Kunci

1. model: 'nomic-embed-text' pada fungsi getEmbedding: Model ini dipilih karena menghasilkan representasi vektor dengan dimensi 768 yang sangat optimal untuk pencarian semantik bahasa Indonesia dan Inggris, serta berjalan sangat ringan di perangkat keras lokal.
2. milvusClient.search dengan parameter limit: 3: Menentukan jumlah top-K chunks yang diambil dari Vector DB. Angka 3 adalah trade-off ideal antara kelengkapan konteks dan batas maksimum panjang token (context window) dari LLM 8B parameter.
3. Prompt Engineering Grounding (HANYA berdasarkan konteks...): Instruksi ketat ini krusial untuk mencegah model melakukan halusinasi atau mengandalkan pengetahuan eksternal yang tidak diverifikasi oleh sistem.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Pada lingkungan produksi skala besar (misalnya melayani 5.000 karyawan internal secara bersamaan), arsitektur tunggal di atas akan mengalami hambatan pada beban CPU/GPU inferensi LLM.

Solusi High Availability & Load Balancing:

• Nginx Reverse Proxy: Mengatur load balancing untuk mendistribusikan permintaan API backend ke beberapa instance Node.js.
• vLLM Cluster: Mengganti Ollama dengan klaster vLLM yang mendukung Continuous Batching dan PagedAttention, meningkatkan throughput token hingga 3x lipat pada GPU NVIDIA A10G.
• Redis Caching: Menyimpan hasil query RAG yang sering ditanyakan (FAQ internal) di Redis dengan TTL 1 jam untuk memotong waktu latensi hingga 0 milidetik pada kueri berulang.

Contoh konfigurasi Nginx Reverse Proxy (/etc/nginx/sites-available/rag-enterprise.conf):

upstream rag_backend_cluster {
    server 127.0.0.1:3000;
    server 127.0.0.1:3001;
    keepalive 32;
}

server {
    listen 80;
    server_name rag.internal.enterprise.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name rag.internal.enterprise.com;

    ssl_certificate /etc/letsencrypt/live/rag.internal.enterprise.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/rag.internal.enterprise.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    client_max_body_size 20M;

    location / {
        proxy_pass http://rag_backend_cluster;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
    }
}

8. Common Pitfalls, Anti-Patterns & Solusi

• Anti-Pattern 1: Ukuran Chunk Terlalu Besar. Memotong dokumen utuh berukuran 10.000 kata ke dalam satu vektor akan merusak akurasi semantik.
  • Solusi: Terapkan Recursive Character Text Splitting dengan ukuran chunk 500 karakter dan overlap 50 karakter.
• Anti-Pattern 2: Mengabaikan Keamanan Endpoint API. Membuka port Vector DB atau Ollama secara langsung ke publik tanpa autentikasi.
  • Solusi: Selalu gunakan Nginx sebagai reverse proxy dengan pembatasan IP internal (VPN/VPC) dan token Bearer Authentication.
• Anti-Pattern 3: Tidak Melakukan Indeks Ulang Saat Model Embedding Diubah. Mengganti model embedding tanpa meregenerasi vektor di Milvus akan menyebabkan pencarian kosinus menghasilkan data korup.
  • Solusi: Lakukan migrasi skema dan re-indexing secara berkala melalui job terjadwal (Cron + Queue).

9. Benchmark, Metrik Kinerja & Tuning Performa

Untuk memastikan sistem RAG memenuhi SLA enterprise, lakukan pengujian beban menggunakan tool k6. Buat file skrip load-test.js:

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
    stages: [
        { duration: '1m', target: 50 },  // Ramp-up ke 50 pengguna
        { duration: '3m', target: 50 },  // Pertahankan 50 pengguna
        { duration: '1m', target: 0 },   // Ramp-down
    ],
};

export default function () {
    const url = 'http://localhost:3000/api/query';
    const payload = JSON.stringify({
        query: 'Bagaimana prosedur klaim asuransi kesehatan karyawan?'
    });

    const params = {
        headers: {
            'Content-Type': 'application/json',
        },
    };

    const res = http.post(url, payload, params);
    check(res, {
        'status adalah 200': (r) => r.status === 200,
        'latensi < 2000ms': (r) => r.timings.duration < 2000,
    });
    sleep(1);
}

Jalankan benchmark dengan perintah:

k6 run load-test.js

Parameter Tuning Lanjutan:

• Milvus Index Tuning: Ubah tipe indeks dari IVF_FLAT ke HNSW dengan parameter M = 16 dan efConstruction = 200 untuk meningkatkan kecepatan pencarian vektor pada dataset > 10.000.000 entri.
• Ollama OMP_NUM_THREADS: Batasi jumlah thread CPU untuk mencegah kompetisi sumber daya dengan proses sistem lain:

  export OMP_NUM_THREADS=8
  

10. Checklist Penerapan Produksi & Kesimpulan

Sebelum merilis sistem RAG lokal ke lingkungan produksi enterprise, pastikan seluruh item dalam checklist berikut telah terpenuhi:

• Isolasi Jaringan: Seluruh kontainer berada di dalam jaringan privat (Docker Bridge terisolasi).
• Enkripsi: Komunikasi eksternal menggunakan TLS 1.3 dengan sertifikat SSL valid (Let's Encrypt / Internal CA).
• Manajemen Akses: Endpoint API dilindungi oleh autentikasi token JWT dan Rate Limiting.
• Backup & Recovery: Volume data Milvus dan Minio dijadwalkan untuk backup otomatis harian ke penyimpanan S3 terpisah.
• Monitoring & Logging: Mengintegrasikan Prometheus dan Grafana untuk memantau penggunaan VRAM GPU, latensi kueri, dan penggunaan disk.

Dengan mengikuti panduan komprehensif ini, Anda telah membangun infrastruktur Retrieval-Augmented Generation (RAG) lokal yang aman, handal, berkinerja tinggi, dan sepenuhnya berada di bawah kendali kedaulatan data perusahaan.