VPS'te Vektör Veritabanı Çalıştırma Rehberi
Uygulama ve indeks aynı VPS'te olduğunda ağ gecikmesi sorun olmaktan çıkar. pgvector, Qdrant, Chroma ve brute force seçeneklerini karşılaştırıp RAM'i doğru hesaplayın.
Bir VPS (sanal özel sunucu) üzerinde vektör veritabanı çalıştırmak, yönetilen tüm sağlayıcıların çözüm sunduğu sorunu ortadan kaldırır. Uygulamanız ve indeksiniz aynı makinede bulunur; bu nedenle arama isteği ağ üzerinden değil, loopback socket üzerinden ilerler. Geriye her zaman asıl maliyet olan metni vektörlere dönüştürme maliyeti kalır. Bunun arkasında iki maliyet daha vardır: indeksi oluşturma süresi ve indeks hizmet verdiği sürece bellekte tuttuğu RAM miktarı.
Bu durum, hangi kararların önemli olduğunu değiştirir. Bölge ve endpoint round trip süresi artık sizin sorununuz değildir. Vektör sayısının boyutlarla ve dört byte ile çarpımı sizin sorununuzdur; çünkü bu değer, indeksin her ay kiraladığınız belleğe sığıp sığmayacağını belirler.
Tek bir sunucuda milisaniyelerin gerçek dağılımı
Kendi barındırdığınız (self-hosted) bir yığında benzerlik sorgusunun izlediği yolu takip edin.
- Sorgu metni, bir embedding modeli tarafından vektöre dönüştürülür. CPU üzerinde kısa bir metin için bu işlem onlarca ila yüzlerce milisaniye sürer. GPU üzerinde ise tek haneli milisaniyelerdedir.
- Vektör, depolama birimine gönderilir. Loopback TCP veya Unix domain socket üzerinden bu işlem bir milisaniyenin çok küçük bir kısmını alır.
- Depolama birimi dizinini tarar ve en yakın satırları döndürür.
- Kodunuz eşleşen metni okur ve bir istem (prompt) oluşturur.
- adım genellikle bu listedeki en büyük süreyi oluşturur. 2. adım, barındırma hizmeti sunan firmaların rekabet ettiği kısımdır; ancak tek bir sunucuda bu süre neredeyse yok denecek kadar azdır. Süre dağılımını tahmin etmeyin. Kendi sunucunuzda her iki ucun da süresini ölçün.
curl http://127.0.0.1:11434/api/embed -s -o /dev/null \
-w 'embed: %{time_total}s\n' \
-d '{"model": "nomic-embed-text", "input": "how do I rotate the api key"}'Ardından arama sorgusundan önce \timing on komutunu psql içinde çalıştırın. Eğer ilk komut embed: 0.184312s çıktısını verirse ve psql, Time: 4.201 ms yanıtını dönerse, dizin ayarı yapmak yanlış bir işlemdir: gecikmenizin sebebi embedding modelidir. Embedding modelini Ollama ile yerel olarak çalıştırmak, 1. adımı 2. ve 3. adımlarla aynı CPU üzerine taşır; bu durumda her iki yarı da aynı çekirdekler ve aynı RAM için rekabet eder. Bu depolama birimi etrafında sarmalanan veri girişi ve geri getirme döngüsü, kendi kendine barındırılan RAG hattı kılavuzu içinde ele alınmıştır. RAG, "retrieval augmented generation" (geri getirme ile güçlendirilmiş üretim) anlamına gelir: kendi belgelerinizde arama yapar ve en iyi eşleşmeleri bir istemin içine yapıştırırsınız.
Yüz bin vektörün altındaki verilerde tümünü tarayın
Kapsamlı bir tarama, sorguyu depolanan her bir vektörle karşılaştırır. Geri çağırma (recall) tanım gereği mükemmeldir. Herhangi bir dizine veya oluşturma adımına ihtiyaç duymaz ve verilerinizin gerisinde kalarak güncelliğini yitiremez.
Aritmetik hesaplama, bu yöntemin ne zaman verimsizleşeceğini size söyler. Bir tarama, sorgu başına n * d * 4 bayt okur; burada n vektör sayısı, d ise boyuttur. 768 boyutlu 100.000 vektörde bu, sorgu başına 307 MB eder ve modern bir işlemci bunu birkaç on milisaniyede işleyebilir. 5 milyon vektörde ise bu değer sorgu başına 15 GB olur ki bu artık bir sorgu olarak kabul edilemez.
Bu nedenle vektörleri SQLite içinde saklayın ve karşılaştırmayı NumPy ile yapın.
import sqlite3, numpy as np
db = sqlite3.connect("docs.db")
db.execute("CREATE TABLE IF NOT EXISTS docs (id INTEGER PRIMARY KEY, body TEXT, vec BLOB)")
def add(body, vec):
v = np.asarray(vec, dtype=np.float32)
v /= np.linalg.norm(v)
db.execute("INSERT INTO docs (body, vec) VALUES (?, ?)", (body, v.tobytes()))
db.commit()
def search(query_vec, k=5):
rows = db.execute("SELECT id, body, vec FROM docs").fetchall()
mat = np.frombuffer(b"".join(r[2] for r in rows), dtype=np.float32).reshape(len(rows), -1)
q = np.asarray(query_vec, dtype=np.float32)
q /= np.linalg.norm(q)
scores = mat @ q
return [(rows[i][0], rows[i][1], float(scores[i])) for i in np.argsort(-scores)[:k]]Her iki taraf da birim uzunluğa ölçeklendiğinden, nokta çarpımı (dot product) doğrudan kosinüs benzerliğidir ve daha yüksek bir puan daha yakın bir eşleşmeyi ifade eder. mat değerini sorgu başına değil, başlangıçta bir kez yükleyin; böylece SQLite okuma işlemi kritik yoldan tamamen çıkar.
Reddetmeden önce kendi makinenizde süre ölçümü yapın.
import time
t = time.perf_counter()
search(q)
print(f"{(time.perf_counter() - t) * 1000:.1f} ms")Dürüst sınırlar şunlardır: Bu yöntem, tüm matrisi RAM'de tutan tek bir süreçtir; meta veri filtrelemesi sunmaz ve eşzamanlı yazma işlemlerini desteklemez. Bu nedenlerden biri sizi kısıtlamaya başladığında başka bir çözüme geçin. SQLite'ın kendisi ciddi bir sunucu tarafı deposudur; üretim ortamında SQLite rehberi bunu detaylandırır. Eğer gerçek iş yükünüz satır sunmaktan ziyade sütun taramaksa, DuckDB ve SQLite karşılaştırması daha faydalı bir okuma olacaktır.
Postgres zaten çalışıyorsa pgvector
Uygulamanın zaten bir Postgres veritabanı varsa pgvector, sisteme en az sayıda yeni bileşen ekler. Bu bir servis değil, bir eklentidir. Vektörler, tanımladıkları satırın yanında normal bir tabloda tutulur. Böylece filtrelenmiş arama, senkronize tutulması gereken ikinci bir sistem yerine bir WHERE koşulu haline gelir.
Ubuntu 24.04, bunu universe bileşeninde sunar.
sudo apt update
sudo apt install -y postgresql-16-pgvector
sudo -u postgres psql -d yourdb -c 'CREATE EXTENSION vector;'Ekim 2026 itibarıyla bu paket pgvector 0.6.0 sürümüdür ve upstream sürümünün oldukça gerisindedir. Özellikle yinelemeli indeks taramaları için 0.8 gerekir. Bu nedenle bunları PostgreSQL projesinin kendi deposundan alın.
sudo apt install -y postgresql-common
sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh
sudo apt install -y postgresql-17-pgvector17 değerini sunucunuzun ana sürümüyle değiştirin. Bu sürümü sudo -u postgres psql -tAc 'SHOW server_version' yazdırır. Yanlış ana sürüm için oluşturulmuş eklenti paketini kurarsanız CREATE EXTENSION başarısız olur. Bunun nedeni Postgres'in yalnızca çalışan sürümün share dizinine bakmasıdır:
ERROR: could not open extension control file "/usr/share/postgresql/16/extension/vector.control": No such file or directoryŞema, tek bir yeni tür içeren standart SQL'dir.
CREATE TABLE chunks (
id bigserial PRIMARY KEY,
doc_id bigint NOT NULL,
body text NOT NULL,
embedding vector(768)
);
SELECT id, body FROM chunks
ORDER BY embedding <=> '[0.013, -0.021, 0.004]'
LIMIT 5;<=> cosine distance, <-> L2 (Euclidean) distance ve <#> negative inner product değeridir. Embedding modelinizin eğitildiği metriği kullanın. Yanlış metriği seçerseniz hata oluşmaz; yalnızca sonuçların kalitesi sessizce düşer.
İndeks olmadan bu sorgu, her satır üzerinde tam arama yapar. Bu, Postgres'teki brute force sürümüdür ve aynı kusursuz recall değerine sahiptir. max_parallel_workers_per_gather değerini artırmak, aramaya daha fazla çekirdek ayrılmasını sağlar. Önce bunu yapın, indeksi daha sonra oluşturun. Böylece indekse kıyaslayabileceğiniz bir recall temel değeriniz olur.
Qdrant, dizin veritabanını aştığında
Qdrant, Rust ile yazılmış özel bir vektör deposudur. Dizin, uygulamanızın Postgres veritabanıyla derleme kaynaklarını paylaşmasını istemeyeceğiniz kadar büyüdüğünde veya pgvector yalnızca yarı hassasiyetli ve ikili nicelemeyi desteklerken payload filtreleme ile yerleşik skaler ya da ürün nicelemesine ihtiyaç duyduğunuzda tercih edilir.
docker run -d --name qdrant \
-p 127.0.0.1:6333:6333 -p 127.0.0.1:6334:6334 \
-e QDRANT__SERVICE__API_KEY="$(openssl rand -hex 32)" \
-v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
qdrant/qdrant6333 numaralı port REST (representational state transfer) API'sine ve /dashboard adresindeki kontrol paneline, 6334 numaralı port ise gRPC'ye hizmet verir. Genel erişime açık bir VPS üzerinde iki ayrıntı önemlidir. Qdrant'ın kendi belgelerinde, servisin varsayılan olarak "şifreleme veya kimlik doğrulama olmadan" çalıştığı belirtilir. Ayrıca quickstart içindeki -p 6333:6333 tüm arayüzlere bağlanır. Docker, kendi yönlendirme kurallarını yazdığı için bu bağlantıyı ufw kuralının dışına çıkarır. 127.0.0.1 adresine bağlanın ve bir API anahtarı ayarlayın. Genel IP adresinden erişilebilen ve anahtarı olmayan bir Qdrant örneği, belgelerinizin herkese açık bir kopyasıdır.
curl -s http://127.0.0.1:6333/collections -H "api-key: $QDRANT_API_KEY"Sağlıklı bir yanıt {"result":{"collections":[]},"status":"ok","time":0.00002} biçiminde görünür. {"status":{"error":"Unauthorized"}} sonucunun alınması, üstbilgi adının veya anahtarın yanlış olduğu anlamına gelir. Hiçbir yanıt alınmaması ise container'ın çalışmadığı ya da başka bir adrese bağlandığı anlamına gelir. Bu container'ın sunucunuz için uygun yapıda olup olmadığı olağan durum bilgisi tutan servis sorusudur. Bu nedenle Docker ile host veritabanı karşılaştırması burada da değişmeden geçerlidir.
Chroma ve kullanım amacı
Chroma, boş bir ortamdan çalışan bir geri getirme (retrieval) demosu oluşturmanın en kısa yoludur.
pip install chromadb
chroma run --path /srv/chromaBu servis 8000 numaralı port üzerinde çalışır ve chromadb.HttpClient(host="localhost", port=8000) buna bağlanır. Chroma varsayılan bir gömme (embedding) fonksiyonu ile gelir, bu nedenle ilk prototip için ayrı bir model sunucusuna ihtiyaç duyulmaz.
Bu değiş tokuş konusunda dürüst olunmalıdır. Chroma, bu kılavuzun konusu olan kararları (hangi mesafe metriğinin kullanılacağı ve sonucun ne kadar RAM kaplayacağı gibi) gizlediği için kullanımı kolaydır. Bu durum bir prototip için doğru, ancak gece yarısı çağrı almanıza neden olacak bir sistem için yanlıştır. Verileriniz halihazırda Postgres üzerinde tutuluyorsa, bunları Chroma'ya taşımak, pgvector'un sahip olmadığı bir sorunu çözmek adına fazladan bir süreç ve senkronizasyon problemi yaratır.
Dizin ne kadar RAM gerektirecek
Ham vektörlerden başlanmalıdır. Bunlar alt sınırı belirler ve hiçbir ayar bu gereksinimi azaltamaz.
bytes = number_of_vectors * dimensions * 4Dört bayt, her boyut için bir adet 32-bit float anlamına gelir. Qdrant'ın RAM kapasitesini aşan collection'lara yönelik kılavuzu; metadata, index'ler ve optimizasyon sırasında oluşturulan geçici segmentler için 1.5 çarpanı ekler:
memory_size = number_of_vectors * vector_dimension * 4 bytes * 1.5Aşağıdaki formül, gerçek embedding modellerinin ürettiği boyutlar kullanılarak bir milyon vektör üzerinde uygulanmıştır.
Bu grafiğin arkasındaki veriler
[
{
"label": "384 dims",
"raw_gib": 1.43,
"with_overhead_gib": 2.15
},
{
"label": "768 dims",
"raw_gib": 2.86,
"with_overhead_gib": 4.29
},
{
"label": "1024 dims",
"raw_gib": 3.81,
"with_overhead_gib": 5.72
},
{
"label": "1536 dims",
"raw_gib": 5.72,
"with_overhead_gib": 8.58
},
{
"label": "3072 dims",
"raw_gib": 11.44,
"with_overhead_gib": 17.17
}
]Bunlar ölçüm sonucu değil, formülün gibibyte (GiB) cinsinden çıktılarıdır. Bellekte ayrılması gereken alanın boyutu olarak değerlendirilmelidir. nomic-embed-text gibi 768 boyutlu bir model, bir milyon chunk için yaklaşık 4.29 GiB gerektirir. Bu miktar, Postgres için de alan bırakarak 8 GB'lık bir plana sığar. Aynı corpus 3072 boyutta 17.17 GiB gerektirir ve sığmaz.
Kontrol edilmesi gereken sütun son sütun değil, grafiğin ilk sütunudur. Boyutun yarıya indirilmesi, bunun ardından gelen tüm aşamalardaki bayt sayısını kalıcı olarak yarıya indirir. Herkese açık bir leaderboard'da biraz daha düşük skor alan 768 boyutlu bir model, VPS üzerinde çoğu zaman daha iyi bir mühendislik tercihidir. Ardından pgvector'ın halfvec türü 16-bit float değerleri depolarak bayt sayısını yeniden yarıya indirir ve expression üzerinden index oluşturur:
CREATE INDEX ON chunks USING hnsw ((embedding::halfvec(768)) halfvec_cosine_ops);Model seçmeden önce bilinmesi gereken bir sınır vardır. pgvector'ın vector türü 16,000 boyuta kadar kabul eder, ancak HNSW ve IVFFlat index'leri yalnızca 2,000 boyutu kapsar. halfvec cast işlemi bu sınırı 4,000'e çıkarır. Bu sınırın üzerinde pgvector, binary quantisation yöntemini belgeler: binary_quantize(embedding)::bit(N) expression için bit_hamming_ops ile index oluşturulur. Bu işlem 64,000 boyuta kadar desteklenir. Ardından en iyi adaylar, orijinal vektörler kullanılarak yeniden sıralanır.
Build zamanında m ve ef_construction maliyeti
HNSW (hierarchical navigable small world), hem pgvector hem de Qdrant'ın kullandığı indekstir. Katmanlı bir grafiktir. Her vektör, yakındaki düğümlere bağlantıları olan bir düğümdür. Arama, tüm veriyi okumak yerine bu bağlantılar üzerinde sorguya doğru ilerler.
m, her düğümün tuttuğu bağlantı sayısını belirtir. Faiss belgelerinde HNSW belleği vektör başına (d * 4 + m * 2 * 4) bayt olarak verilir ve m değerinin 4 ile 64 arasında tutulması önerilir. Bunu 768 boyutlu bir milyon vektör üzerinde çalıştırın.
Bu grafiğin arkasındaki veriler
[
{
"label": "m = 8",
"link_bytes_per_vector": 64,
"total_gib": 2.92
},
{
"label": "m = 16 (default)",
"link_bytes_per_vector": 128,
"total_gib": 2.98
},
{
"label": "m = 32",
"link_bytes_per_vector": 256,
"total_gib": 3.1
},
{
"label": "m = 64",
"link_bytes_per_vector": 512,
"total_gib": 3.34
}
]Aradaki farkın boyutu önemlidir. Varsayılan m = 16 değerinden m = 64 değerine geçildiğinde bağlantıların boyutu vektör başına 128 bayttan 512 bayta çıkar. Bu, 3072 baytlık vektör verisine karşılık ek 384 bayt demektir. Toplam boyut 2.98 GiB değerinden 3.34 GiB değerine çıkar. Artış yaklaşık yüzde 12'dir. Bu boyutlarda bellek kullanımının asıl kaynağı m değildir. Vektörlerdir.
m değerinin asıl maliyeti, her düğüm yerleştirilirken bu kadar komşunun bulunup bağlantılandırılması gerektiği için derleme ve ekleme süresinde ortaya çıkar. ef_construction, oluşturucunun her düğümü yerleştirirken değerlendirdiği aday listesinin boyutudur. Bu değerin artırılması daha iyi bir grafik oluşturur ve derlemeyi yavaşlatır. Tamamlanan indeksin boyutunu ise hiç değiştirmez.
SET maintenance_work_mem = '4GB';
SET max_parallel_maintenance_workers = 7;
CREATE INDEX ON chunks USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);Derlemenin dakikalar mı yoksa saatler mi süreceğini belirleyen ayar maintenance_work_mem değeridir. Bunun nedeni, pgvector grafiği belleğe sığdığı sürece bellekte oluşturur. Sığmadığında pgvector bunu bildirir:
NOTICE: hnsw graph no longer fits into maintenance_work_mem after 100000 tuples
DETAIL: Building will take significantly more time.
HINT: Increase maintenance_work_mem to speed up builds.Bu bildirim, pgvector'ın yazdırdığı en yararlı satırdır. Derlemenin çok daha yavaş bir yola geçtiğini gösterir. Bu durumda işlemi iptal edin, ayarı yukarıda hesapladığınız RAM değerinin üzerine çıkarın ve yeniden başlatın. İlerlemeyi ikinci bir oturumdan izleyin:
SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS pct
FROM pg_stat_progress_create_index;HNSW önce initializing bilgisini, ardından loading tuples bilgisini bildirir. Meşgul olmayan bir diskte derleme uzun süre düşük bir yüzde değerinde kalıyorsa sorun maintenance_work_mem değerindedir; sorgu takılmış değildir.
Planlama sırasında dikkate alınması gereken iki nokta vardır. pgvector README dosyasına göre HNSW, IVFFlat'e kıyasla "daha yavaş derlenir ve daha fazla bellek kullanır". Bunun karşılığında hız ve geri çağırma arasındaki dengede daha iyi sonuç sunar. Ayrıca HNSW boş bir tablo üzerinde oluşturulabilir. IVFFlat ise önce temsili veriler üzerinde k-means çalıştırmalıdır. Bu nedenle boş bir tablo üzerinde oluşturulması düşük geri çağırma oranına yol açar. Yeni bir şemada önceden oluşturulabilecek indeks HNSW'dir.
ef_search: derleme sonrasında ayarlanan parametre
m ve ef_construction indeks içine sabitlenmiştir. ef_search ise sabit değildir. Bu parametre, arama işlemi graf üzerinde ilerlerken kaç adet adayın tutulacağını belirler ve oturum ya da sorgu bazında değiştirilebilir.
SET hnsw.ef_search = 100;
SELECT id, body FROM chunks ORDER BY embedding <=> $1 LIMIT 5;Varsayılan değer 40'tır. Bu değeri artırdığınızda geri çağırma (recall) oranı yükselir, ancak gecikme süresi de artar. Değeri düşürdüğünüzde her ikisi de azalır. Bu, yeniden derleme yapmadan değiştirebileceğiniz tek geri çağırma kontrolüdür; bu nedenle, doğru cevaplarını bildiğiniz sabit bir sorgu kümesi üzerinde ayarlama yapın ve geri çağırma oranı iyileşmeyi durdurduğunda işlemi sonlandırın.
Bir tuzak noktası mevcuttur. ef_search, seçici bir WHERE yan tümcesi ile kötü etkileşime girer; çünkü indeks sabit sayıda aday döndürür ve filtreleme işlemi sonrasında uygulanır. Satırların çoğunu reddeden bir filtre, eşleşen satırlar tabloda dururken elinizde LIMIT değerinden daha az sonuç kalmasına neden olabilir. pgvector 0.8 sürümü, bu sorunu yinelemeli taramalar ile çözer:
SET hnsw.iterative_scan = relaxed_order;İndeks, limit karşılanana kadar daha fazla aday için yeniden taranır; bu işlem, varsayılan değeri 20000 olan hnsw.max_scan_tuples sınırına kadar devam eder. strict_order, tam mesafe sıralamasını korur ve daha maliyetlidir. Ubuntu 0.6.0 paketinde bulunmayan özellik budur ve filtre altında eksik satırlarla karşılaştığınızda bu eksikliği fark edersiniz.
Dizinin neden RAM'e sığması gerektiği
HNSW araması, bir grafik üzerinde yapılan bir gezintidir. Her sıçrama, bir öncekinden bağımsız bir konumda saklanan bir düğümü okur; bu nedenle erişim düzeni rastgeleye yakındır ve önceden okuma (read-ahead) mekanizması işe yaramaz. Grafik RAM'de olduğu sürece her sıçrama bir bellek referansıdır. Grafik RAM'de olmadığında ise bir sıçrama disk okumasına dönüşebilir ve birkaç yüz düğüme dokunan bir arama, birkaç yüz disk okumasına yol açar.
Qdrant belgeleri bu durumu şöyle özetler: "RAM'de yarı yarıya daha az vektör saklarsanız, arama gecikmesi kabaca iki katına çıkar." Planlamanızı bu cümleyi dikkate alarak yapın.
Dizinin gerçekten sığmayacağı durumlarda, her seçenek bilinçli olarak yapmanız gereken bir takas işlemidir.
- Vektörleri bellek eşlemeli (memory-map) hale getirin; böylece işletim sistemi sık kullanılan sayfaları önbelleğe alır ve seyrek kullanılanları diskte bırakır. Bunun kabul edilebilir olması için altta hızlı bir NVMe depolama birimi bulunmalıdır.
- Niceleme (quantisation) uygulayın; her boyutu dört bayt yerine bir bayt olarak saklayın. Bu, ölçülebilir küçük bir doğruluk kaybı karşılığında vektör boyutunu dörtte bire indirir.
- pgvector içinde
halfvecformatına dönüştürün; bu, tek baytlık nicelemeye göre daha az doğruluk kaybıyla bayt boyutunu yarıya indirir. - Daha küçük bir model ile gömme (embedding) işlemi yapın. Bu en ucuz çözümdür ancak insanlar tarafından genellikle göz ardı edilir, çünkü tüm veri kümesinin yeniden gömülmesini gerektirir.
Hata modları ve karşılaşacağınız dizgeler
could not open extension control file. Çalışan Postgres ana sürümü için pgvector paketi yüklü değildir. Sürümü sudo -u postgres psql -tAc 'SHOW server_version' ile yazdırın ve eşleşen postgresql-NN-pgvector paketini yükleyin.
ERROR: expected 768 dimensions, not 1536. Sütun türü ile model uyuşmuyor. Gömme (embedding) modellerini değiştirdiniz ancak verileri yeniden işlemediniz. Burada kısmi bir çözüm yoktur; iki farklı modelden gelen vektörler birbiriyle kıyaslanamaz, bu nedenle her satırın yeniden oluşturulması gerekir.
Sorgu yavaştır ve EXPLAIN bir sequential scan gösteriyor. İndeks operatör sınıfı ile sorgu operatörü eşleşmiyor. vector_cosine_ops yalnızca <=> için hizmet verir. Sorgu üzerinde EXPLAIN ANALYZE çalıştırın ve Index Scan using ... on chunks ifadesini arayın. Bunun yerine Seq Scan on chunks görüyorsanız, indeksinizi aslında sorguladığınız operatörle eşleşen operatör sınıfını kullanarak yeniden oluşturun.
LIMIT değerinden daha az satır dönüyor ve bir WHERE ifadesi mevcut. Bu, yukarıda bahsedilen filtreleme tuzağıdır. hnsw.ef_search değerini yükseltin veya pgvector 0.8 sürümüne geçerek hnsw.iterative_scan ayarını yapılandırın.
İndeks oluşturma işlemi, süreç sonlanarak bitiyor ve psql içinde hiçbir hata görünmüyor. maintenance_work_mem değerinin makine kapasitesinin büyük kısmına ayarlanması, shared_buffers ve uygulamanızın da bellek talep etmesiyle birleşince çekirdeğin out-of-memory killer mekanizması devreye girer. sudo dmesg -T | grep -i 'killed process', postgres sürecini işaret eden satırı gösterir. Ayarı düşürün veya indeksi daha yüksek kapasiteli bir planda oluşturup yedeği geri yükleyin.
Birini seçmek
Hali hazırda Postgres kullanıyorsanız ve birkaç milyondan az vektörünüz varsa, pgvector kullanın. İndeks verinin yanında yer alır, filtreleme bir WHERE ifadesidir ve mevcut yedekleme stratejiniz bunu zaten kapsar. İndeks kendi bellek sınırına ihtiyaç duyacak kadar büyükse veya yoğun yük filtrelemesine gereksinim duyuyorsanız, Qdrant'ı yanına kurun ve ikinci bir servisi yönetmeyi kabul edin.
Yaklaşık yüz bin vektörün altındaki boyutlarda, herhangi bir kurulum yapmadan önce brute-force tarama performansını ölçün. Bu boyutta, mükemmel geri çağırma (recall) oranına sahip ve herhangi bir oluşturma adımı gerektirmeyen kapsamlı bir arama bir ödünleşim değildir. Bu doğru yaklaşımdır; bunun yerine yaklaşık bir indekse yönelmek, harcamadığınız milisaniyeler karşılığında ayarlama yükü ve RAM baskısını üstlenmek anlamına gelir.
FAQ
Özel bir vector database gerekli mi, yoksa Postgres yeterli mi?
Verileriniz zaten Postgres üzerinde bulunuyorsa pgvector, çoğu karşılaştırmada belirtilenden çok daha uzun süre yeterli olur. Vektörleri normal bir sütunda saklar; bu nedenle filtreli arama bir WHERE koşuludur ve mevcut yedekleme işleminiz indeksi de kapsar. Vektör iş yükünün kendine ait bir bellek sınırına ihtiyaç duyduğu veya pgvector'ın sağlamadığı payload filtreleme ile scalar ya da product quantisation gerektiği durumlarda Qdrant gibi özel bir veri deposuna geçilmelidir.
Bir VPS kaç vektör barındırabilir?
Tahmin etmek yerine number_of_vectors * dimensions * 4 bytes * 1.5 kullanarak hesaplayın. 768 boyutlu bir milyon vektör yaklaşık 4.3 GiB yer kaplar. Bu nedenle 8 GB plan, Postgres için de alan bırakır. 3072 boyutlu bir milyon vektör yaklaşık 17 GiB yer kaplar ve çok daha büyük bir plan gerektirir. Bu değeri en fazla değiştiren unsur embedding modelinizin boyutudur. Bu nedenle modeli bellek maliyetini dikkate alarak seçin.
İndeks aynı makinede olmasına rağmen vector search neden yavaş?
Tek bir makinede ağ bağlantısı sorun değildir. Bu nedenle iki noktayı inceleyin. İlk olarak embedding çağrısının süresini tek başına ölçün. Çünkü sorgu vektörünün CPU üzerinde oluşturulması çoğu zaman aramanın kendisinden çok daha uzun sürer. İkinci olarak indeksin RAM içinde bulunduğunu doğrulayın. HNSW araması bir grafik üzerinde rastgele geçişler yapar. Grafik diske taştığında her geçiş bir disk okumasına dönüşebilir. Qdrant'ın kendi yönergelerine göre RAM içinde tutulan vektör sayısının yarıya indirilmesi, arama gecikmesini yaklaşık iki katına çıkarır.
HNSW indeksi oluşturmam gerekiyor mu?
Yaklaşık yüz bin vektörün altında genellikle gerekmez. Kapsamlı tarama, sorgu başına n * d * 4 byte okur. 768 boyutlu 100,000 vektörde bu değer 307 MB olur. Modern bir CPU, kusursuz geri çağırma oranıyla ve oluşturma adımı gerektirmeden bu veriyi onlarca milisaniye içinde işleyebilir. Önce taramayı kendi donanımınızda ölçün. İndeksi, bir benchmark makalesi önerdiği için değil, ölçülen tarama süresi gerçekten çok yavaş olduğu için oluşturun.
m değerini artırmanın gerçek maliyeti nedir?
Maliyetin büyük bölümü bellekten çok oluşturma ve ekleme süresine yansır. 768 boyutta varsayılan m = 16 değerinden m = 64 değerine geçildiğinde grafik bağlantıları vektör başına 128 byte'tan 512 byte'a çıkar. Bu, 3072 byte'lık vektör verisine ek olarak 384 byte anlamına gelir. Böylece toplam bellek kullanımı yaklaşık yüzde 12 artar. Ancak her ekleme işleminde dört kat daha fazla komşunun bulunması ve bağlanması gerekir. Önce ef_search değerini ayarlayın. Bu değerin değiştirilmesi ek maliyet gerektirmez ve yeniden oluşturma işlemi gerektirmez.