0Pricing
AI Engineering Academy · Pelajaran

Memilih dan Mengukur Kinerja Penyimpanan Vektor

Bandingkan Pinecone, pgvector, Chroma, Weaviate, dan Qdrant berdasarkan biaya, latensi, kemampuan penyaringan, dan kompleksitas operasional untuk memilih alat yang tepat bagi kasus penggunaan Anda.

Memilih dan Mengukur Kinerja Penyimpanan Vektor adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Lanskap Penyimpanan Vektor

Ekosistem basis data vektor berkembang pesat dalam beberapa tahun terakhir. Pilihannya mencakup layanan cloud yang dirancang khusus seperti Pinecone, ekstensi PostgreSQL seperti pgvector, server sumber terbuka seperti Chroma, Qdrant, dan Weaviate, serta pustaka dalam memori seperti FAISS. Memilih alat yang tepat penting karena beralih di kemudian hari akan mahal setelah data Anda diindeks.

Dimensi Utama untuk Dievaluasi

Saat membandingkan penyimpanan vektor, evaluasilah lima dimensi: latensi kueri pada skala target Anda, throughput pengindeksan untuk penyisipan secara batch, kemampuan pemfilteran untuk prapemfilteran berbasis metadata, kompleksitas operasional (terkelola atau dihosting sendiri), serta biaya per satu juta vektor yang disimpan dan diku eri. Tidak ada satu alat yang unggul dalam setiap dimensi.

Pinecone: Kesederhanaan Terkelola

Pinecone adalah basis data vektor cloud yang sepenuhnya terkelola dan tidak memerlukan pengelolaan infrastruktur. Layanan ini unggul untuk beban kerja dengan konkurensi tinggi, menawarkan pencarian hibrida renggang-padat secara bawaan, serta menyediakan kueri konsisten dalam hitungan satu digit milidetik pada skala apa pun. Kekurangannya adalah biaya: layanan ini lebih mahal daripada opsi yang dihosting sendiri dan menimbulkan ketergantungan pada vendor karena semua data berada di cloud Pinecone.

import pinecone

pc = pinecone.Pinecone(api_key='YOUR_API_KEY')
index = pc.Index('my-index')

# Query with metadata filter
results = index.query(
    vector=[0.1, 0.2, 0.3],
    top_k=10,
    filter={'category': {'$eq': 'finance'}},
    include_metadata=True
)

pgvector: Embedding di PostgreSQL

pgvector memperluas PostgreSQL dengan jenis data vector dan indeks approximate nearest neighbor (ANN) menggunakan algoritme HNSW atau IVFFlat. Ini ideal jika Anda sudah menjalankan PostgreSQL karena embedding Anda berada di basis data yang sama dengan data relasional, sehingga memungkinkan penggabungan SQL antara pencarian vektor dan filter terstruktur tanpa infrastruktur tambahan.

-- Create table with embedding column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    category TEXT,
    embedding vector(1536)
);

-- Create HNSW index for fast ANN search
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Query nearest neighbors with SQL filter
SELECT content, 1 - (embedding <=> '[0.1,0.2,...]')
FROM documents
WHERE category = 'finance'
ORDER BY embedding <=> '[0.1,0.2,...]'
LIMIT 10;

Chroma: Ramah Pengembang dan Berbasis Lokal

Chroma adalah basis data embedding sumber terbuka yang dirancang untuk pembuatan prototipe cepat. Chroma berjalan di dalam proses untuk pengembangan lokal (tidak memerlukan server) dan mendukung mode server persisten untuk produksi. Chroma populer dalam tutorial LangChain karena API-nya yang sangat sederhana, tetapi memiliki keterbatasan pada skala besar: tidak ada mode terdistribusi dan pemfilterannya lebih lemah daripada Pinecone atau Qdrant.

import chromadb

client = chromadb.PersistentClient(path='./chroma_db')
collection = client.get_or_create_collection('my_docs')

# Add documents
collection.add(
    documents=['text one', 'text two'],
    metadatas=[{'source': 'doc1'}, {'source': 'doc2'}],
    ids=['id1', 'id2']
)

# Query
results = collection.query(
    query_texts=['search query'],
    n_results=5
)

Qdrant: Pemfilteran dan Pencarian Muatan

Qdrant adalah basis data vektor sumber terbuka yang ditulis dalam Rust dan unggul dalam pemfilteran metadata yang kompleks. Berbeda dari basis data yang menerapkan filter setelah pencarian ANN, Qdrant melakukan prapemfilteran vektor kandidat berdasarkan field muatan sebelum pemberian skor, sehingga meningkatkan presisi secara drastis ketika filter bersifat selektif. Qdrant mendukung indeks HNSW pada disk, sehingga cocok untuk himpunan data yang tidak dapat dimuat ke dalam RAM.

from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue

client = QdrantClient(url='http://localhost:6333')

# Search with payload filter
results = client.search(
    collection_name='documents',
    query_vector=[0.1, 0.2, 0.3],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='category',
                match=MatchValue(value='finance')
            )
        ]
    ),
    limit=10
)

Weaviate: GraphQL dan Multimodal

Weaviate adalah basis data vektor sumber terbuka dengan API GraphQL yang unik serta dukungan bawaan untuk objek multimodal (teks, gambar, audio). Weaviate terintegrasi langsung dengan penyedia model embedding melalui modul, sehingga Anda dapat menyisipkan teks mentah dan membiarkan Weaviate memanggil API embedding secara otomatis. Kemudahan ini harus dibayar dengan penyiapan yang lebih kompleks dibandingkan Chroma atau Qdrant.

import weaviate

client = weaviate.Client('http://localhost:8080')

# Near-text search using built-in vectorizer
result = client.query.get(
    'Document', ['content', 'category']
).with_near_text(
    {'concepts': ['financial analysis']}
).with_where({
    'path': ['category'],
    'operator': 'Equal',
    'valueString': 'finance'
}).with_limit(10).do()

FAISS: Dalam Memori pada Skala Besar

FAISS (Facebook AI Similarity Search) adalah pustaka C++ dengan binding Python yang menyediakan pencarian vektor dalam memori dengan kecepatan sangat tinggi. FAISS bukan basis data (tidak memiliki persistensi atau server), tetapi mampu menangani pencarian kemiripan berskala miliaran pada satu mesin dengan akselerasi GPU. FAISS merupakan pilihan tepat untuk beban kerja pencarian batch luring yang banyak membaca dan seluruh tumpukannya Anda kendalikan.

import faiss
import numpy as np

dimension = 1536
vectors = np.random.random((100000, dimension)).astype('float32')

# Normalize for cosine similarity
faiss.normalize_L2(vectors)

# Build HNSW index
index = faiss.IndexHNSWFlat(dimension, 32)  # M=32 neighbors
index.add(vectors)

# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
D, I = index.search(query, k=10)  # top-10 results

Membangun Pengujian Tolok Ukur

Satu-satunya cara untuk memilih dengan yakin adalah melakukan tolok ukur pada data Anda sendiri. Tolok ukur yang baik mengukur: (1) waktu pengindeksan untuk seluruh himpunan data, (2) latensi kueri pada persentil p50, p95, dan p99 di bawah beban serentak, (3) recall@K dengan membandingkan hasil ANN dengan hasil tepat melalui brute force, dan (4) memori serta biaya pada skala target Anda. Jalankan kueri yang sama terhadap setiap penyimpanan kandidat.

import time
import numpy as np

def benchmark_store(store, queries, k=10):
    latencies = []
    for q in queries:
        start = time.perf_counter()
        store.search(q, k)
        latencies.append(time.perf_counter() - start)
    latencies.sort()
    n = len(latencies)
    print(f'p50: {latencies[n//2]*1000:.1f}ms')
    print(f'p95: {latencies[int(n*0.95)]*1000:.1f}ms')
    print(f'p99: {latencies[int(n*0.99)]*1000:.1f}ms')

Mengukur Trade-off Recall dan Latensi

Indeks ANN menukar recall dengan kecepatan. Parameter HNSW ef_search yang lebih tinggi menemukan tetangga yang lebih akurat, tetapi memerlukan waktu lebih lama. Ukur recall@10 (proporsi 10 tetangga sebenarnya teratas yang dikembalikan) pada berbagai pengaturan parameter, lalu buat grafik recall terhadap latensi. Sebagian besar sistem produksi menargetkan recall 95-99%. Recall di bawah 90% berarti pengguna mendapatkan potongan yang tidak relevan meskipun kuerinya cepat.

def compute_recall(approx_ids, exact_ids):
    '''Compute recall@K for one query'''
    return len(set(approx_ids) & set(exact_ids)) / len(exact_ids)

def benchmark_recall(index, brute_force, queries, k=10):
    recalls = []
    for q in queries:
        approx = index.search(q, k)
        exact = brute_force.search(q, k)
        recalls.append(compute_recall(approx, exact))
    print(f'Mean recall@{k}: {sum(recalls)/len(recalls):.3f}')

Kerangka Pengambilan Keputusan

Gunakan pohon keputusan berikut: Jika Anda memerlukan pengelolaan infrastruktur nol dan anggaran bukan kendala, pilih Pinecone. Jika Anda sudah menjalankan PostgreSQL dan himpunan data Anda berisi kurang dari 10 juta vektor, tambahkan pgvector. Untuk solusi sumber terbuka yang dihosting sendiri dengan pemfilteran muatan kompleks, pilih Qdrant. Untuk pembuatan prototipe cepat dan pengembangan lokal, mulai dengan Chroma lalu migrasikan nanti. Untuk pekerjaan batch luring berskala miliaran, gunakan FAISS.

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Rekayasa AI dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini Anda mempelajari: lanskap penyimpanan vektor yang mencakup Pinecone, pgvector, Chroma, Qdrant, Weaviate, dan FAISS, lima dimensi evaluasi berupa latensi, throughput, pemfilteran, kompleksitas, dan biaya, serta kerangka pengambilan keputusan praktis untuk memilih penyimpanan yang tepat berdasarkan infrastruktur dan kebutuhan skala Anda. Selanjutnya, kita akan membahas masalah yang hendak diselesaikan oleh RAG.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memilih dan Mengukur Kinerja Penyimpanan Vektor” gratis?

Ya — teks lengkap “Memilih dan Mengukur Kinerja Penyimpanan Vektor” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Memilih dan Mengukur Kinerja Penyimpanan Vektor”?

Bandingkan Pinecone, pgvector, Chroma, Weaviate, dan Qdrant berdasarkan biaya, latensi, kemampuan penyaringan, dan kompleksitas operasional untuk memilih alat yang tepat bagi kasus penggunaan Anda. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Memilih dan Mengukur Kinerja Penyimpanan Vektor” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengapa Anda Membutuhkan Basis Data Vektor
  2. Memulai dengan Pinecone
  3. pgvector: Penyematan dalam PostgreSQL
  4. Memilih dan Mengukur Kinerja Penyimpanan Vektor
← Kembali ke AI Engineering Academy