Supabase pgvector: Panduan Lengkap Vector Database untuk AI Applications

Arsitektur Sistem

Semantic search bekerja dalam dua tahap utama: (1) indexing — mengubah konten menjadi embedding dan menyimpannya di database, dan (2) querying — mengubah query pengguna menjadi embedding lalu mencari vektor paling mirip di database.

Implementasi Backend dengan Node.js

import { createClient } from '@supabase/supabase-js';
import OpenAI from 'openai';

// Inisialisasi Supabase dan OpenAI
const supabase = createClient(
    process.env.SUPABASE_URL,
    process.env.SUPABASE_SERVICE_KEY
);
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Fungsi untuk membuat embedding dari teks
async function getEmbedding(text) {
    const response = await openai.embeddings.create({
        model: 'text-embedding-3-small',
        input: text
    });
    return response.data[0].embedding;
}

// Fungsi untuk menyimpan artikel dengan embedding
async function insertArticle(title, content, category) {
    const embedding = await getEmbedding(`${title}\n\n${content}`);
    
    const { data, error } = await supabase
        .from('articles')
        .insert({
            title,
            content,
            category,
            embedding: JSON.stringify(embedding)
        })
        .select();
    
    if (error) throw error;
    return data[0];
}

// Fungsi semantic search
async function semanticSearch(query, matchCount = 5, matchThreshold = 0.5) {
    const queryEmbedding = await getEmbedding(query);
    
    const { data, error } = await supabase.rpc('match_articles', {
        query_embedding: JSON.stringify(queryEmbedding),
        match_count: matchCount,
        match_threshold: matchThreshold
    });
    
    if (error) throw error;
    return data;
}

Stored Procedure untuk Pencarian

Untuk performa optimal, kita buat stored procedure di Supabase yang menjalankan pencarian vektor:

-- Fungsi untuk pencarian artikel berdasarkan similarity
CREATE OR REPLACE FUNCTION match_articles(
    query_embedding VECTOR(1536),
    match_count INT DEFAULT 5,
    match_threshold FLOAT DEFAULT 0.5
)
RETURNS TABLE (
    id BIGINT,
    title TEXT,
    content TEXT,
    category TEXT,
    similarity FLOAT
)
LANGUAGE plpgsql
AS $$
BEGIN
    RETURN QUERY
    SELECT
        a.id,
        a.title,
        LEFT(a.content, 500) AS content,
        a.category,
        1 - (a.embedding <=> query_embedding) AS similarity
    FROM articles a
    WHERE 1 - (a.embedding <=> query_embedding) > match_threshold
    ORDER BY a.embedding <=> query_embedding
    LIMIT match_count;
END;
$$;

Fungsi match_articles menerima vektor query, jumlah hasil yang diinginkan, dan threshold kemiripan minimum. Operator <=> adalah cosine distance operator dari pgvector — semakin kecil nilainya, semakin mirip kedua vektor. Kita mengurangkan dari 1 untuk mengonversi ke cosine similarity (semakin besar = semakin mirip).

Penggunaan dalam Praktik

// Contoh penggunaan
async function main() {
    // Cari artikel yang relevan dengan pertanyaan pengguna
    const results = await semanticSearch(
        'Bagaimana cara mengoptimalkan performa database PostgreSQL?',
        3,
        0.6
    );
    
    console.log('Hasil pencarian:');
    results.forEach((article, i) => {
        console.log(`${i + 1}. ${article.title} (skor: ${article.similarity.toFixed(4)})`);
    });
}

main();

Keunggulan pendekatan ini adalah pencarian dapat menemukan artikel yang relevan meskipun kata kunci yang digunakan berbeda. Misalnya, query "meningkatkan kecepatan query di basis data relasional" tetap akan menemukan artikel tentang optimasi PostgreSQL meskipun tidak ada kata kunci yang identik.

Contoh Implementasi: RAG (Retrieval-Augmented Generation)

RAG (Retrieval-Augmented Generation) adalah teknik yang menggabungkan pencarian informasi dari database dengan kemampuan generasi teks dari Large Language Model (LLM). Dengan RAG, model AI tidak hanya mengandalkan data training-nya, tetapi juga dapat mengambil informasi terkini dan spesifik dari basis pengetahuan Anda.

Bagaimana RAG Bekerja

Alur kerja RAG terdiri dari tiga tahap utama:

1. Retrieval — Mencari dokumen relevan dari vector database berdasarkan query pengguna
2. Augmentation — Menambahkan konteks dari dokumen yang ditemukan ke dalam prompt LLM
3. Generation — LLM menghasilkan jawaban berdasarkan kombinasi query dan konteks yang diberikan

Implementasi RAG Lengkap

import { createClient } from '@supabase/supabase-js';
import OpenAI from 'openai';

const supabase = createClient(
    process.env.SUPABASE_URL,
    process.env.SUPABASE_SERVICE_KEY
);
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Langkah 1: Ingest dokumen ke dalam database
async function ingestDocument(title, content, source) {
    // Bagi konten menjadi chunk (potongan kecil)
    const chunks = splitIntoChunks(content, 500, 50);
    
    for (const chunk of chunks) {
        const embedding = await getEmbedding(chunk);
        
        await supabase.from('documents').insert({
            title,
            content: chunk,
            source,
            embedding: JSON.stringify(embedding),
            metadata: { chunk_size: chunk.length }
        });
    }
}

// Fungsi splitting teks menjadi chunk
function splitIntoChunks(text, chunkSize = 500, overlap = 50) {
    const words = text.split(' ');
    const chunks = [];
    
    for (let i = 0; i < words.length; i += chunkSize - overlap) {
        chunks.push(words.slice(i, i + chunkSize).join(' '));
    }
    return chunks;
}

// Langkah 2: Retrieval — mencari konteks relevan
async function retrieveContext(query, topK = 3) {
    const queryEmbedding = await getEmbedding(query);
    
    const { data, error } = await supabase.rpc('match_documents', {
        query_embedding: JSON.stringify(queryEmbedding),
        match_count: topK,
        match_threshold: 0.5
    });
    
    if (error) throw error;
    return data.map(doc => doc.content).join('\n\n---\n\n');
}

// Langkah 3: Generation — menghasilkan jawaban dengan RAG
async function ragQuery(userQuestion) {
    // Ambil konteks relevan dari database
    const context = await retrieveContext(userQuestion);
    
    // Buat prompt dengan konteks
    const systemPrompt = `Anda adalah asisten AI yang membantu menjawab pertanyaan.
Jawab berdasarkan konteks yang diberikan di bawah. Jika informasi tidak ada 
dalam konteks, katakan bahwa Anda tidak memiliki informasi yang cukup.

KONTEKS:
${context}`;

    // Kirim ke LLM
    const response = await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [
            { role: 'system', content: systemPrompt },
            { role: 'user', content: userQuestion }
        ],
        temperature: 0.3,
        max_tokens: 1000
    });
    
    return {
        answer: response.choices[0].message.content,
        sources: context.substring(0, 200) + '...'
    };
}

// Contoh penggunaan
async function main() {
    const result = await ragQuery('Apa itu pgvector dan bagaimana cara menggunakannya?');
    console.log('Jawaban:', result.answer);
}

Implementasi RAG dengan pgvector memberikan beberapa keunggulan penting: jawaban LLM menjadi lebih akurat karena didasarkan pada data nyata, mengurangi hallucination (kecenderungan LLM mengarang informasi), dan memungkinkan penggunaan data yang selalu terkini tanpa perlu fine-tuning ulang model.

Pertimbangan Penting untuk RAG

• Chunking Strategy — Cara membagi dokumen menjadi potongan-potongan kecil sangat mempengaruhi kualitas hasil. Chunk yang terlalu besar mengurangi presisi, sementara chunk yang terlalu kecil kehilangan konteks.
• Metadata enrichment — Menyimpan metadata seperti judul, sumber, dan timestamp membantu LLM memberikan jawaban yang lebih terkonteks.
• Reranking — Menggunakan model reranker untuk menilai ulang hasil pencarian dapat meningkatkan kualitas konteks yang dikirim ke LLM.

Perbandingan: pgvector vs Pinecone vs Weaviate vs Qdrant

Memilih vector database yang tepat adalah keputusan penting dalam arsitektur aplikasi AI. Berikut adalah perbandingan komprehensif antara pgvector dan tiga vector database populer lainnya:

Kapan Harus Memilih pgvector?

pgvector adalah pilihan yang tepat ketika Anda menginginkan solusi yang terintegrasi — menyimpan data relasional dan vektor dalam satu database. Ini sangat ideal untuk aplikasi yang membutuhkan JOIN antara data vektor dengan data lainnya, seperti mencari artikel dengan filter kategori atau pengguna tertentu. Untuk aplikasi skala startup hingga menengah, pgvector dengan Supabase menawarkan rasio fitur-per-biaya yang sulit dikalahkan.

Kapan Harus Memilih Alternatif?

Pinecone menjadi pilihan yang baik ketika Anda membutuhkan managed service tanpa perlu khawatir tentang infrastruktur, terutama untuk tim kecil yang fokus pada produk. Weaviate menonjol untuk use case multimodal — mencari berdasarkan teks, gambar, dan tipe data lainnya secara bersamaan. Qdrant menjadi pilihan untuk workload yang membutuhkan filtering vektor yang sangat kompleks dan performa ultra-tinggi di skala miliaran vektor.

Best Practices dan Optimasi Performa

Untuk memanfaatkan pgvector secara maksimal dalam aplikasi AI produksi, ada beberapa best practices dan teknik optimasi yang perlu diterapkan:

Optimasi Indeks

Pemilihan indeks dan parameter yang tepat adalah faktor terpenting dalam performa pgvector:

• Gunakan HNSW untuk read-heavy workload — HNSW memberikan keseimbangan terbaik antara kecepatan pencarian dan kualitas hasil. Gunakan m=16 hingga m=32 dan ef_construction=200.
• Gunakan IVFFlat untuk write-heavy workload — Jika aplikasi Anda sering menambahkan vektor baru, IVFFlat lebih mudah di-maintain.
• Rebuild indeks secara berkala — Setelah penambahan data yang signifikan (lebih dari 30% dari total data), rebuild indeks untuk menjaga kualitas pencarian.

-- Rebuild indeks HNSW setelah penambahan data massal
REINDEX INDEX articles_embedding_idx;

-- Atau drop dan buat ulang untuk hasil yang lebih optimal
DROP INDEX IF EXISTS articles_embedding_idx;
CREATE INDEX articles_embedding_idx ON articles 
    USING hnsw (embedding vector_cosine_ops)
    WITH (m = 16, ef_construction = 200);

Pengaturan Parameter Pencarian

Parameter ef_search mengontrol akurasi vs kecepatan pencarian. Semakin tinggi nilainya, semakin akurat hasilnya namun semakin lambat:

-- Mengatur ef_search untuk keseimbangan akurasi-kecepatan
SET hnsw.ef_search = 100;  -- Default: 40, naikkan untuk akurasi lebih tinggi

-- Untuk query yang membutuhkan presisi tinggi
SET hnsw.ef_search = 200;

-- Untuk query cepat dengan toleransi akurasi lebih rendah
SET hnsw.ef_search = 20;

Optimasi Penyimpanan

• Gunakan dimensi embedding yang tepat — Model seperti text-embedding-3-small dari OpenAI mendukung dimensionality reduction (dari 1536 ke 512 atau 256) dengan dampak minimal pada kualitas. Ini mengurangi ukuran penyimpanan hingga 6x.
• Kompresi data — Aktifkan kompresi pada kolom teks untuk menghemat storage, terutama untuk dataset besar.
• Partisi tabel — Untuk dataset sangat besar (100 juta+ baris), pertimbangkan table partitioning untuk meningkatkan query performance.

Pooling Koneksi

Dalam produksi, gunakan connection pooling untuk mengelola koneksi database secara efisien. Supabase menyediakan PgBouncer yang sudah terintegrasi, atau Anda dapat menggunakan tools seperti pgbouncer atau pgpool-II:

// Menggunakan connection pooling dengan Supabase
// Gunakan port 6543 untuk pooler connection
const supabase = createClient(
    'https://your-project.supabase.co',
    'your-anon-key',
    {
        db: {
            schema: 'public'
        },
        global: {
            headers: { 'x-my-custom-header': 'my-app-name' }
        }
    }
);

Batch Processing untuk Embedding

Ketika mengindeks banyak dokumen, gunakan batch processing untuk menghemat waktu dan biaya API:

// Batch embedding — lebih efisien daripada per-dokumen
async function batchEmbed(texts) {
    const response = await openai.embeddings.create({
        model: 'text-embedding-3-small',
        input: texts  // Array hingga 2048 teks sekaligus
    });
    
    return response.data.map(item => item.embedding);
}

// Contoh penggunaan untuk indexing massal
async function bulkIndex(documents) {
    const batchSize = 100;
    
    for (let i = 0; i < documents.length; i += batchSize) {
        const batch = documents.slice(i, i + batchSize);
        const texts = batch.map(doc => `${doc.title}\n${doc.content}`);
        const embeddings = await batchEmbed(texts);
        
        const rows = batch.map((doc, idx) => ({
            ...doc,
            embedding: JSON.stringify(embeddings[idx])
        }));
        
        await supabase.from('articles').insert(rows);
        
        console.log(`Indexed ${Math.min(i + batchSize, documents.length)}/${documents.length}`);
    }
}

Use Cases: AI Applications yang Menggunakan pgvector

pgvector dan vector database secara umum telah menjadi fondasi untuk berbagai jenis aplikasi AI yang inovatif. Berikut adalah use cases utama yang banyak diadopsi oleh developer dan perusahaan:

1. Semantic Search Engine

Pencarian berbasis makna yang memungkinkan pengguna menemukan informasi dengan menggunakan bahasa alami, bukan kata kunci persis. Ini digunakan dalam portal knowledge base perusahaan, e-commerce untuk pencarian produk, dan platform dokumentasi teknis.

2. RAG untuk Chatbot dan Asisten AI

Membangun chatbot yang dapat menjawab pertanyaan berdasarkan dokumen internal perusahaan. Dengan pgvector sebagai backbone, chatbot dapat mengambil informasi dari ribuan dokumen dan menghasilkan jawaban yang akurat dan terkonteks. Ini adalah use case yang paling banyak diadopsi saat ini.

3. Rekomendasi Content

Sistem rekomendasi yang menyarankan artikel, video, atau produk berdasarkan kemiripan konten. Berbeda dengan collaborative filtering yang bergantung pada perilaku pengguna, pendekatan berbasis embedding dapat memberikan rekomendasi bahkan untuk konten baru tanpa data interaksi.

4. Deduplication dan Anomaly Detection

Mendeteksi konten duplikat atau anomali dengan membandingkan embedding dokumen baru terhadap yang sudah ada. Berguna untuk moderasi konten, deteksi plagiarisme, dan identifikasi data yang tidak konsisten.

5. Multimodal Search

Mencari berbagai tipe data (teks, gambar, kode) dalam satu kueri. Dengan model embedding multimodal seperti CLIP, gambar dan teks dapat direpresentasikan dalam ruang vektor yang sama, memungkinkan pencarian seperti "temukan gambar yang sesuai dengan deskripsi ini."

6. Code Search dan Documentation

Developer tools modern menggunakan vector search untuk menemukan kode, dokumentasi, atau issue yang relevan dengan masalah yang sedang dihadapi. GitHub Copilot dan berbagai AI coding assistant memanfaatkan pendekatan ini.

7. Personalisasi Konten

Menyimpan representasi vektor dari preferensi pengguna dan mencocokkannya dengan konten yang tersedia. Sistem dapat menyarankan konten yang secara semantik selaras dengan minat pengguna, menghasilkan pengalaman yang lebih personal dan relevan.

Kombinasi dengan Teknologi Lain

pgvector menjadi semakin powerful ketika dikombinasikan dengan teknologi lain dalam ekosistem AI modern. Misalnya, dikombinasikan dengan Redis untuk caching query yang sering dijalankan (baca lebih lanjut di Redis Caching Patterns untuk Web Apps Skala Besar), atau diintegrasikan ke dalam sistem AI Agents yang membutuhkan memori jangka panjang untuk menyimpan dan mengambil pengalaman sebelumnya (baca di AI Agents: Panduan Lengkap Sistem Kecerdasan Otonom 2026).

Kombinasi pgvector dengan arsitektur agen AI memungkinkan pembuatan sistem yang benar-benar cerdas — mampu mengingat konteks percakapan sebelumnya, belajar dari interaksi masa lalu, dan memberikan respons yang semakin personal seiring waktu.

Pertanyaan yang Sering Diajukan (FAQ)

1. Apakah pgvector bisa menangani jutaan vektor?

Ya, pgvector dirancang untuk menangani dataset besar. Dengan indeks HNSW yang dioptimasi, pgvector dapat melakukan pencarian pada jutaan vektor dalam hitungan milidetik. Beberapa pengguna melaporkan performa yang baik hingga ratusan juta vektor. Kunci utamanya adalah memilih parameter indeks yang tepat (m, ef_construction, ef_search) sesuai dengan ukuran dataset dan kebutuhan aplikasi Anda.

2. Berapa biaya menggunakan pgvector di Supabase?

pgvector adalah ekstensi open-source yang gratis. Di Supabase, Anda dapat menggunakannya pada plan Free Tier yang mencakup 500 MB database, 1 GB storage, dan 50.000 rows aktif per bulan. Untuk proyek produksi, plan Pro mulai dari $25/bulan memberikan lebih banyak resource. Karena pgvector berjalan di PostgreSQL standar, tidak ada biaya tambahan khusus untuk fitur vector database.

3. Bagaimana pgvector dibandingkan dengan Pinecone dari segi performa?

Pada dataset berukuran kecil hingga menengah (hingga beberapa juta vektor), performa pgvector dan Pinecone cukup sebanding. Pinecone mungkin memiliki keunggulan pada skala sangat besar (miliaran vektor) karena arsitektur managed service-nya yang dioptimasi. Namun, pgvector menawarkan keunggulan dalam hal integrasi — Anda bisa melakukan JOIN dengan data relasional dan menjalankan query SQL kompleks tanpa perlu query terpisah ke layanan berbeda.

4. Model embedding mana yang kompatibel dengan pgvector?

pgvector kompatibel dengan semua model embedding yang menghasilkan output berupa array angka. Ini termasuk model dari OpenAI (text-embedding-3-small, text-embedding-3-large), Cohere (embed-english-v3.0), model open-source dari Hugging Face (sentence-transformers, BAAI/bge-large), dan model lainnya. Yang terpenting adalah memastikan dimensi vektor sesuai dengan deklarasi kolom VECTOR(n) di tabel Anda.

5. Bagaimana cara mengoptimalkan pgvector untuk produksi?

Untuk optimasi produksi, terapkan strategi berikut: gunakan indeks HNSW dengan parameter yang sesuai, aktifkan connection pooling untuk mengelola koneksi, gunakan batch processing untuk operasi embedding massal, pertimbangkan caching untuk query yang sering dijalankan, monitor performa indeks dengan EXPLAIN ANALYZE, dan re-build indeks secara berkala setelah penambahan data yang signifikan. Selain itu, pertimbangkan untuk menggunakan dimensionality reduction pada embedding untuk mengurangi ukuran penyimpanan dan mempercepat pencarian.