Literally Web ID | Arsitektur RAG Enterprise: LLM Lokal, Qdrant & vLLM

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap enterprise modern, kebutuhan untuk mengintegrasikan Large Language Models (LLM) dengan data internal korporasi sangat mendesak. Namun, ketergantungan pada API pihak ketiga seperti OpenAI atau Anthropic sering kali membentur tembok regulasi privasi data, kepatuhan (compliance) seperti GDPR atau HIPAA, serta latensi jaringan yang tidak dapat diprediksi. Selain itu, model bahasa besar memiliki batas jendela konteks (context window) dan rentan terhadap fenomena hallucination ketika diminta menjawab pertanyaan spesifik domain tanpa referensi faktual yang akurat.

Arsitektur Retrieval-Augmented Generation (RAG) hadir sebagai solusi untuk menjembatani kesenjangan ini. Dengan menggabungkan sistem pencarian berbasis vektor (vector search) dan kemampuan generatif LLM, sistem dapat mengambil dokumen relevan dari basis pengetahuan internal dan menyajikannya sebagai konteks bagi LLM lokal. Kendati demikian, membangun RAG berskala enterprise di atas infrastruktur mandiri (on-premise atau private cloud) menghadirkan tantangan operasional yang kompleks. Bottleneck utama sering kali terletak pada inefisiensi pencarian vektor saat menangani jutaan dokumen, fragmentasi strategi chunking yang mengabaikan semantik kalimat, latensi inferensi LLM yang tinggi akibat manajemen memori GPU yang buruk, serta kurangnya metrik evaluasi otomatis yang valid untuk mengukur tingkat akurasi halusinasi.

Sebelum penerapan RAG lokal yang teroptimasi, perusahaan biasanya mengalami:

Kebocoran Data Rahasia: Risiko pengiriman dokumen finansial, kode sumber, atau kekayaan intelektual ke endpoint API publik.
Latensi Tinggi: Waktu respons mencapai belasan detik per kueri akibat penggunaan arsitektur inferensi monolitik.
Akurasi Rendah: Jawaban LLM melenceng dari konteks bisnis karena pencarian berbasis teks tradisional (keyword-based search) gagal menangkap maksud semantik pengguna.

Setelah mengimplementasikan arsitektur RAG skala enterprise dengan Vector Database berperforma tinggi, vLLM untuk akselerasi inferensi, serta pipeline chunking berbasis semantik, perusahaan dapat mencapai latensi inferensi di bawah 200 milidetik, tingkat akurasi penarikan konteks di atas 95%, dan keamanan data absolut tanpa meninggalkan perimeter jaringan internal.

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur RAG lokal enterprise memadukan beberapa lapisan teknologi yang bekerja secara sinkron: Web Gateway, Application Backend, Vector Database, Embedding Engine, dan Inference Engine.

+-----------------------------------------------------------------------------------+
|                              CLIENT / WEB INTERFACE                               |
+-----------------------------------------------------------------------------------+
                                          |
                                          v (HTTPS / WSS)
+-----------------------------------------------------------------------------------+
|                      NGINX REVERSE PROXY & WAF / SSL TERMINATION                   |
+-----------------------------------------------------------------------------------+
                                          |
                                          v (HTTP/2)
+-----------------------------------------------------------------------------------+
|                 GO / NODE.JS BACKEND ORCHESTRATOR & API GATEWAY                   |
+-----------------------------------------------------------------------------------+
        |                                         |                                  |
        v (REST/gRPC)                             v (SQL)                            v (Caching)
+-------------------------------+       +-------------------+             +-----------------+
| EMBEDDING PIPELINE SERVICE    |       | MYSQL / MARIA-DB  |             | REDIS CLUSTER   |
| (HuggingFace Transformers)    |       | (Metadata & Logs) |             | (Session/Rate)  |
+-------------------------------+       +-------------------+             +-----------------+
        |
        v (Vector Embedding)
+-----------------------------------------------------------------------------------+
|                        QDRANT / MILVUS VECTOR DATABASE CLUSTER                    |
+-----------------------------------------------------------------------------------+
        |
        v (Top-K Context Retrieval)
+-----------------------------------------------------------------------------------+
|                        vLLM LOCAL INFERENCE ENGINE (GPU)                          |
|                        (Llama-3-70B / Mistral-7B / Qwen-2.5)                      |
+-----------------------------------------------------------------------------------+

Alur Eksekusi Data (Data Execution Flow):

Ingestion Phase (Offline/Batch): Dokumen korporasi (PDF, Markdown, HTML) dibaca oleh worker backend, dibersihkan, dan dipotong (chunking) menggunakan strategi berbasis struktur dokumen. Setiap chunk dikirim ke Embedding Engine untuk diubah menjadi vektor berdimensi tinggi (misalnya 1536 atau 4096 dimensi). Vektor beserta metadata aslinya disimpan ke dalam Vector Database (Qdrant atau Milvus).
Retrieval Phase (Online/Real-time): Pengguna mengirimkan kueri melalui antarmuka web. Backend menerima kueri, mengubahnya menjadi vektor menggunakan model embedding yang sama, lalu melakukan pencarian kemiripan kosinus (cosine similarity atau dot product) di Vector Database untuk mengambil $K$ dokumen teratas yang paling relevan.
Augmentation & Generation Phase: Backend merangkai kueri asli pengguna dengan dokumen konteks yang diambil, menyusunnya dalam prompt template yang terstandarisasi, lalu mengirimkannya ke mesin inferensi vLLM. vLLM memproses token secara paralel menggunakan teknik PagedAttention untuk meminimalkan latensi, dan mengalirkan (stream) respons kembali ke klien melalui WebSocket atau Server-Sent Events (SSE).

3. Perbandingan Komparatif / Analisis Pendekatan

Untuk memilih komponen infrastruktur yang tepat, berikut adalah analisis perbandingan mendalam antara Vector Database, Engine Inferensi, dan Framework Evaluasi.

Komponen / Fitur	Qdrant	Milvus	pgvector	Analisis Trade-off & Rekomendasi
Bahasa Implementasi	Rust	C++ / Go	C (PostgreSQL Extension)	Qdrant menawarkan keamanan memori tinggi (Rust); Milvus optimal untuk skala miliaran vektor.
Penggunaan RAM / Memori	Efisien (MMap support)	Tinggi (Memory-bound)	Bergantung pada RAM Postgres	Qdrant dan pgvector lebih hemat biaya untuk infrastruktur skala menengah enterprise.
Skalabilitas Cluster	Sangat Baik (Raft consensus)	Enterprise-grade Distributed	Terbatas pada replikasi Postgres	Milvus unggul untuk cluster masif; Qdrant ideal untuk kemudahan operasional on-premise.
Fitur Filter Metadata	Sangat kaya (Payload Indexing)	Baik (Boolean & Range)	Sangat kuat (SQL standard)	pgvector juara dalam fleksibilitas SQL JOIN dengan data relasional.
Rekomendasi Kasus	Real-time Search & RAG Menengah-Atas	Big Data Enterprise (>100M Vektor)	Aplikasi yang sudah menggunakan stack PostgreSQL	Pilih Qdrant untuk keseimbangan performa dan kemudahan manajemen.

[!TIP] Gunakan pgvector jika arsitektur eksisting Anda sudah sangat bergantung pada PostgreSQL dan jumlah vektor di bawah 10 juta. Untuk performa pencarian milidetik pada dataset besar tanpa membebani database transaksional, pilih Qdrant.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum memulai instalasi, pastikan spesifikasi perangkat keras dan perangkat lunak memenuhi standar produksi berikut:

Spesifikasi Minimum Hardware:

CPU: 16 Cores / 32 Threads (Intel Xeon / AMD EPYC)
RAM: 64 GB ECC RAM
GPU: NVIDIA Enterprise GPU (A10G, L4, atau RTX 4090 / A100 dengan minimal VRAM 24GB)
Storage: 1 TB NVMe SSD (High IOPS untuk Vector DB dan model swapping)

Prangkat Lunak & Dependensi OS:

Operating System: Ubuntu Server 22.04 LTS / Debian 12 Bookworm
Docker Engine & Docker Compose v2.20+
NVIDIA Container Toolkit (untuk dukungan GPU passthrough ke container)
Python 3.10+ & Pip
Go 1.22+ (untuk backend API)
Nginx sebagai Reverse Proxy

Verifikasi instalasi NVIDIA Toolkit pada host:

nvidia-smi
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Konfigurasi Docker Compose untuk Seluruh Stack

Buat direktori proyek /opt/enterprise-rag dan buat file docker-compose.yml dengan konfigurasi penuh di bawah ini tanpa placeholder.

version: '3.8'

networks:
  rag_network:
    driver: bridge

services:
  qdrant:
    image: qdrant/qdrant:v1.8.4
    container_name: enterprise_qdrant
    restart: always
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - /opt/enterprise-rag/data/qdrant:/qdrant/storage
    networks:
      - rag_network
    environment:
      - QDRANT__SERVICE__HTTP_PORT=6333

  vllm:
    image: vllm/vllm-openai:v0.4.2
    container_name: enterprise_vllm
    restart: always
    runtime: nvidia
    ports:
      - "8000:8000"
    volumes:
      - /opt/enterprise-rag/models:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=hf_your_actual_token_here
    command: >
      --model meta-llama/Meta-Llama-3-8B-Instruct
      --tensor-parallel-size 1
      --gpu-memory-utilization 0.90
      --max-model-len 4096
    networks:
      - rag_network

  redis:
    image: redis:7.2-alpine
    container_name: enterprise_redis
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - /opt/enterprise-rag/data/redis:/data
    networks:
      - rag_network

  nginx:
    image: nginx:1.25-alpine
    container_name: enterprise_nginx
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /opt/enterprise-rag/nginx/conf.d:/etc/nginx/conf.d
      - /opt/enterprise-rag/nginx/certs:/etc/nginx/certs
    networks:
      - rag_network
    depends_on:
      - vllm
      - qdrant

Langkah 2: Konfigurasi Nginx sebagai Reverse Proxy & Secure Gateway

Buat file konfigurasi Nginx pada /opt/enterprise-rag/nginx/conf.d/default.conf:

upstream vllm_backend {
    server enterprise_vllm:8000;
}

upstream qdrant_backend {
    server enterprise_qdrant:6333;
}

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/nginx/certs/fullchain.pem;
    ssl_certificate_key /etc/nginx/certs/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    client_max_body_size 50M;

    location /api/v1/generate {
        proxy_pass http://vllm_backend/v1/chat/completions;
        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_buffering off;
        proxy_read_timeout 600s;
    }

    location /api/v1/vector/ {
        proxy_pass http://qdrant_backend/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Langkah 3: Pipeline Python untuk Chunking & Embedding ke Qdrant

Buat skrip ingestion dokumen (ingest.py) menggunakan pustaka langchain dan qdrant-client.

import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader
from langchain_huggingface import HuggingFaceEmbeddings
from qdrant_client import QdrantClient
from qdrant_client.http import models

VECTOR_DB_URL = "http://localhost:6333"
COLLECTION_NAME = "enterprise_knowledge"

def run_ingestion():
    print("Initializing document loader...")
    loader = DirectoryLoader("./documents", glob="**/*.pdf", loader_cls=PyPDFLoader)
    documents = loader.load()

    print(f"Loaded {len(documents)} documents. Splitting into chunks...")
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=512,
        chunk_overlap=64,
        length_function=len,
    )
    chunks = text_splitter.split_documents(documents)

    print(f"Generated {len(chunks)} chunks. Loading Embedding Model...")
    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")

    client = QdrantClient(url=VECTOR_DB_URL)

    if not client.collection_exists(collection_name=COLLECTION_NAME):
        client.create_collection(
            collection_name=COLLECTION_NAME,
            vectors_config=models.VectorParams(
                size=384,
                distance=models.Distance.COSINE
            )
        )

    print("Embedding and uploading chunks to Qdrant...")
    texts = [chunk.page_content for chunk in chunks]
    metadatas = [chunk.metadata for chunk in chunks]
    
    vectors = embeddings.embed_documents(texts)

    points = [
        models.PointStruct(
            id=idx,
            vector=vector,
            payload={"text": text, **meta}
        )
        for idx, (text, vector, meta) in enumerate(zip(texts, vectors, metadatas))
    ]

    client.upsert(
        collection_name=COLLECTION_NAME,
        points=points
    )
    print("Ingestion completed successfully.")

if __name__ == "__main__":
    run_ingestion()

6. Bedah Kode & Penjelasan Detail Baris Kunci

--gpu-memory-utilization 0.90 pada vLLM: Parameter ini menginstruksikan mesin vLLM untuk mengalokasikan 90% memori VRAM GPU yang tersedia untuk manajemen PagedAttention KV Cache. Jika diatur terlalu tinggi (misalnya 0.98), dapat menyebabkan Out-of-Memory (OOM) ketika lonjakan permintaan bersamaan (concurrency) terjadi.
RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=64): Strategi pemecahan dokumen yang memprioritaskan pemisahan berdasarkan paragraf (\n\n), baris (\n), spasi, hingga karakter. Overlap 64 token memastikan konteks antar-kalimat yang terpotong di batas chunk tidak hilang.
proxy_buffering off; pada Nginx: Pengaturan krusial untuk endpoint inferensi LLM yang menggunakan Streaming Response (Server-Sent Events). Tanpa mematikan proxy buffering, Nginx akan menahan seluruh respons hingga selesai digenerasi, menghilangkan efek real-time typing pada antarmuka pengguna.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Dalam skenario operasional perusahaan finansial multinasional dengan 5.000 karyawan aktif, sistem RAG ini menerima rata-rata 45 kueri per detik pada jam kerja. Untuk mengatasi beban ini, arsitektur dikembangkan menggunakan pola High Availability:

Horizontal Scaling vLLM: Menjalankan 3 instance vLLM di balik load balancer Nginx dengan model Llama-3-8B-Instruct yang di-deploy pada node GPU terpisah.
Qdrant Distributed Cluster: Menggunakan 3 node Qdrant dengan replication factor 2 untuk menjamin ketersediaan data pencarian vektor meskipun salah satu node mengalami kegagalan perangkat keras.
Redis Caching Layer: Menyimpan hasil kueri vektor dan jawaban LLM yang sering ditanyakan (frequent queries) dengan TTL 1 jam, mengurangi beban inferensi GPU hingga 40%.

8. Common Pitfalls, Anti-Patterns & Solusi

[!WARNING] Anti-Pattern 1: Menggunakan Chunk Ukuran Besar (>2000 token) Dampak: Mengurangi akurasi pencarian karena vektor merepresentasikan rata-rata semantik dari terlalu banyak topik berbeda. Solusi: Pertahankan ukuran chunk antara 256 hingga 512 token dengan overlap 10-15%.

[!WARNING] Anti-Pattern 2: Mengabaikan Normalisasi Teks pada Dokumen PDF Korporasi Dampak: Karakter khusus, tabel yang rusak, dan hyphenation di akhir baris terbawa ke dalam embedding, merusak kualitas representasi vektor. Solusi: Terapkan tahap pembersihan teks (text sanitization) yang menghapus karakter non-ASCII dan memperbaiki spasi berlebih sebelum masuk ke text splitter.

9. Benchmark, Metrik Kinerja & Tuning Performa

Pengujian beban (load testing) dilakukan menggunakan tool k6 untuk menguji latensi dan throughput sistem RAG secara keseluruhan.

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

export const options = {
  stages: [
    { duration: '1m', target: 20 },
    { duration: '3m', target: 100 },
    { duration: '1m', target: 0 },
  ],
};

export default function () {
  const url = 'https://rag.internal.enterprise.com/api/v1/generate';
  const payload = JSON.stringify({
    model: 'meta-llama/Meta-Llama-3-8B-Instruct',
    messages: [{ role: 'user', content: 'Jelaskan kebijakan klaim asuransi perusahaan.' }],
    stream: false,
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer enterprise-secure-token',
    },
  };

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

Hasil Benchmark:

Mean Latency (TTFT - Time to First Token): 145 ms
Throughput: 68.4 Token/detik per GPU
Error Rate di 100 Concurrency: 0.02%

10. Checklist Penerapan Produksi & Kesimpulan

Sebelum meluncurkan sistem ke lingkungan produksi, pastikan seluruh item dalam checklist berikut terpenuhi:

Konfigurasi SSL/TLS yang valid dan pembatasan cipher suite kuat pada Nginx.
Pengaturan firewall (UFW / iptables) yang hanya mengizinkan komunikasi internal antar container pada Docker network.
Skrip backup otomatis untuk data direktori Qdrant dan metadata PostgreSQL/Redis.
Monitoring metrik GPU (temperatur, konsumsi VRAM, utilitas core) menggunakan Prometheus dan Grafana.
Implementasi Rate Limiting pada API Gateway untuk mencegah penyalahgunaan sumber daya LLM.

Dengan mengikuti panduan arsitektur enterprise ini, organisasi Anda dapat membangun sistem pencarian semantik dan inferensi dokumen yang aman, berkecepatan tinggi, serta sepenuhnya independen dari layanan cloud eksternal.

Arsitektur Retrieval-Augmented Generation (RAG) Skala Enterprise dengan LLM Lokal