---
title: "RAG चंक साइज़ और ओवरलैप: रिट्रीवल और टोकन लागत | BroadRouter"
description: "चंक साइज़ और ओवरलैप RAG रिकॉल, इंडेक्स साइज़, एम्बेडिंग लागत और हर क्वेरी में LLM को जाने वाले टोकन कैसे बदलते हैं, प्रकाशित नतीजों और हिसाब के साथ।"
url: https://broadrouter.com/hi/blog/rag-chunk-size-overlap/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/rag-chunk-size-overlap/) (2026-11-16 को अपडेट किया गया).

# RAG चंक साइज़ और ओवरलैप: रिट्रीवल और लागत पर इनका असर

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित 2026-11-15 · अपडेट किया गया 2026-11-16

लगभग 256 से 512 टोकन के चंक, 0 से 15% ओवरलैप, और अपनी क्वेरी पर ट्यून किए top-k से शुरू करें। बड़े चंक हर क्वेरी में LLM को जाने वाले टोकन बढ़ाते हैं। ओवरलैप एम्बेड और स्टोर होने वाले टोकन को साइज़ ÷ (साइज़ − ओवरलैप) से गुणा करता है, इसलिए 50% ओवरलैप इंडेक्स दोगुना करता है। प्रकाशित टेस्ट में छोटे या बिना ओवरलैप वाले चंक अक्सर बराबर या बेहतर रिकॉल देते मिले।

## मुख्य बातें

-   प्रति क्वेरी इनपुट मोटे तौर पर top-k × चंक साइज़ + प्रॉम्प्ट है। 5 × 400 से 8 × 1,024 टोकन पर जाने से हर क्वेरी पर लगभग 3.4 गुना इनपुट जाता है।
-   ओवरलैप इंडेक्स को साइज़ ÷ (साइज़ − ओवरलैप) से फुलाता है: 15% ओवरलैप लगभग 18% तक जोड़ता है (यहाँ मापे गए 10,000-टोकन डॉक्यूमेंट पर 17%), और 50% उसे दोगुना करता है।
-   Chroma के 2024 के मूल्यांकन में बिना ओवरलैप वाले 200 से 400 टोकन के चंक, 400 ओवरलैप वाले 800 टोकन के चंक के बराबर रहे या उनसे बेहतर, जो OpenAI file search का डिफ़ॉल्ट है।
-   NVIDIA के 2025 के टेस्ट में कोई एक सबसे अच्छा साइज़ नहीं मिला: तथ्य वाले सवालों में 256 से 512 टोकन आगे रहे, विश्लेषण वाले सवालों में 1,024 टोकन या एक पेज।
-   चंक साइज़ अपने एम्बेडिंग मॉडल के टोकन में गिनें। कुछ स्प्लिटर डिफ़ॉल्ट रूप से कैरेक्टर गिनते हैं।

**इस पेज पर**

1.  चंक साइज़ और ओवरलैप क्या बदलते हैं?
2.  प्रकाशित टेस्ट चंक साइज़ के बारे में क्या कहते हैं?
3.  ओवरलैप इंडेक्स को कितना फुलाता है?
4.  चंक साइज़ LLM बिल पर क्या असर डालता है?
5.  शब्द काटे बिना टोकन के हिसाब से चंक कैसे करें?
6.  अपने डेटा के लिए संख्याएँ कैसे चुनें?
7.  BroadNet Inference कहाँ फ़िट होता है

चंक साइज़ और ओवरलैप वे दो संख्याएँ हैं जो हर RAG पाइपलाइन शुरू में तय करती है और शायद ही कभी दोबारा देखती है। यही तय करती हैं कि आप कितने वेक्टर स्टोर करते हैं, कितने टोकन एम्बेड करते हैं, हर सवाल LLM को कितने टोकन भेजता है, और सही अंश मिलता भी है या नहीं। यह पोस्ट दिखाती है कि प्रकाशित टेस्ट में क्या मिला, फिर टोकन का हिसाब लगाती है, ताकि कुछ भी एम्बेड करने से पहले आप हर सेटिंग की लागत देख सकें।

अगर आप अभी तय कर रहे हैं कि RAG इस्तेमाल करना भी है या नहीं, तो [लॉन्ग कॉन्टेक्स्ट बनाम RAG](https://broadrouter.com/hi/blog/long-context-vs-rag/) से शुरू करें। अरबी डॉक्यूमेंट के लिए इस पोस्ट के साथ [अरबी RAG](https://broadrouter.com/hi/blog/arabic-rag-search/) और [अरबी टेक्स्ट नॉर्मलाइज़ेशन](https://broadrouter.com/hi/blog/arabic-text-normalization-search/) भी पढ़ें।

## चंक साइज़ और ओवरलैप क्या बदलते हैं?

-   **चंक साइज़** यह है कि आप जो हर टुकड़ा एम्बेड और रिट्रीव करते हैं, उसमें कितने टोकन जाते हैं।
-   **ओवरलैप** यह है कि लगातार चंक आपस में कितने टोकन साझा करते हैं, ताकि सीमा पर कटा वाक्य कम से कम एक चंक में पूरा दिखे।
-   **Top-k** यह है कि आप हर सवाल पर कितने चंक रिट्रीव करते हैं।

ये मिलकर चार चीज़ें तय करते हैं:

| मात्रा | फ़ॉर्मूला (लंबे डॉक्यूमेंट) |
| --- | --- |
| स्टोर हुए चंक | कॉर्पस टोकन ÷ (साइज़ − ओवरलैप) |
| एम्बेड हुए टोकन | कॉर्पस टोकन × साइज़ ÷ (साइज़ − ओवरलैप) |
| प्रति क्वेरी कॉन्टेक्स्ट | top-k × साइज़ |
| प्रति क्वेरी LLM इनपुट | top-k × साइज़ + सिस्टम प्रॉम्प्ट + सवाल |

पहली दो का भुगतान हर इंडेक्सिंग रन में एक बार होता है, और हर बार दोबारा चंक करने पर फिर से। आख़िरी का भुगतान हर सवाल पर होता है, हमेशा।

## प्रकाशित टेस्ट चंक साइज़ के बारे में क्या कहते हैं?

दो सार्वजनिक मूल्यांकन जानने लायक़ हैं, क्योंकि उन्होंने अलग-अलग चीज़ें मापीं।

**Chroma (Smith और Troynikov, जुलाई 2024)** ने रिट्रीवल को टोकन के स्तर पर मापा: प्रासंगिक टेक्स्ट का कितना हिस्सा रिट्रीव हुआ (रिकॉल), और जो रिट्रीव हुआ उसका कितना हिस्सा प्रासंगिक था। इसमें पाँच रिट्रीव किए गए चंक और OpenAI का text-embedding-3-large इस्तेमाल हुआ। चुनी हुई पंक्तियाँ:

| स्प्लिटर | साइज़ (टोकन) | ओवरलैप | रिकॉल | IoU |
| --- | --- | --- | --- | --- |
| Recursive | 800 | 400 | 85.4% | 1.5% |
| Token | 800 | 400 | 87.9% | 1.4% |
| Recursive | 400 | 200 | 88.1% | 3.3% |
| Recursive | 400 | 0 | 89.5% | 3.6% |
| Recursive | 200 | 0 | 88.1% | 6.9% |

IoU (intersection over union) मापता है कि रिट्रीव किए गए टेक्स्ट का कितना हिस्सा प्रासंगिक था, इसलिए यह बर्बाद टोकन का पैमाना भी है। 800/400 वाली पंक्तियाँ file search के लिए OpenAI के डिफ़ॉल्ट से मेल खाती हैं; token स्प्लिटर मानकर, Chroma ने पाया कि उस सेटिंग का रिकॉल औसत से थोड़ा नीचे था और बाक़ी पैमानों पर स्कोर सबसे कम। बिना ओवरलैप वाले छोटे चंक ने उतना या ज़्यादा रिकॉल दिया और उनमें अप्रासंगिक टेक्स्ट बहुत कम था।

**NVIDIA (जून 2025)** ने पाँच डेटासेट पर शुरू से अंत तक जवाब की सटीकता मापी, 15% ओवरलैप के साथ 128 से 2,048 के टोकन चंक पर, और साथ में पेज-स्तर और सेक्शन-स्तर की चंकिंग पर। पेज-स्तर की चंकिंग की औसत सटीकता सबसे ज़्यादा (0.648) और उतार-चढ़ाव सबसे कम रहा। सबसे अच्छा टोकन साइज़ सवालों पर निर्भर था: तथ्य वाले सेट में 256 से 512 टोकन आगे रहे, विश्लेषण वालों में 1,024 टोकन या पूरे पेज। दोनों छोर, 128 और 2,048, आम तौर पर कमज़ोर रहे।

दोनों एक बात पर सहमत हैं: **कोई सार्वभौमिक सबसे अच्छा साइज़ नहीं है**, और भारी ओवरलैप वाले बहुत बड़े चंक शायद ही कभी सही डिफ़ॉल्ट होते हैं।

## ओवरलैप इंडेक्स को कितना फुलाता है?

हर चंक साइज़ − ओवरलैप टोकन आगे बढ़ता है, इसलिए इंडेक्स में कॉर्पस की साइज़ ÷ (साइज़ − ओवरलैप) प्रतियाँ होती हैं। 10,000-टोकन डॉक्यूमेंट वाले 2,000,000-टोकन कॉर्पस के लिए:

| साइज़ | ओवरलैप | चंक | एम्बेड हुए टोकन | फुलाव |
| --- | --- | --- | --- | --- |
| 200 | 0 | 10,000 | 2,000,000 | 1.00× |
| 400 | 0 | 5,000 | 2,000,000 | 1.00× |
| 512 | 77 (15%) | 4,600 | 2,338,800 | 1.17× |
| 1,024 | 154 (15%) | 2,400 | 2,338,800 | 1.17× |
| 800 | 400 (50%) | 4,800 | 3,840,000 | 1.92× |
| 400 | 200 (50%) | 9,800 | 3,920,000 | 1.96× |

छोटे डॉक्यूमेंट थोड़ा कम फूलते हैं, क्योंकि हर एक का आख़िरी चंक अधूरा होता है। फ़ॉर्मूला ऊपरी सीमा देता है: एम्बेडिंग टोकन, वेक्टर स्टोरेज और री-इंडेक्सिंग समय में 15% ओवरलैप लगभग 18% ज़्यादा पड़ता है, और 50% लगभग 100% ज़्यादा।

ओवरलैप क्वेरी के समय भी महँगा पड़ता है। 50% ओवरलैप के साथ, एक ही सवाल के लिए रिट्रीव हुए दो पड़ोसी चंक अपना आधा टेक्स्ट दोहराते हैं। आप उन दोहराए टोकन का भुगतान करते हैं, और वे दूसरे प्रासंगिक अंशों को top-k से बाहर धकेल देते हैं।

BroadNet एम्बेडिंग नहीं बेचता, इसलिए बिल का यह हिस्सा आपके एम्बेडिंग प्रोवाइडर के पास जाता है। इसकी कीमत [एम्बेडिंग कॉस्ट कैलकुलेटर](https://broadrouter.com/tools/embedding-cost-calculator/) से निकालें।

## चंक साइज़ LLM बिल पर क्या असर डालता है?

हर सवाल top-k चंक और प्रॉम्प्ट भेजता है। मान लें महीने में 100,000 सवाल, सिस्टम प्रॉम्प्ट और सवाल के 600 टोकन, और हर बार वही 300 टोकन का जवाब:

| साइज़ × top-k | प्रति क्वेरी कॉन्टेक्स्ट | प्रति क्वेरी इनपुट | प्रति माह इनपुट |
| --- | --- | --- | --- |
| 200 × 10 | 2,000 | 2,600 | 260 मिलियन |
| 400 × 5 | 2,000 | 2,600 | 260 मिलियन |
| 512 × 5 | 2,560 | 3,160 | 316 मिलियन |
| 800 × 5 | 4,000 | 4,600 | 460 मिलियन |
| 1,024 × 5 | 5,120 | 5,720 | 572 मिलियन |
| 1,024 × 8 | 8,192 | 8,792 | 879 मिलियन |

हर पंक्ति में आउटपुट महीने में 30 मिलियन टोकन है, इसलिए सिर्फ़ इनपुट बदलता है। प्रति 1M टोकन कीमत पर मासिक इनपुट लागत आख़िरी कॉलम के मिलियन गुणा वह कीमत है। [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/) पर, $0.10 प्रति 1M इनपुट टोकन के हिसाब से, 1,024 × 8 वाला सेटअप महीने में इनपुट पर 879 × $0.10 पड़ता है, जबकि 400 × 5 पर 260 × $0.10। यह 3.4 गुना है, उस सेटिंग के लिए जिसका रिकॉल प्रकाशित टेस्ट में बेहतर नहीं दिखता। [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) ($0.175 इनपुट) या [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) ($0.78 इनपुट) पर अनुपात वही है और कुल रक़म बड़ी।

दो लीवर इसे मॉडल की कीमत से ज़्यादा हिलाते हैं:

1.  **साइज़ बढ़ाएँ तो k घटाएँ।** 200 × 10 और 400 × 5 उतना ही कॉन्टेक्स्ट भेजते हैं। साइज़ टेस्ट करते समय प्रति क्वेरी कॉन्टेक्स्ट लगभग स्थिर रखें, ताकि आप रिट्रीवल क्वालिटी की तुलना करें, कॉन्टेक्स्ट बजट की नहीं।
2.  **तय हिस्से को कैश करें।** सिस्टम प्रॉम्प्ट सबसे पहले रखें और उसे बाइट-दर-बाइट एक जैसा रखें, ताकि जिन मॉडल पर [कैश्ड इनपुट](https://broadrouter.com/hi/blog/cached-input-tokens-explained/) दर है, वहाँ वह उस दर पर बिल हो। रिट्रीव किए गए चंक हर सवाल पर बदलते हैं और शायद ही कैश होते हैं।

कॉन्टेक्स्ट की सीमाएँ भी मायने रखती हैं। Gemma 4 VL 26B प्रति अनुरोध 32,768 टोकन स्वीकार करता है, जो ऊपर की किसी भी पंक्ति के लिए काफ़ी है। अगर आप k × साइज़ को दसियों हज़ार टोकन की ओर धकेलते हैं, तो आप RAG से [लॉन्ग कॉन्टेक्स्ट](https://broadrouter.com/hi/blog/long-context-vs-rag/) की ओर बढ़ चुके हैं, और उस तुलना का अपना हिसाब है। [RAG चंकिंग कैलकुलेटर](https://broadrouter.com/tools/rag-chunking-calculator/) ये फ़ॉर्मूले आपके अपने कॉर्पस, चंक साइज़, ओवरलैप और top-k पर चलाता है।

## शब्द काटे बिना टोकन के हिसाब से चंक कैसे करें?

गिनती टोकन में करें, लेकिन कटाई ढाँचे पर। LangChain का `RecursiveCharacterTextSplitter` साइज़ अपने `length_function` से मापता है, जो डिफ़ॉल्ट रूप से कैरेक्टर की लंबाई है। तब 512 का “साइज़” 512 कैरेक्टर है, यानी अंग्रेज़ी के मोटे तौर पर 100 से 150 टोकन, और अरबी के लिए फिर एक अलग संख्या; देखें [अरबी में प्रति शब्द टोकन](https://broadrouter.com/hi/blog/tokens-per-word-arabic-english/)। एम्बेडिंग की सीमाएँ और LLM बिल टोकन में होते हैं।

यह चंकर पूरे पैराग्राफ़ को टोकन बजट तक भरता है और आख़िरी पैराग्राफ़ को ओवरलैप के रूप में आगे ले जाता है। पैराग्राफ़ की सीमा पर काटने से शब्द या मल्टी-बाइट अरबी कैरेक्टर नहीं टूटते, जो कच्ची टोकन विंडो कर सकती है।

```python
import tiktoken

enc = tiktoken.get_encoding("o200k_base")    # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))

def chunk(text, size=512, overlap=64):
    """Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
    chunks, cur, cur_len = [], [], 0
    for para in (p.strip() for p in text.split("\n\n")):
        if not para:
            continue
        n = count(para)
        if cur and cur_len + n > size:
            chunks.append("\n\n".join(cur))
            tail, t = [], 0
            for q in reversed(cur):                  # carry the end of this chunk forward
                if t + count(q) > overlap:
                    break
                tail.insert(0, q); t += count(q)
            cur, cur_len = tail, t
        cur.append(para); cur_len += n              # a paragraph over `size` stays whole
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks

def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
    index_tokens = corpus_tokens * size / (size - overlap)   # long-document limit
    per_query = k * size + prompt_tokens
    return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
            "input_per_query": per_query, "input_per_month": per_query * queries_per_month}

print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}
```

यहाँ ओवरलैप “ज़्यादा से ज़्यादा” है: ओवरलैप बजट से लंबा पैराग्राफ़ दोहराया नहीं जाता। `size` से लंबा एक अकेला पैराग्राफ़ पूरा रहता है; अगर आपके डॉक्यूमेंट में ऐसे पैराग्राफ़ हैं, तो पहले उन्हें वाक्यों पर तोड़ें। हर चंक के आगे उसके डॉक्यूमेंट का शीर्षक और सेक्शन हेडिंग जोड़ें, ताकि रिट्रीव हुआ चंक फिर भी बताए कि वह किस बारे में है। इससे हर चंक में कुछ टोकन जुड़ते हैं और अक्सर ओवरलैप से ज़्यादा मदद मिलती है।

## अपने डेटा के लिए संख्याएँ कैसे चुनें?

1.  **एक मूल्यांकन सेट बनाएँ।** 50 से 200 असली सवाल, हर एक के साथ वह अंश जो उसका जवाब देता है। स्कोरिंग [LLM मूल्यांकन गाइड](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/) में है।
2.  **कॉन्टेक्स्ट बजट तय रखें।** साइज़ की तुलना करते समय k × साइज़ को एक मान के आसपास रखें, जैसे 2,000 टोकन।
3.  **तीन साइज़ और दो ओवरलैप आज़माएँ।** जैसे 256, 512 और 1,024 टोकन, हर एक 0 और 15% ओवरलैप पर। k पर सही अंश का रिकॉल मापें।
4.  **ढाँचा आज़माएँ।** अगर आपके डॉक्यूमेंट में पेज या नंबर वाले सेक्शन हैं, तो टोकन साइज़ के मुक़ाबले पेज-स्तर या सेक्शन-स्तर के चंक टेस्ट करें। NVIDIA ने पेज-स्तर को सबसे स्थिर पाया।
5.  **सबसे अच्छे रिकॉल से एक-दो अंक के भीतर की सबसे सस्ती सेटिंग चुनें,** फिर [मासिक लागत के तरीक़े](https://broadrouter.com/hi/blog/estimate-llm-api-cost-before-launch/) से अपने क्वेरी वॉल्यूम पर उसकी कीमत निकालें।

यह पूरा कॉर्पस एम्बेड करने से पहले एक सैंपल पर करें। बाद में चंकिंग बदलने का मतलब है सब कुछ दोबारा एम्बेड करना।

## BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference RAG का जवाब वाला चरण सर्व करता है, रिट्रीवल नहीं। यह न एम्बेडिंग बेचता है न वेक्टर स्टोरेज, इसलिए इसे अपनी पसंद के एम्बेडिंग प्रोवाइडर और वेक्टर डेटाबेस के साथ जोड़ें। जवाब के लिए Gemma 4 VL 26B कम लागत वाला विकल्प है और $5 के शुरुआती क्रेडिट पर चलता है। Qwen3.8 27B (262,144-टोकन कॉन्टेक्स्ट) और GLM 5.3 (1,048,576) बड़े top-k या लंबे डॉक्यूमेंट के लिए ठीक हैं, टॉप-अप के बाद। अनुरोध के बाद प्रॉम्प्ट और रिट्रीव किए गए अंश रखे नहीं जाते। अगर आपका कॉर्पस इतना छोटा और स्थिर है कि कॉन्टेक्स्ट विंडो में समा जाए, तो [लॉन्ग कॉन्टेक्स्ट](https://broadrouter.com/hi/blog/long-context-vs-rag/) चंकिंग से पूरी तरह बेहतर हो सकता है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[एम्बेडिंग (embeddings)](https://broadrouter.com/hi/glossary/embeddings/)

एम्बेडिंग, फ़्लोटिंग-पॉइंट संख्याओं की सूचियाँ (वेक्टर) हैं जो कोई मॉडल टेक्स्ट, इमेज या दूसरे इनपुट को दर्शाने के लिए बनाता है। मिलते-जुलते अर्थ वाले इनपुट के वेक्टर पास-पास होते हैं, इसलिए वेक्टर के बीच की दूरी से सर्च नतीजों की रैंकिंग, दस्तावेज़ों का समूह बनाना या जुड़ी चीज़ें ढूँढना संभव होता है।

[RAG (retrieval-augmented generation)](https://broadrouter.com/hi/glossary/rag/)

RAG (retrieval-augmented generation) एक पैटर्न है जिसमें ऐप्लिकेशन पहले किसी बाहरी स्टोर, जैसे सर्च या वेक्टर इंडेक्स, से सवाल से जुड़े हिस्से निकालता है, और फिर उन्हें प्रॉम्प्ट में जोड़ता है, ताकि लैंग्वेज मॉडल सिर्फ़ अपनी याददाश्त के बजाय उस टेक्स्ट से जवाब दे सके।

[चंकिंग (chunking, RAG)](https://broadrouter.com/hi/glossary/chunking/)

Chunking retrieval पाइपलाइन का वह चरण है जो दस्तावेज़ों को embed और इंडेक्स करने से पहले छोटे टुकड़ों, यानी chunks, में बाँटता है। Chunk size तय करता है कि हर टुकड़े में कितना टेक्स्ट हो, और chunk overlap पड़ोसी chunks के बीच कुछ टेक्स्ट दोहराता है ताकि सीमा पर कटे विचार न खोएँ।

[वेक्टर डेटाबेस (vector database)](https://broadrouter.com/hi/glossary/vector-database/)

वेक्टर डेटाबेस एक डेटा स्टोर है जो embedding वेक्टर, अक्सर उनके सोर्स टेक्स्ट और मेटाडेटा के साथ, रखता है और nearest-neighbour क्वेरी का जवाब देता है: क्वेरी वेक्टर मिलने पर यह सबसे मिलते-जुलते सेव वेक्टर लौटाता है, आम तौर पर cosine दूरी, Euclidean दूरी या inner product से।

[सिस्टम प्रॉम्प्ट (system prompt)](https://broadrouter.com/hi/glossary/system-prompt/)

सिस्टम प्रॉम्प्ट वह निर्देश टेक्स्ट है जो कोई ऐप्लिकेशन बातचीत से पहले लैंग्वेज मॉडल को भेजता है, आम तौर पर system या developer रोल वाले मैसेज के रूप में। यह मॉडल की भूमिका, नियम, लहजा और आउटपुट फ़ॉर्मैट तय करता है, और टकराव होने पर मॉडल को यूज़र के मैसेज के बजाय इसी का पालन करना होता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[अरबी टेक्स्ट नॉर्मलाइज़ेशन (Arabic text normalization)](https://broadrouter.com/hi/glossary/arabic-text-normalization/)

अरबी टेक्स्ट नॉर्मलाइज़ेशन वह चरण है जो मिलान से पहले एक ही शब्द की अलग-अलग वर्तनियों को एक रूप में बदलता है: डायक्रिटिक्स और tatweel हटाना, alef के रूप एक करना, और अक्सर ى को ي और ة को ه करना। यह सर्च key और मूल्यांकन पर लगता है, दिखाए जाने वाले टेक्स्ट पर नहीं।

## अक्सर पूछे जाने वाले सवाल

### RAG के लिए अच्छा चंक साइज़ क्या है?

लगभग 256 से 512 टोकन से शुरू करें और टेस्ट करें। Chroma के मूल्यांकन में बिना ओवरलैप वाले 200 से 400 टोकन ने अच्छा प्रदर्शन किया। NVIDIA ने पाया कि तथ्य वाले सवालों के लिए 256 से 512 टोकन ठीक रहे, जबकि विश्लेषण वाले सवाल 1,024-टोकन या पेज-स्तर के चंक के साथ बेहतर रहे।

### चंक ओवरलैप कितना रखना चाहिए?

ज़्यादातर डिफ़ॉल्ट से कम। NVIDIA ने एक डेटासेट पर 10%, 15% और 20% आज़माए, जिनमें 15% सबसे अच्छा रहा। Chroma ने पाया कि बिना ओवरलैप वाली सेटिंग अक्सर बराबर या बेहतर स्कोर करती थीं। ओवरलैप का हर अंक एम्बेड, स्टोर और भेजने के लिए टोकन जोड़ता है।

### क्या बड़ा चंक साइज़ ज़्यादा महँगा पड़ता है?

ओवरलैप न हो तो एम्बेड करने में नहीं: कॉर्पस उतने ही टोकन का रहता है। प्रति क्वेरी ज़्यादा पड़ता है, क्योंकि हर रिट्रीव किया गया चंक लंबा होता है, तो top-k × चंक साइज़ बढ़ता है। साइज़ बढ़ाएँ तो k घटाएँ।

### चंक साइज़ टोकन में मापा जाता है या कैरेक्टर में?

यह स्प्लिटर पर निर्भर है। LangChain का RecursiveCharacterTextSplitter अपने length\_function से मापता है, जो डिफ़ॉल्ट रूप से कैरेक्टर की लंबाई है। एम्बेडिंग की सीमाएँ और LLM बिल टोकन में होते हैं, इसलिए टोकन काउंटर पास करें।

### चंक साइज़ बदलने पर क्या दोबारा एम्बेड करना पड़ता है?

हाँ। नई सीमाएँ नए चंक बनाती हैं, और हर एक को नया वेक्टर चाहिए। दोबारा एम्बेड करने में पूरे इंडेक्स की लागत फिर लगती है, इसलिए पूरा कॉर्पस एम्बेड करने से पहले एक सैंपल पर चंकिंग तय कर लें।

## आगे पढ़ें

-   [लॉन्ग कॉन्टेक्स्ट बनाम RAG: कब 1M टोकन वेक्टर DB की जगह लेते हैं](https://broadrouter.com/hi/blog/long-context-vs-rag/)
-   [अरबी RAG: normalisation, chunking और retrieval जो सच में काम करे](https://broadrouter.com/hi/blog/arabic-rag-search/)
-   [सर्च और RAG के लिए अरबी टेक्स्ट normalization: क्या बदलें, क्या नहीं](https://broadrouter.com/hi/blog/arabic-text-normalization-search/)
-   [फ़ीचर लॉन्च से पहले LLM API की लागत का अनुमान कैसे लगाएँ](https://broadrouter.com/hi/blog/estimate-llm-api-cost-before-launch/)
-   [कैश्ड इनपुट टोकन क्या हैं: LLM API का बिल कैसे घटाएँ](https://broadrouter.com/hi/blog/cached-input-tokens-explained/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**स्रोत**

-   [Smith और Troynikov, Evaluating Chunking Strategies for Retrieval, Chroma तकनीकी रिपोर्ट, जुलाई 2024 (2026-11-15 को जाँचा गया)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, जून 2025 (2026-11-15 को जाँचा गया)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [OpenAI रिट्रीवल गाइड: डिफ़ॉल्ट 800-टोकन चंक और 400-टोकन ओवरलैप, chunking\_strategy की सीमाएँ (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/guides/retrieval)
-   [LangChain डॉक्स, RecursiveCharacterTextSplitter: चंक साइज़ length\_function से मापा जाता है, डिफ़ॉल्ट रूप से कैरेक्टर (2026-11-15 को जाँचा गया)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [BroadNet Inference कीमतें और API रेफ़रंस: मॉडल, कॉन्टेक्स्ट लंबाई, कैश्ड इनपुट (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-rag-chunk-size-overlap&utm_content=sources)
