Bagian III - Bab 12

Vector Database dan Semantic Search

Keterbatasan brute-force search, cara kerja HNSW, implementasi Pinecone dan FAISS, serta hybrid search.

12.1 Keterbatasan Pencarian Brute-Force

Di Bab 9, kita menghitung cosine similarity antara query dan setiap dokumen dalam corpus secara langsung. Pendekatan ini disebut exact nearest neighbor search atau brute-force, dan ia bekerja dengan baik untuk corpus kecil.

Masalahnya muncul saat skala bertambah. Jika corpus memiliki 1 juta dokumen dengan embedding 768 dimensi, setiap query membutuhkan 1 juta perhitungan cosine similarity. Ini tidak bisa berjalan dalam hitungan milidetik yang dibutuhkan aplikasi produksi.

Vector database menyelesaikan masalah ini dengan teknik yang disebut Approximate Nearest Neighbor (ANN), yang menukar sedikit akurasi dengan kecepatan pencarian yang jauh lebih tinggi.

12.2 Cara Kerja HNSW

Algoritma ANN yang paling umum digunakan di vector database modern adalah HNSW (Hierarchical Navigable Small World). HNSW membangun sebuah graf berlapis dari semua vektor yang diindeks. Setiap vektor terhubung ke beberapa tetangga terdekatnya. Lapisan paling atas berisi sedikit vektor dengan koneksi jarak jauh (seperti jalan tol), lapisan bawah berisi semua vektor dengan koneksi jarak pendek (seperti jalan lokal).

Saat query masuk, pencarian dimulai dari lapisan teratas, melompat jauh untuk menemukan wilayah yang mendekati. Lalu turun ke lapisan yang lebih detail untuk menemukan tetangga terdekat yang presisi. Ini jauh lebih efisien dari membandingkan query dengan setiap vektor satu per satu.

12.3 Proses Indexing dan Query

Ada dua fase dalam penggunaan vector database yang perlu dipahami secara terpisah.

12.4 Implementasi dengan Pinecone

Pinecone adalah vector database cloud yang paling umum digunakan dalam ekosistem AI Engineering saat ini. Ia menangani semua kompleksitas HNSW di balik layar, kamu hanya perlu fokus pada indexing dan querying.

Setup dan Inisialisasi

Setup koneksi ke Pinecone dan inisialisasi index. Dimensi harus sesuai dengan model embedding yang digunakan, mismatch akan menyebabkan error saat indexing.

# pip install pinecone-client sentence-transformers
import os
from pinecone import Pinecone, ServerlessSpec
from sentence_transformers import SentenceTransformer
from dotenv import load_dotenv

load_dotenv()

# Inisialisasi Pinecone client
pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))

# Nama index dan dimensi embedding
INDEX_NAME = "handbook-rag"
DIMENSION = 384  # sesuai multilingual-MiniLM-L12-v2

# Buat index jika belum ada
if INDEX_NAME not in pc.list_indexes().names():
    pc.create_index(
        name=INDEX_NAME,
        dimension=DIMENSION,
        metric="cosine",  # gunakan cosine similarity
        spec=ServerlessSpec(cloud="aws", region="us-east-1")
    )
    print(f"Index '{INDEX_NAME}' berhasil dibuat")

# Sambungkan ke index
index = pc.Index(INDEX_NAME)

# Load model embedding
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

print(f"Siap: {index.describe_index_stats()}")

Indexing Dokumen

Proses indexing: ubah teks menjadi embedding lalu simpan ke Pinecone. Metadata disimpan bersama vektor agar bisa digunakan untuk filtering dan untuk menampilkan teks asli ke pengguna.

def index_dokumen(dokumen: list[dict], batch_size: int = 100) -> None:
    """
    Index kumpulan dokumen ke Pinecone.

    Args:
        dokumen: list of {"id": str, "teks": str, "metadata": dict}
        batch_size: jumlah dokumen per batch (max 100 untuk Pinecone)
    """
    print(f"Mengindeks {len(dokumen)} dokumen...")

    for i in range(0, len(dokumen), batch_size):
        batch = dokumen[i:i + batch_size]

        # Buat embedding untuk seluruh batch sekaligus
        teks_batch = [d["teks"] for d in batch]
        embeddings = model.encode(teks_batch).tolist()

        # Format yang dibutuhkan Pinecone: list of (id, vektor, metadata)
        vectors = [
            (
                d["id"],
                embeddings[j],
                {"teks": d["teks"], **d.get("metadata", {})}
            )
            for j, d in enumerate(batch)
        ]

        index.upsert(vectors=vectors)
        print(f"Batch {i//batch_size + 1}: {len(batch)} dokumen diindeks")

    print("Indexing selesai")

# Contoh penggunaan
dokumen_contoh = [
    {
        "id": "doc-001",
        "teks": "Kebijakan pengembalian barang berlaku 30 hari setelah pembelian.",
        "metadata": {"sumber": "kebijakan.pdf", "halaman": 3}
    },
    {
        "id": "doc-002",
        "teks": "Pengiriman gratis untuk pembelian di atas Rp 200.000.",
        "metadata": {"sumber": "kebijakan.pdf", "halaman": 5}
    },
]
index_dokumen(dokumen_contoh)

Querying dan Filter

Querying: ubah pertanyaan pengguna menjadi embedding lalu cari chunk yang paling relevan. Metadata filter memungkinkan pencarian hanya pada subset dokumen tertentu.

def cari_dokumen(
    query: str,
    top_k: int = 3,
    filter_metadata: dict = None
) -> list[dict]:
    """
    Cari chunk paling relevan untuk query.

    Args:
        query: pertanyaan pengguna
        top_k: jumlah hasil yang dikembalikan
        filter_metadata: filter opsional, misal {"sumber": "kebijakan.pdf"}
    """
    # Embedding query menggunakan model yang SAMA dengan saat indexing
    embedding_query = model.encode(query).tolist()

    # Query ke Pinecone
    hasil = index.query(
        vector=embedding_query,
        top_k=top_k,
        include_metadata=True,  # sertakan teks asli
        filter=filter_metadata  # None = cari semua
    )

    # Format hasil menjadi list yang mudah digunakan
    dokumen_relevan = []
    for match in hasil["matches"]:
        if match["score"] > 0.5:  # threshold minimum relevansi
            dokumen_relevan.append({
                "id": match["id"],
                "teks": match["metadata"]["teks"],
                "skor": round(match["score"], 3),
                "sumber": match["metadata"].get("sumber", "unknown")
            })

    return dokumen_relevan

# Test pencarian
hasil = cari_dokumen("Bagaimana cara mengembalikan barang?")
for d in hasil:
    print(f"[{d['skor']}] {d['teks']}")

# Pencarian dengan filter metadata
hasil_filter = cari_dokumen(
    query="kebijakan pengiriman",
    filter_metadata={"sumber": "kebijakan.pdf"}
)

12.5 FAISS vs Pinecone: Kapan Menggunakan Masing-Masing

Aspek	FAISS (Meta, open-source)	Pinecone (cloud managed)
Deployment	Berjalan di memori lokal atau server sendiri, tidak butuh internet saat query	Layanan cloud dikelola sepenuhnya, butuh koneksi internet dan API Key
Biaya	Gratis, open-source. Biaya hanya dari infrastruktur server	Ada free tier terbatas. Paid tier untuk skala produksi
Skalabilitas	Terbatas oleh RAM server, perlu di-rebuild saat data bertambah signifikan	Skala otomatis, bisa menampung miliaran vektor
Persistensi data	Index disimpan sebagai file lokal, perlu manajemen backup sendiri	Data tersimpan di cloud secara persisten
Metadata filtering	Tidak ada dukungan native, perlu filter manual setelah retrieval	Dukungan filter metadata yang kaya dan efisien
Privasi data	Data tidak keluar dari infrastrukturmu, ideal untuk data sensitif	Data dikirim ke cloud pihak ketiga
Kapan menggunakan	Prototyping lokal, data sensitif, skala kecil (<500k vektor)	Produksi, tim yang tidak ingin kelola infrastruktur, skala besar (>500k vektor)

Berikut implementasi FAISS sebagai alternatif lokal dari Pinecone, kodenya hampir identik dari sisi penggunaan, tapi berjalan sepenuhnya di mesin kamu sendiri.

# pip install faiss-cpu sentence-transformers numpy
import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")
DIMENSION = 384

# Buat index FAISS dengan cosine similarity (Inner Product setelah normalisasi)
index = faiss.IndexFlatIP(DIMENSION)

# Simpan teks asli secara terpisah, FAISS hanya menyimpan vektor
teks_tersimpan = []

def index_dokumen_faiss(dokumen: list[str]) -> None:
    """Tambahkan dokumen ke FAISS index."""
    embeddings = model.encode(dokumen, normalize_embeddings=True)
    index.add(embeddings.astype(np.float32))
    teks_tersimpan.extend(dokumen)
    print(f"{len(dokumen)} dokumen diindeks. Total: {index.ntotal}")

def cari_faiss(query: str, top_k: int = 3) -> list[dict]:
    """Cari dokumen paling relevan menggunakan FAISS."""
    embedding_query = model.encode([query], normalize_embeddings=True)
    skor, indeks = index.search(embedding_query.astype(np.float32), top_k)

    hasil = []
    for skor_val, idx in zip(skor[0], indeks[0]):
        if idx != -1 and skor_val > 0.5:
            hasil.append({
                "teks": teks_tersimpan[idx],
                "skor": round(float(skor_val), 3)
            })
    return hasil

# Simpan dan muat index dari disk
def simpan_index(path: str) -> None:
    faiss.write_index(index, path)
    print(f"Index disimpan ke {path}")

def muat_index(path: str) -> None:
    global index
    index = faiss.read_index(path)
    print(f"Index dimuat dari {path}: {index.ntotal} vektor")

# Contoh penggunaan
dokumen = [
    "Kebijakan pengembalian barang berlaku 30 hari setelah pembelian.",
    "Pengiriman gratis untuk pembelian di atas Rp 200.000.",
    "Layanan pelanggan tersedia setiap hari pukul 08.00 - 22.00.",
]
index_dokumen_faiss(dokumen)

hasil = cari_faiss("Bagaimana cara mengembalikan produk?")
for h in hasil:
    print(f"[{h['skor']}] {h['teks']}")

12.6 Keyword Search vs Semantic Search vs Hybrid Search

Tidak semua jenis query terlayani dengan baik oleh semantic search saja.

Keyword search (seperti Elasticsearch atau BM25) mencari berdasarkan kecocokan kata yang tepat. Semantic search unggul untuk query berbasis makna, pertanyaan dengan redaksi berbeda tapi maksud sama. Hybrid search menggabungkan keduanya, mengambil hasil dari kedua pendekatan lalu menggabungkan skornya. Ini adalah pendekatan yang direkomendasikan untuk sistem produksi.

Kesalahan Umum

Ringkasan Bab 12