# Bulk Ingestion और Batching — Vector Databases

Source: https://www.geekswithgeeks.com/hi/vector-databases/o-ingest

> लाखों vectors कुशलता और idempotent ढंग से लोड करें।

## Batches, retries और काम का क्रम

एक बार में एक request से vectors insert करना अधिकांश समय network round trips पर बर्बाद करता है। लिखावट **batch** करें (engine की सीमाओं के भीतर प्रति request सैकड़ों से कुछ हज़ार records), सीमित concurrency के साथ **समानांतर workers** उपयोग करें, और लिखावट **idempotent** बनाएँ (निश्चित ID से upsert) ताकि विफलता के बाद retries duplicates न बना सकें। **Embeddings** बनाना आम तौर पर सबसे धीमा और महँगा चरण है, इसलिए content hash से cache करें और embed भी batches में करें। **पहले बड़े load** के लिए table या collection बनाएँ, डेटा लोड करें, और जहाँ engine अनुमति दे **बाद में ANN index बनाएँ** (मौजूदा index में insert करने से तेज़), फिर गिनतियाँ और नमूना recall जाँचें। **चालू** अद्यतनों के लिए queue या change feed उपयोग करें ताकि ingestion retry और मॉनिटर हो सके, और **lag** ट्रैक करें (बदलाव से खोज योग्य होने तक का समय)।

## Ingest, shard, replicate, योजना

लिखावट batch करें, डेटा shards में फैलाएँ, उपलब्धता के लिए replicate करें, और ख़रीदने से पहले क्षमता का अंकगणित करें।

![चार काम: ingest, shard, replicate, योजना।](assets/figures/vector-databases/section-6-map.svg) — चित्र 6.1 — Ingest, shard, replicate और योजना।

## Batching क्यों मायने रखती है, चलाकर

मैंने यह सादा-Python (सिर्फ़ standard library) उदाहरण चलाया। यह मान ली गई संख्याओं (प्रति request 5 ms और प्रति vector 0.2 ms काम) वाला मॉडल है, किसी database का माप नहीं। 100,000 vectors एक-एक करके लोड करना round trips से हावी है (520 s), जबकि 1,000 के batches इसे लगभग 20 s कर देते हैं।

```python
import time
batch_sizes = [1, 10, 100, 1000]
calls_overhead = 0.005                      # assume 5 ms of network round-trip per request (illustrative)
per_item = 0.0002                           # assume 0.2 ms of work per vector (illustrative)
n = 100_000
for b in batch_sizes:
    requests = -(-n // b)
    total = requests * calls_overhead + n * per_item
    print(f"batch={b:5d} requests={requests:7d} estimated time={total:8.1f} s")

```

Output:

```
batch=    1 requests= 100000 estimated time=   520.0 s
batch=   10 requests=  10000 estimated time=    70.0 s
batch=  100 requests=   1000 estimated time=    25.0 s
batch= 1000 requests=    100 estimated time=    20.5 s
```

## एक बार embed करें, content hash से cache करें

अपरिवर्तित पाठ दोबारा embed करना पैसा बर्बाद करता है। जिन chunks का hash नहीं बदला उन्हें छोड़ें।

**Quiz:** लिखावट को निश्चित IDs से idempotent क्यों बनाएँ?

- [ ] Vectors बड़े करने के लिए
- [x] ताकि विफलताओं के बाद retries duplicates न बना सकें
- [ ] Indexes से बचने के लिए
- [ ] Embeddings तेज़ करने के लिए

*Answer:* ताकि विफलताओं के बाद retries duplicates न बना सकें. वही ID दो बार upsert करने से एक record बचता है।