SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-21

VPS पर Vector Database चलाने की लागत और RAM

Application और index एक ही VPS पर होने से latency समस्या नहीं रहती। pgvector, Qdrant, Chroma और brute force की तुलना करें, फिर सही RAM चुनें।

VPS पर vector database चलाने की वास्तविक लागत

VPS (virtual private server) पर vector database चलाने से वह समस्या समाप्त हो जाती है जिसका समाधान बेचकर managed vendors मुनाफा कमाते हैं। आपका application और index एक ही machine पर स्थित होते हैं, इसलिए search request network के बजाय loopback socket से होकर गुजरती है। जो लागत शेष रहती है, वह हमेशा से ही वास्तविक रही है: text को vectors में बदलना। इसके पीछे दो और लागतें होती हैं: index बनाने में लगने वाला समय और वह RAM जो index के सक्रिय रहने तक उपयोग होती है।

यह उन निर्णयों को बदल देता है जो महत्वपूर्ण हैं। Region और endpoint round trip अब आपकी चिंता का विषय नहीं रहते। Vector count, dimensions और चार bytes का गुणनफल आपकी चिंता बन जाता है, क्योंकि यही तय करता है कि index आपके द्वारा हर महीने किराए पर ली गई memory में फिट होगा या नहीं।

एक ही सर्वर पर मिलीसेकंड्स वास्तव में कहाँ खर्च होते हैं

एक self-hosted stack में similarity query की प्रक्रिया को समझें।

  1. Query text को एक embedding model द्वारा vector में बदला जाता है। CPU पर एक छोटी string के लिए इसमें दस से सैकड़ों मिलीसेकंड्स लगते हैं। GPU पर यह समय सिंगल डिजिट में होता है।
  2. Vector को store में भेजा जाता है। Loopback TCP या Unix domain socket के माध्यम से इसमें एक मिलीसेकंड का बहुत छोटा हिस्सा लगता है।
  3. Store अपने index को स्कैन करता है और निकटतम rows को लौटाता है।
  4. आपका कोड matching text को पढ़ता है और एक prompt तैयार करता है।

इस सूची में Step 1 आमतौर पर सबसे अधिक समय लेता है। Step 2 वह चरण है जिस पर hosted vendors प्रतिस्पर्धा करते हैं, लेकिन एक ही बॉक्स पर इसका प्रभाव न के बराबर होता है। अनुमान न लगाएँ। अपने सर्वर पर दोनों सिरों का समय मापें।

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"}'

इसके बाद search query से पहले \timing on को psql में चलाएँ। यदि पहला कमांड embed: 0.184312s प्रिंट करता है और psql का उत्तर Time: 4.201 ms है, तो index को ट्यून करना गलत काम है: आपकी latency embedding model के कारण है। Ollama के साथ स्थानीय रूप से embedding model चलाना Step 1 को Step 2 और 3 वाले CPU पर ही रखता है, इसलिए दोनों हिस्से समान cores और समान RAM के लिए प्रतिस्पर्धा करते हैं। इस store के इर्द-गिर्द बना ingest और retrieval loop self-hosted RAG pipeline गाइड में कवर किया गया है। RAG का अर्थ है retrieval augmented generation: आप अपने स्वयं के दस्तावेज़ों को खोजते हैं और सबसे अच्छे matches को एक prompt में पेस्ट करते हैं।

लगभग एक लाख vectors से कम होने पर सभी vectors को scan करें

Exhaustive scan हर stored vector के साथ query की तुलना करता है। परिभाषा के अनुसार recall perfect रहता है। इसके लिए index या build step की जरूरत नहीं होती, और यह आपके data से पीछे पुराना भी नहीं पड़ सकता।

Arithmetic से पता चलता है कि यह तरीका कब अपर्याप्त हो जाता है। प्रत्येक query के लिए scan n * d * 4 bytes पढ़ता है, जहाँ n vector count और d dimension है। 768 dimensions वाले 100,000 vectors पर यह प्रति query 307 MB होता है, जिसे modern CPU कुछ tens of milliseconds में stream कर लेता है। 5 million vectors पर यह प्रति query 15 GB होता है, जिसे query कहना भी उचित नहीं रह जाता।

इसलिए vectors को SQLite में store करें और comparison NumPy में करें।

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]]

दोनों sides को unit length पर scale किया जाता है, इसलिए dot product वास्तव में cosine similarity है और अधिक score का अर्थ closer match है। mat को प्रत्येक query के बजाय startup पर एक बार load करें; इससे SQLite read पूरी तरह hot path से बाहर हो जाता है।

इसे अस्वीकार करने से पहले अपने box पर इसका समय मापें।

import time
t = time.perf_counter()
search(q)
print(f"{(time.perf_counter() - t) * 1000:.1f} ms")

ईमानदार सीमाएँ ये हैं: यह एक process है, जो पूरी matrix को RAM में रखता है, और इसमें metadata filtering या concurrent writer के लिए कोई व्यवस्था नहीं है। यदि आपकी असुविधा का कारण इनमें से कोई एक है, तो आगे बढ़ें। SQLite स्वयं एक गंभीर server-side store है, जिसे production में SQLite guide में विस्तार से बताया गया है। यदि आपका वास्तविक workload rows serve करने के बजाय columns scan करना है, तो DuckDB और SQLite comparison अधिक उपयोगी है।

यदि आप पहले से Postgres चला रहे हैं तो pgvector

यदि आपके application में पहले से Postgres database है, तो pgvector सबसे कम नया surface जोड़ता है। यह एक extension है, service नहीं। Vectors उस row के पास एक सामान्य table में रहते हैं जिसका वे वर्णन करते हैं। इसलिए filtered search, sync में बनाए रखने के लिए दूसरी system के बजाय एक WHERE clause बन जाती है।

Ubuntu 24.04 इसे universe component में उपलब्ध कराता है।

sudo apt update
sudo apt install -y postgresql-16-pgvector
sudo -u postgres psql -d yourdb -c 'CREATE EXTENSION vector;'

October 2026 तक वह package pgvector 0.6.0 है, जो upstream से काफी पुराना है। विशेष रूप से iterative index scans के लिए 0.8 आवश्यक है। इसलिए इन्हें PostgreSQL project के अपने repository से लें।

sudo apt install -y postgresql-common
sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh
sudo apt install -y postgresql-17-pgvector

17 को अपने server के major version से बदलें। इसे sudo -u postgres psql -tAc 'SHOW server_version' दिखाता है। गलत major version के लिए बनाया गया extension package install करने पर CREATE EXTENSION fail होता है, क्योंकि Postgres केवल चल रहे version की share directory में खोजता है:

ERROR:  could not open extension control file "/usr/share/postgresql/16/extension/vector.control": No such file or directory

Schema सामान्य SQL है, जिसमें केवल एक नया type है।

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 है, और <#> negative inner product है। अपने embedding model के training के लिए उपयोग किए गए विकल्प को चुनें। गलत विकल्प चुनने पर कोई error नहीं आएगा, लेकिन आपके results चुपचाप खराब हो जाएँगे।

Index के बिना यह query हर row पर exact search करती है। यह ऊपर बताए गए brute force का Postgres संस्करण है और इसका recall भी पूर्ण रहता है। max_parallel_workers_per_gather बढ़ाने से इसमें अधिक cores लगाए जाते हैं। पहले यह करें और index बाद में बनाएँ, क्योंकि अब आपके पास index की तुलना करने के लिए recall baseline होगा।

Qdrant, जब index database से बड़ा हो जाए

Qdrant Rust में लिखा गया dedicated vector store है। यह तब उपयोगी होता है, जब index इतना बड़ा हो जाए कि आप उसका build अपनी application के Postgres के साथ संसाधनों के लिए प्रतिस्पर्धा करते हुए न चलाना चाहें, या जब आपको payload filtering और built-in scalar या product quantisation चाहिए। pgvector में केवल half precision और binary quantisation का documentation है।

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/qdrant

Port 6333 REST (representational state transfer) API और /dashboard पर dashboard उपलब्ध कराता है, जबकि 6334 gRPC के लिए है। Public VPS पर दो बातें महत्वपूर्ण हैं। Qdrant के अपने documentation के अनुसार service डिफ़ॉल्ट रूप से "with no encryption or authentication" चलती है, और quickstart का -p 6333:6333 हर interface पर bind होता है। Docker इसे ufw rule के बाहर publish कर देता है, क्योंकि Docker अपने forwarding rules लिखता है। 127.0.0.1 पर bind करें और API key सेट करें। बिना key के public IP पर reachable Qdrant instance आपके documents की public copy है।

curl -s http://127.0.0.1:6333/collections -H "api-key: $QDRANT_API_KEY"

सही response में {"result":{"collections":[]},"status":"ok","time":0.00002} दिखता है। {"status":{"error":"Unauthorized"}} वापस मिलने का अर्थ है कि header name या key गलत है। बिल्कुल कुछ भी न मिलने का अर्थ है कि container चल नहीं रहा है या किसी अन्य स्थान पर bound है। यह container आपके host के लिए सही configuration है या नहीं, यह सामान्य stateful-service का प्रश्न है। इसलिए Docker और host database की तुलना यहां भी उसी तरह लागू होती है।

Chroma और इसका उद्देश्य

Chroma, बिना किसी तैयारी के एक कार्यशील retrieval demo तक पहुँचने का सबसे छोटा रास्ता है।

pip install chromadb
chroma run --path /srv/chroma

यह port 8000 पर चलता है और chromadb.HttpClient(host="localhost", port=8000) इससे connect होता है। Chroma एक default embedding function के साथ आता है, इसलिए शुरुआती prototype के लिए किसी अलग model server की आवश्यकता नहीं होती है।

इस समझौते के प्रति ईमानदार रहें। Chroma इसलिए सुविधाजनक है क्योंकि यह उन निर्णयों को छिपा देता है जिनके बारे में यह guide है: कौन सा distance metric उपयोग करें, और परिणाम के लिए कितनी RAM की आवश्यकता होगी। यह एक prototype के लिए सही है, लेकिन उस सिस्टम के लिए गलत है जिसके लिए आपको रात में alert (page) किया जाए। यदि आपका data पहले से ही Postgres में है, तो उसे Chroma में ले जाने से एक अतिरिक्त process और synchronization की समस्या पैदा होती है, जबकि pgvector में ऐसी कोई समस्या नहीं होती।

इंडेक्स को कितनी RAM चाहिए

Raw vectors से शुरुआत करें, क्योंकि यही न्यूनतम आवश्यकता तय करते हैं और कोई tuning इन्हें छोटा नहीं कर सकती।

bytes = number_of_vectors * dimensions * 4

हर dimension के लिए 4 bytes का एक 32-bit float होता है। Qdrant की उस guide में, जो RAM से बड़े हो जाने वाले collections के बारे में है, metadata, indexes और optimisation के दौरान बनाए जाने वाले temporary segments के लिए 1.5 का multiplier जोड़ा जाता है:

memory_size = number_of_vectors * vector_dimension * 4 bytes * 1.5

यह formula उन embedding models के dimensions पर एक million vectors के लिए लागू किया गया है, जो वास्तविक उपयोग में आम हैं।

चार्टRAM for 1 million vectors, by embedding dimension
इस चार्ट के पीछे का डेटा
[
  {
    "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
  }
]

ये formula का output gibibytes (GiB) में हैं, किसी measurement से प्राप्त मान नहीं। इन्हें उस memory space के आकार के रूप में समझें, जिसे आपको पहले से खाली रखना होगा। nomic-embed-text जैसे 768-dimension model को एक million chunks के लिए लगभग 4.29 GiB चाहिए। यह 8 GB plan में Postgres के लिए कुछ जगह छोड़कर फिट हो जाता है। इसी corpus को 3072 dimensions पर रखने के लिए 17.17 GiB चाहिए, इसलिए यह plan पर्याप्त नहीं है।

इस chart में सही control पहला column है, आखिरी नहीं। Dimension को आधा करने पर उसके बाद उपयोग होने वाला हर byte हमेशा के लिए आधा हो जाता है। Public leaderboard पर थोड़ा कम score देने वाला 768-dimension model अक्सर VPS पर बेहतर engineering choice होता है। इसके बाद pgvector का halfvec type 16-bit floats store करता है, जिससे bytes फिर आधे हो जाते हैं। यह expression के माध्यम से index बनाता है:

CREATE INDEX ON chunks USING hnsw ((embedding::halfvec(768)) halfvec_cosine_ops);

Model चुनने से पहले एक सीमा जान लें। pgvector का vector type अधिकतम 16,000 dimensions स्वीकार करता है, लेकिन इसके HNSW और IVFFlat indexes केवल 2,000 dimensions तक काम करते हैं। halfvec cast इस सीमा को 4,000 dimensions तक बढ़ाता है। इससे अधिक dimensions के लिए pgvector binary quantisation document करता है: binary_quantize(embedding)::bit(N) expression को bit_hamming_ops के साथ index करें। यह अधिकतम 64,000 dimensions तक काम करता है। इसके बाद top candidates को original vectors के विरुद्ध फिर से rank करें।

बनाते समय m और ef_construction की लागत

HNSW (hierarchical navigable small world) वह index है जिसे pgvector और Qdrant दोनों इस्तेमाल करते हैं। यह एक layered graph है। प्रत्येक vector एक node होता है, जिसके nearby nodes से links होते हैं। Search के दौरान पूरी index पढ़ने के बजाय query की दिशा में इन links के माध्यम से आगे बढ़ा जाता है।

m यह तय करता है कि प्रत्येक node कितने links रखेगा। Faiss documentation के अनुसार HNSW की memory उपयोगिता (d * 4 + m * 2 * 4) bytes प्रति vector है और m को 4 से 64 के बीच रखने की सलाह दी जाती है। इसे 768 dimensions और 1 million vectors पर चलाएँ।

चार्टCost of raising m at 768 dimensions, 1 million vectors
इस चार्ट के पीछे का डेटा
[
  {
    "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
  }
]

इस अंतर का वास्तविक प्रभाव इसके आकार में दिखता है। Default m = 16 से m = 64 पर जाने पर links की मात्रा 128 से बढ़कर 512 bytes प्रति vector हो जाती है। 3072 bytes के vector data की तुलना में यह 384 bytes अतिरिक्त है। इसलिए कुल आकार 2.98 GiB से बढ़कर 3.34 GiB हो जाता है। यह लगभग 12 प्रतिशत है। इन dimensions पर memory का मुख्य उपयोग m नहीं करता। मुख्य उपयोग vectors करते हैं।

m की वास्तविक लागत build time और insert time में आती है, क्योंकि node जोड़ने के लिए इतने neighbours खोजकर उनसे links बनाने पड़ते हैं। ef_construction वह candidate list का आकार है, जिस पर builder प्रत्येक node जोड़ते समय विचार करता है। इसे बढ़ाने से graph बेहतर बनता है और build धीमा होता है। Finished index का आकार इससे बिल्कुल नहीं बदलता।

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);

maintenance_work_mem वह setting है जो तय करती है कि build में minutes लगेंगे या hours, क्योंकि pgvector graph को memory में assemble करता है, जब तक वह memory में fit होता है। जब graph fit होना बंद हो जाता है, तो pgvector यह संदेश देता है:

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.

यह notice pgvector द्वारा print की जाने वाली सबसे उपयोगी line है। इसका अर्थ है कि build बहुत धीमे path पर चला गया है। इसलिए इसे cancel करें, ऊपर की गई RAM calculation से अधिक setting करें और फिर से शुरू करें। दूसरी session से progress monitor करें:

SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS pct
FROM pg_stat_progress_create_index;

HNSW पहले initializing और फिर loading tuples report करता है। यदि disk व्यस्त नहीं है और build लंबे समय तक कम percentage पर रुका रहता है, तो यह maintenance_work_mem problem है, stuck query नहीं।

Planning के लिए दो तथ्य ध्यान रखें। pgvector की README के अनुसार HNSW में IVFFlat की तुलना में "slower build times and uses more memory" होता है। इसके बदले speed और recall के बीच बेहतर trade-off मिलता है। HNSW को empty table पर बनाया जा सकता है, जबकि IVFFlat को पहले representative data पर k-means चलाना पड़ता है। इसलिए empty table पर IVFFlat बनाने से recall खराब मिलता है। Fresh schema में HNSW वह index है जिसे आप पहले से बना सकते हैं।

ef_search: वह knob जिसे आप build के बाद tune करते हैं

m और ef_construction index में स्थिर (frozen) रहते हैं। ef_search ऐसा नहीं है। यह निर्धारित करता है कि graph को traverse करते समय search कितने candidates को बनाए रखती है, और आप इसे प्रति session या प्रति query बदल सकते हैं।

SET hnsw.ef_search = 100;
SELECT id, body FROM chunks ORDER BY embedding <=> $1 LIMIT 5;

Default मान 40 है। इसे बढ़ाने पर recall बढ़ता है, और साथ ही latency भी बढ़ती है। इसे कम करने पर दोनों कम हो जाते हैं। यह एकमात्र recall control है जिसे आप rebuild किए बिना बदल सकते हैं, इसलिए इसे उन queries के एक निश्चित सेट के विरुद्ध tune करें जिनके सही उत्तर आप पहले से जानते हैं, और तब रुकें जब recall में सुधार होना बंद हो जाए।

एक समस्या है। ef_search का WHERE clause के साथ तालमेल खराब रहता है, क्योंकि index एक निश्चित संख्या में candidates लौटाता है और filter उसके बाद लागू होता है। ऐसा filter जो अधिकांश rows को reject कर देता है, वह आपको LIMIT से कम परिणाम दे सकता है, जबकि table में matching rows मौजूद होती हैं। pgvector 0.8 इसका समाधान iterative scans के साथ देता है:

SET hnsw.iterative_scan = relaxed_order;

इसके बाद index को अधिक candidates के लिए फिर से scan किया जाता है जब तक कि limit पूरी न हो जाए, जो कि hnsw.max_scan_tuples तक हो सकती है, जिसका default मान 20000 है। strict_order सटीक distance ordering बनाए रखता है और इसमें अधिक लागत आती है। यह वह feature है जो Ubuntu 0.6.0 package में नहीं है, और filter के अंतर्गत rows का गायब होना ही वह तरीका है जिससे आपको इसका पता चलता है।

इंडेक्स का RAM में फिट होना क्यों आवश्यक है

HNSW सर्च एक ग्राफ पर चलने के समान है। प्रत्येक हॉप (hop) एक ऐसे नोड को पढ़ता है जो पिछले नोड से पूरी तरह अलग स्थान पर स्थित होता है, इसलिए एक्सेस पैटर्न रैंडम (random) होता है और read-ahead इसमें कोई मदद नहीं करता। जब तक ग्राफ RAM में रहता है, तब तक प्रत्येक हॉप एक मेमोरी रेफरेंस होता है। एक बार जब यह RAM से बाहर हो जाता है, तो एक हॉप डिस्क रीड (disk read) बन सकता है, और एक ऐसी सर्च जो कुछ सौ नोड्स को छूती है, वह कुछ सौ डिस्क रीड में बदल जाती है।

Qdrant का डॉक्यूमेंटेशन इसे स्पष्ट करता है: "यदि आप RAM में आधे वेक्टर स्टोर करते हैं, तो सर्च लेटेंसी लगभग दोगुनी हो जाएगी।" इस वाक्य को ध्यान में रखकर योजना बनाएं।

जब इंडेक्स वास्तव में फिट न हो, तो हर विकल्प एक ऐसा समझौता होना चाहिए जिसे आप जानबूझकर करें।

  • वेक्टर्स को memory-map करें ताकि ऑपरेटिंग सिस्टम हॉट पेजों को कैश (cache) कर सके और कोल्ड पेजों को डिस्क पर छोड़ दे। इसे सहन करने योग्य बनाने के लिए नीचे तेज NVMe (non-volatile memory express) स्टोरेज की आवश्यकता होती है।
  • क्वांटाइज (Quantise) करें, प्रत्येक डाइमेंशन को चार बाइट्स के बजाय एक बाइट के रूप में स्टोर करें। यह एक छोटी, मापने योग्य रिकॉल (recall) लागत पर वेक्टर बाइट्स को चार गुना कम कर देता है।
  • pgvector में halfvec में कास्ट करें, जो एक-बाइट क्वांटाइजेशन की तुलना में कम रिकॉल नुकसान के साथ बाइट्स को आधा कर देता है।
  • छोटे मॉडल के साथ एम्बेड करें। यह सबसे सस्ता समाधान है और जिसे लोग अक्सर छोड़ देते हैं, क्योंकि इसका मतलब पूरे कॉर्पस (corpus) को फिर से एम्बेड करना होता है।

विफलता के प्रकार और आपको दिखाई देने वाली स्ट्रिंग्स

could not open extension control file. चल रहे Postgres मेजर वर्ज़न के लिए pgvector पैकेज इंस्टॉल नहीं है। sudo -u postgres psql -tAc 'SHOW server_version' के साथ वर्ज़न प्रिंट करें और संबंधित postgresql-NN-pgvector इंस्टॉल करें।

ERROR: expected 768 dimensions, not 1536. कॉलम टाइप और मॉडल मेल नहीं खाते हैं। आपने एम्बेडिंग मॉडल बदल दिया है और डेटा को फिर से एम्बेड नहीं किया है। यहाँ कोई आंशिक सुधार संभव नहीं है, क्योंकि दो अलग-अलग मॉडलों के वेक्टर्स की तुलना नहीं की जा सकती, इसलिए प्रत्येक पंक्ति को फिर से जनरेट करना होगा।

क्वेरी धीमी है और EXPLAIN एक sequential scan दिखाता है। इंडेक्स ऑपरेटर क्लास और क्वेरी ऑपरेटर मेल नहीं खाते हैं। vector_cosine_ops केवल <=> को सपोर्ट करता है। क्वेरी पर EXPLAIN ANALYZE चलाएँ और Index Scan using ... on chunks खोजें। यदि आपको इसके बजाय Seq Scan on chunks दिखाई देता है, तो उस ऑपरेटर क्लास के साथ इंडेक्स को फिर से बनाएँ जो उस ऑपरेटर से मेल खाता है जिसका आप वास्तव में उपयोग कर रहे हैं।

LIMIT से कम पंक्तियाँ हैं, और एक WHERE क्लॉज मौजूद है। यह ऊपर बताया गया फिल्टरिंग ट्रैप है। hnsw.ef_search को बढ़ाएँ, या pgvector 0.8 पर जाएँ और hnsw.iterative_scan सेट करें।

इंडेक्स बिल्ड प्रक्रिया समाप्त हो जाती है और psql में कोई त्रुटि नहीं दिखती। maintenance_work_mem को मशीन की अधिकांश क्षमता पर सेट किया गया है, जबकि shared_buffers और आपका एप्लिकेशन भी मेमोरी चाहते हैं, जिससे कर्नल का out-of-memory killer सक्रिय हो जाता है। sudo dmesg -T | grep -i 'killed process' वह लाइन दिखाता है जो postgres को नामित करती है। सेटिंग को कम करें, या किसी बड़े प्लान पर इंडेक्स बनाएँ और डंप को रिस्टोर करें।

एक का चयन करना

यदि आप पहले से ही Postgres चला रहे हैं और आपके पास कुछ मिलियन से कम vectors हैं, तो pgvector का उपयोग करें। Index डेटा के साथ ही रहता है, फ़िल्टरिंग एक WHERE clause है, और आपका मौजूदा बैकअप इसे पहले से ही कवर करता है। यदि index इतना बड़ा है कि उसे अपनी memory ceiling की आवश्यकता है, या आपको भारी payload फ़िल्टरिंग की आवश्यकता है, तो इसके साथ Qdrant चलाएं और संचालन के लिए एक दूसरी service को स्वीकार करें।

लगभग एक लाख vectors से कम के लिए, कुछ भी install करने से पहले brute-force scan को मापें। उस आकार पर perfect recall और बिना किसी build step के exhaustive search कोई समझौता नहीं है। यह सही उत्तर है, और इसके बजाय approximate index का उपयोग करने का अर्थ है उन milliseconds के बदले में tuning और RAM का दबाव लेना जिन्हें आप खर्च ही नहीं कर रहे थे।

FAQ

क्या मुझे dedicated vector database की आवश्यकता है, या Postgres पर्याप्त है?

यदि आपका data पहले से Postgres में है, तो pgvector अधिकांश comparisons की अपेक्षा कहीं अधिक समय तक पर्याप्त रहेगा। यह vectors को एक सामान्य column में store करता है, इसलिए filtered search एक WHERE clause है और आपका मौजूदा backup index को भी cover करता है। Dedicated store जैसे Qdrant पर तब जाएँ, जब vector workload के लिए अपना memory ceiling चाहिए या payload filtering और scalar या product quantisation की आवश्यकता हो, जो pgvector उपलब्ध नहीं कराता।

एक VPS में कितने vectors रखे जा सकते हैं?

अनुमान लगाने के बजाय number_of_vectors * dimensions * 4 bytes * 1.5 का उपयोग करके इसकी गणना करें। 768-dimension वाले 1 million vectors के लिए लगभग 4.3 GiB चाहिए, इसलिए 8 GB plan में Postgres के लिए भी पर्याप्त जगह बचती है। 3072-dimension वाले 1 million vectors के लिए लगभग 17 GiB चाहिए और इसके लिए कहीं बड़े plan की आवश्यकता होगी। इस संख्या पर सबसे अधिक प्रभाव आपके embedding model के dimension का होता है, इसलिए memory bill को ध्यान में रखकर model चुनें।

एक ही box पर network आपकी समस्या नहीं है, इसलिए उन दो चीजों पर ध्यान दें जो वास्तव में कारण हो सकती हैं। पहले embedding call का समय अलग से मापें, क्योंकि CPU पर query vector generate करने में अक्सर search से कहीं अधिक समय लगता है। दूसरे, जाँचें कि index RAM में है। HNSW search graph में random hops करती है, इसलिए graph के disk पर spill होने के बाद हर hop एक disk read बन सकता है। Qdrant की अपनी guidance के अनुसार, RAM में रखे vectors की संख्या आधी करने से search latency लगभग दोगुनी हो सकती है।

क्या मुझे HNSW index बनाना चाहिए?

लगभग 100,000 vectors से कम होने पर नहीं। Exhaustive scan प्रति query n * d * 4 bytes पढ़ता है। 768 dimensions वाले 100,000 vectors के लिए यह 307 MB है, और modern CPU perfect recall तथा बिना किसी build step के इसे कुछ दसियों milliseconds में stream कर सकता है। पहले अपने hardware पर scan को measure करें। Index तब बनाएँ, जब measured scan time वास्तव में बहुत धीमा हो, न कि केवल इसलिए कि किसी benchmark article में ऐसा कहा गया है।

m बढ़ाने की वास्तविक लागत क्या है?

Memory से कहीं अधिक build time और insert time की। 768 dimensions पर default m = 16 से m = 64 तक जाने पर graph links 128 से बढ़कर 512 bytes per vector हो जाते हैं। Vector data के 3072 bytes की तुलना में यह 384 bytes अतिरिक्त है, इसलिए total memory लगभग 12 percent बढ़ती है। लेकिन हर insert में चार गुना अधिक neighbours खोजकर link करने पड़ते हैं। पहले ef_search को tune करें, क्योंकि इसे बदलने की कोई लागत नहीं है और rebuild की आवश्यकता भी नहीं होती।

क्या यह लेख उपयोगी था?