---
title: "सर्च और RAG के लिए अरबी टेक्स्ट normalization | BroadRouter"
description: "तश्कील, alef के रूप, ta marbuta, hamza, फ़ारसी अक्षर, अंक और Unicode: अरबी normalization के कौन-से नियम सर्च में मदद करते हैं, कौन नुक़सान, और टेस्टेड Python।"
url: https://broadrouter.com/hi/blog/arabic-text-normalization-search/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

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

# सर्च और RAG के लिए अरबी टेक्स्ट normalization: क्या बदलें, क्या नहीं

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

सर्च और RAG index के लिए स्टोर की गई कॉपी और हर query, दोनों को एक ही तरह normalize करें: Unicode NFKC, तश्कील और tatweel हटाएँ, alef के रूप एक करें, ى को ي और ة को ه में बदलें, और अंक बदलें। दिखाने और LLM के लिए मूल टेक्स्ट रखें। hamza के आधार और ta marbuta को ट्यून करने लायक़ मानें: ये recall बढ़ाते हैं पर कुछ अलग शब्दों को मिला देते हैं।

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

-   सर्च key को normalize करें, उस टेक्स्ट को कभी नहीं जिसे आप दिखाते या उद्धृत करते हैं। मूल को उसके साथ स्टोर करें।
-   TREC-2001 के अरबी समाचार संग्रह पर एक क्लासिक अध्ययन में सिर्फ़ normalization ने average precision को .194 से .238 किया, और ऊपर से light stemming ने .376 तक पहुँचाया।
-   पहले Unicode NFKC चलाएँ। यह टूटे हुए hamza को जोड़ता है, presentation forms और ligatures को खोलता है, और आगे के नियमों को भरोसेमंद बनाता है।
-   लाइब्रेरियाँ असहमत हैं। PyArabic का normalize\_alef ى को ا में बदलता है; CAMeL Tools ى को ي में। नियमों का एक set चुनें और हर जगह वही इस्तेमाल करें।
-   Embedding सर्च के लिए अपनी queries पर normalized और कच्चे इनपुट दोनों को टेस्ट करें। Normalization के नियम keyword सर्च पर मापे गए थे।

**इस पेज पर**

1.  क्या normalization सच में retrieval में मदद करता है?
2.  क्या normalize करें, और हर नियम की क्या क़ीमत है?
3.  Unicode normalization पहले क्यों आना चाहिए?
4.  क्या normalize नहीं करना चाहिए?
5.  CAMeL Tools, PyArabic और Lucene में क्या फ़र्क़ है?
6.  टेस्ट किया हुआ normalizer कैसा दिखता है?
7.  Normalization, embeddings और RAG में कैसे फ़िट होता है?
8.  BroadNet Inference कहाँ फ़िट होता है

अरबी में एक ही शब्द कई तरह से लिखा जा सकता है। यूज़र احمد टाइप करता है; दस्तावेज़ में أَحْمَد लिखा है। जो सर्च index अक्षरों को हूबहू मिलाता है, वह यह मेल चूक जाता है, और RAG पाइपलाइन का keyword वाला आधा हिस्सा भी। Normalization तुलना से पहले रूपों को एक रूप में बदलकर इसे ठीक करता है। लापरवाही से करने पर यह अलग-अलग अर्थ वाले शब्दों को भी मिला देता है। यह पोस्ट नियम-दर-नियम चलती है: हर नियम क्या करता है, कब लगाएँ, क्या तोड़ता है, और मुख्य लाइब्रेरियाँ कैसे अलग हैं। आख़िर में टेस्टेड Python है।

पूरी अरबी RAG पाइपलाइन (chunking, hybrid सर्च, हवालों वाले जवाब) के लिए देखें [काम करने वाला अरबी RAG](https://broadrouter.com/hi/blog/arabic-rag-search/)। यह पोस्ट normalization वाले चरण में और गहराई तक जाती है।

## क्या normalization सच में retrieval में मदद करता है?

हाँ, keyword सर्च के लिए, और सबूत पुराना है पर साफ़ है। Larkey, Ballesteros और Connell (SIGIR 2002) ने TREC-2001 समाचार संग्रह पर अरबी retrieval टेस्ट किया। Stemming से पहले उन्होंने corpus और queries को normalize किया: हरकतें और विराम चिह्न हटाए, alef के रूप एक किए, और शब्द के अंत के ى और ة बदले। उनके monolingual नतीजे, बिना विस्तार वाली queries के साथ:

| Processing | Average precision | कच्चे के मुक़ाबले बदलाव (राउंड किए आँकड़ों से) |
| --- | --- | --- |
| कच्चा टेक्स्ट | .194 | — |
| Normalized | .238 | +22.7% |
| Normalized + light stemming (light8) | .376 | +93.8% |

दो सावधानियाँ। यह समाचारों पर 2002 का keyword retrieval है, embedding सर्च नहीं। और सबसे बड़ा फ़ायदा light stemming (و और ال जैसे prefixes और आम suffixes हटाना) से आया, जो normalization से अलग चरण है। Lucene का `ArabicAnalyzer` और Elasticsearch का `arabic` analyzer दोनों लगाते हैं: पहले normalizer, फिर light stemmer।

## क्या normalize करें, और हर नियम की क्या क़ीमत है?

| नियम | उदाहरण | सर्च index | जोखिम |
| --- | --- | --- | --- |
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | हाँ, हमेशा पहले | दूसरी लिपियों के compatibility अक्षर भी बदलता है |
| अदृश्य निशान हटाएँ | zero-width joiners, RLM/LRM, BOM | हाँ | अरबी के लिए कोई नहीं; फ़ारसी में ZWNJ मायने रखता है |
| तश्कील हटाएँ | أَحْمَدُ → أحمد | हाँ | सिर्फ़ स्वरों से अलग पहचाने जाने वाले शब्द मिल जाते हैं |
| Tatweel (ـ) हटाएँ | الـــمدينة → المدينة | हाँ | कोई नहीं |
| Alef एक करें | أ إ آ ٱ → ا | हाँ | कुछ जोड़े मिल जाते हैं: سأل (पूछा) और سال (बहा) |
| Alef maksura | ى → ي | आमतौर पर | على (पर) और علي (अली) मिल जाते हैं |
| Ta marbuta | ة → ه | आमतौर पर | كتابة (लेखन) और كتابه (उसकी किताब) मिल जाते हैं |
| Hamza के आधार | ؤ ئ → ء | वैकल्पिक | مسؤول और مسئول मिलते हैं (अच्छा) पर कुछ अलग शब्द भी |
| फ़ारसी अक्षर | ی → ي, ک → ك | हाँ, अगर यूज़र्स के पास फ़ारसी कीबोर्ड हैं | अरबी टेक्स्ट के लिए कोई नहीं |
| अंक | ٢٠٢٦ और ۲۰۲۶ → 2026 | हाँ | कोई नहीं; दिखाने के लिए मूल रखें |

पहला कॉलम index key और query के लिए है। जो टेक्स्ट आप स्टोर करते, दिखाते और मॉडल को देते हैं, वह जैसा लिखा है वैसा ही रहता है।

## Unicode normalization पहले क्यों आना चाहिए?

एक ही दिखने वाला अक्षर अलग-अलग तरह से स्टोर हो सकता है। أ एक code point (U+0623) हो सकता है या सादा alef और उसके बाद combining hamza (U+0627 U+0654)। पुराने PDF और कुछ कीबोर्ड अरबी presentation forms (U+FB50 से U+FEFF) बनाते हैं, जैसे एक-अक्षर वाला lam-alef ﻻ। [Unicode normalization](https://unicode.org/reports/tr15/) में NFC, hamza को alef पर जोड़ता है, और NFKC presentation forms और ligatures को भी खोलता है। Python में `unicodedata.normalize("NFKC", "ﻻ")` لا लौटाता है, और `ﷲ` الله बन जाता है।

इसे सबसे पहले चलाएँ। वरना أ बदलने वाला regex टूटे हुए रूप को चूक जाता है। एक दूसरा जाल भी है: CAMeL Tools का `dediac_ar` अपने `AR_DIAC_CHARSET` (U+064B से U+0652 और U+0670) के अक्षर हटाता है। उस set में combining hamza और madda के निशान (U+0653 से U+0655) नहीं हैं, इसलिए टूटे हुए टेक्स्ट पर वे हरकतें हटाने के बाद भी बचे रहते हैं। NFKC उन्हें पहले जोड़ देता है।

NFKC एक compatibility mapping है। यह अरबी के बाहर के अक्षर भी बदलता है, जैसे full-width लैटिन अक्षर। सर्च key में आमतौर पर यही चाहिए, और यह मूल को उसके साथ रखने की एक और वजह है।

## क्या normalize नहीं करना चाहिए?

-   **वह टेक्स्ट जो आप दिखाते, उद्धृत या quote करते हैं।** Normalized अरबी ग़लत वर्तनी वाली लगती है (المدينه)। मूल को key के साथ स्टोर करें।
-   **जो आप LLM को भेजते हैं।** मॉडल hamza और तश्कील ठीक पढ़ लेते हैं, और हूबहू टेक्स्ट नाम और उद्धरण सही रखता है। तश्कील हटाने से कुछ टोकन बचते हैं; सटीकता के बदले यह सौदा करने से पहले [अरबी टोकन काउंटर](https://broadrouter.com/tools/arabic-token-counter/) से देखें कि कितने।
-   **ऐसा टेक्स्ट जहाँ निशान अर्थ रखते हैं:** क़ुरआन, हदीस, शायरी, बच्चों की किताबें, उच्चारण और हरकतें लगाने वाले काम (देखें [LLM से हरकतें लगाना](https://broadrouter.com/hi/blog/arabic-diacritization-llm/))।
-   **वर्तनी या व्याकरण सुधार:** पहले normalize करने से वही hamza और taa marbuta की ग़लतियाँ मिट जाती हैं जिन्हें आप सुधारना चाहते हैं; देखें [LLM से अरबी व्याकरण और वर्तनी सुधार](https://broadrouter.com/hi/blog/arabic-grammar-spelling-correction-llm/)।
-   **Identifiers।** प्रोडक्ट कोड, ईमेल, URL और लैटिन टेक्स्ट अरबी नियमों से नहीं गुज़रने चाहिए। Normalization सिर्फ़ अरबी लिपि वाले फ़ील्ड पर, या सिर्फ़ अरबी टोकन पर लगाएँ।
-   **ऐसे फ़ील्ड जिन्हें लोग हूबहू सर्च करते हैं।** क़ानूनी नामों या ID जैसे फ़ील्ड के लिए एक कच्ची कॉपी भी index करें, ताकि सटीक मेल फिर भी सबसे ऊपर आ सके।

## CAMeL Tools, PyArabic और Lucene में क्या फ़र्क़ है?

ये एक जैसे नियम लागू नहीं करते, और इन्हें मिलाने से ऐसा index और queries बनती हैं जो कभी मेल नहीं खातीं। हमने हर लाइब्रेरी का डॉक्यूमेंटेशन और source पढ़ा, और PyArabic 0.6.15 चलाया:

| Function | असल में क्या करता है |
| --- | --- |
| CAMeL `normalize_unicode` | NFKC (या `compatibility=False` के साथ NFC); ﷼ को ريال और ﷽ को उसके पूरे वाक्यांश में भी फैलाता है |
| CAMeL `normalize_alef_ar` | إ أ ٱ آ → ا |
| CAMeL `normalize_alef_maksura_ar` | ى → ي |
| CAMeL `normalize_teh_marbuta_ar` | ة → ه |
| CAMeL `dediac_ar` | U+064B से U+0652 और U+0670 हटाता है; tatweel छोड़ देता है |
| PyArabic `strip_tashkeel` | shadda समेत सभी harakat हटाता है |
| PyArabic `strip_tatweel` | ـ हटाता है |
| PyArabic `normalize_alef` | alef का हर रूप **और ى** → ا, इसलिए إلى बन जाता है الا |
| PyArabic `normalize_hamza` | डिफ़ॉल्ट तरीक़ा hamza के हर रूप को ء में बदलता है, أ समेत, इसलिए أحمد बन जाता है ءحمد |
| Lucene `ArabicNormalizer` | alef पर hamza वाले रूप → ا, ة → ه, ى → ي, harakat और tatweel हटाता है |

PyArabic वाली पंक्तियाँ लोगों को चौंकाती हैं। उसके `normalize_alef` का docstring कहता है कि alef maksura अपवाद है, लेकिन 0.6.15 में `ALEFAT` set में ى शामिल है, और function उसे ا में बदल देता है। उसका `normalize_hamza` hamza की परवाह न करने वाले मिलान के लिए बना है, आम सर्च के लिए नहीं। क्रम भी मायने रखता है: पहले alef normalization चलाएँ, तो `normalize_hamza` सिर्फ़ ؤ, ئ और ء को छूता है, इसलिए مسؤول और مسئول दोनों مسءول बन जाते हैं। उसका `tasheel` तरीक़ा इसकी जगह مسوول और مسيول देता है, जो आपस में मेल नहीं खाते।

Elasticsearch का `arabic_normalization` filter, Lucene normalizer इस्तेमाल करता है, इसलिए जो Python पाइपलाइन किसी Elasticsearch index से मेल खाना चाहती है, उसे Lucene के नियम हूबहू अपनाने चाहिए। यानी ى → ي, ى → ا नहीं।

## टेस्ट किया हुआ normalizer कैसा दिखता है?

यह function Lucene के फ़ैसलों का पालन करता है, Unicode, अंकों और फ़ारसी अक्षरों को संभालना जोड़ता है, और जोखिम वाले नियमों को चालू-बंद करने लायक़ बनाता है। यह सिर्फ़ standard library इस्तेमाल करता है।

```python
import re
import unicodedata

DIACRITICS = re.compile("[ً-ٰٟ]")  # tashkeel, extra marks, superscript alef
INVISIBLE = re.compile("[​-‏‪-‮⁦-⁩﻿]")  # zero-width, bidi
ALEF = re.compile("[آأإٱ]")    # آ أ إ ٱ -> ا
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹", "0123456789" * 2)
FARSI = str.maketrans({"ی": "ي", "ک": "ك"})  # ی -> ي, ک -> ك

def normalize(text, *, alef=True, alef_maksura=True, ta_marbuta=True,
              hamza_seats=False, digits=True):
    text = unicodedata.normalize("NFKC", text)     # compose marks, unpack ligatures
    text = INVISIBLE.sub("", text)
    text = DIACRITICS.sub("", text).replace("ـ", "")   # tashkeel, tatweel
    text = text.translate(FARSI)
    if alef:
        text = ALEF.sub("ا", text)
    if alef_maksura:
        text = text.replace("ى", "ي")    # ى -> ي
    if ta_marbuta:
        text = text.replace("ة", "ه")    # ة -> ه
    if hamza_seats:
        text = re.sub("[ؤئ]", "ء", text)  # ؤ ئ -> ء
    if digits:
        text = text.translate(DIGITS)
    return text
```

हमारी टेस्ट strings पर इसने यह लौटाया:

| इनपुट | आउटपुट | नोट |
| --- | --- | --- |
| أَحْمَدُ | احمد | तश्कील और hamza हटे |
| الـــمدينة | المدينه | Tatweel और ta marbuta |
| إلى | الي | Alef और alef maksura |
| ا + U+0654 + مل | امل | टूटा hamza जुड़ा, फिर एक किया गया |
| ﻻبد | لابد | Presentation form खोला गया |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | अरबी-भारतीय और फ़ारसी अंक |
| مسؤول / مسئول | `hamza_seats=True` के साथ दोनों مسءول | डिफ़ॉल्ट रूप से बिना बदलाव |
| فارسی | فارسي | फ़ारसी ya |

इसे दो जगह इस्तेमाल करें: जब आप index key बनाते हैं और जब आप query पढ़ते हैं। `original` और `normalize(original)` साथ-साथ स्टोर करें, दूसरे पर सर्च करें और पहला लौटाएँ। मुफ़्त [अरबी टेक्स्ट normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) में आप टेक्स्ट पेस्ट करके अपनी सेटिंग्स चुनने से पहले हर नियम का असर देख सकते हैं।

## Normalization, embeddings और RAG में कैसे फ़िट होता है?

RAG पाइपलाइन में आमतौर पर दो retrievers होते हैं: keyword सर्च (BM25) और [embeddings](https://broadrouter.com/hi/glossary/embeddings/)। Normalization साफ़ तौर पर keyword वाले हिस्से में मदद करता है। Embedding वाले हिस्से पर ऊपर का सबूत लागू नहीं होता: embedding मॉडल कच्चे टेक्स्ट पर trained होते हैं, और बहुत से पहले ही احمد और أحمد को पास-पास रखते हैं। Embedding से पहले normalize करना मदद कर सकता है, कुछ न करे, या नुक़सान करे। जाने-पहचाने जवाबों वाली 50 से 100 असली queries बनाएँ, उन्हें कच्चे और normalized इनपुट के साथ चलाएँ, और जो ज़्यादा recall दे वह रखें। जो भी चुनें, उसे दस्तावेज़ों और queries पर एक जैसा लगाएँ।

Normalization टोकन की गिनती भी थोड़ी घटाता है, क्योंकि हरकतें और tatweel [tokenizer](https://broadrouter.com/hi/glossary/tokenizer/) के लिए अतिरिक्त अक्षर हैं। मापे गए अनुपात [tokenizer efficiency dataset](https://broadrouter.com/data/tokenizer-efficiency/) और [अरबी में प्रति शब्द टोकन](https://broadrouter.com/hi/blog/tokens-per-word-arabic-english/) में हैं। Speech recognition को निष्पक्ष स्कोर करने के लिए भी यही normalization इस्तेमाल होता है; देखें [अरबी WER की व्याख्या](https://broadrouter.com/hi/blog/arabic-asr-wer-explained/)।

Arabizi (लैटिन अक्षरों में अरबी) को बिल्कुल अलग तरीक़ा चाहिए: [LLM, Arabizi को कैसे संभालते हैं](https://broadrouter.com/hi/blog/arabizi-llm-handling/)।

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

Normalization आपके अपने कोड में चलता है, इसलिए इसके लिए कोई API नहीं चाहिए। BroadNet Inference retrieval के बाद आता है। यह embeddings नहीं बेचता, इसलिए अपनी पसंद का retriever और embeddings प्रोवाइडर जवाब वाले चरण के लिए BroadNet चैट मॉडल के साथ जोड़ें। [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और DeepSeek V4.1 Flash 1,048,576 टोकन का कॉन्टेक्स्ट लेते हैं, इसलिए आप बहुत से निकाले गए अंश उनकी मूल, बिना normalize की अरबी में भेज सकते हैं। अरबी क्वालिटी पर मॉडल चुनने के लिए देखें [अरबी के लिए LLM चुनना](https://broadrouter.com/hi/blog/choosing-an-llm-for-arabic/)। अगर आपको सिर्फ़ keyword सर्च चाहिए, तो शायद Elasticsearch का बिल्ट-इन `arabic` analyzer ही काफ़ी हो।

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

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

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

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

[हम्ज़ा (hamza)](https://broadrouter.com/hi/glossary/hamza/)

हम्ज़ा (ء) ग्लॉटल स्टॉप के लिए अरबी अक्षर है। यह अकेले या किसी कुर्सी पर लिखा जाता है: अलिफ़ (أ إ), वाव (ؤ) या ये (ئ), और آ अलिफ़ को मद्दा के साथ जोड़ता है। टाइप किए टेक्स्ट में यह एक-सा नहीं लिखा जाता, सो सर्च इंजन और स्पीच स्कोरिंग अक्सर अलिफ़ वाले रूपों को ا में बदल देते हैं।

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

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

[Unicode नॉर्मलाइज़ेशन (Unicode normalization)](https://broadrouter.com/hi/glossary/unicode-normalization/)

Unicode नॉर्मलाइज़ेशन टेक्स्ट को एक मानक रूप में बदलता है, ताकि एक जैसी दिखने वाली स्ट्रिंग एक जैसे कोड पॉइंट इस्तेमाल करें। चार रूप हैं NFD, NFC, NFKD और NFKC; K वाले रूप compatibility कैरेक्टर, जैसे अरबी presentation forms और ligatures, को भी सामान्य अक्षरों में बदल देते हैं।

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

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

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

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

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

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

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

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

[टोकनाइज़र (tokenizer)](https://broadrouter.com/hi/glossary/tokenizer/)

टोकनाइज़र वह हिस्सा है जो टेक्स्ट को इंटीजर टोकन ID के उस क्रम में बदलता है जिसे लैंग्वेज मॉडल पढ़ता है, और जनरेट हुई ID को वापस टेक्स्ट में बदलता है। हर मॉडल अपने टोकनाइज़र के साथ आता है, इसलिए एक ही टेक्स्ट अलग-अलग मॉडलों पर अलग संख्या में टोकन बना सकता है।

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

### क्या अरबी टेक्स्ट index करने से पहले तश्कील (हरकतें) हटा दूँ?

सर्च के लिए, हाँ: ज़्यादातर queries और ज़्यादातर आधुनिक टेक्स्ट में हरकतें नहीं होतीं, इसलिए वरना हरकतों वाले दस्तावेज़ मेल नहीं खाएँगे। उन्हें index key और query से हटाएँ, दिखाने के लिए मूल टेक्स्ट रखें, और क़ुरआन, शायरी या उच्चारण वाले कामों में उन्हें रखें जहाँ वे अर्थ रखती हैं।

### क्या ta marbuta (ة) को ha (ه) में normalize करना चाहिए?

सर्च के लिए आमतौर पर हाँ, क्योंकि बहुत से लोग शब्द के अंत में ه टाइप करते हैं। यह कुछ जोड़ों को मिला देता है, जैसे كتابة (लेखन) और كتابه (उसकी किताब)। अगर आपके क्षेत्र में ये टकराव मायने रखते हैं, तो ة रखें और दोनों सेटिंग्स टेस्ट करें।

### Elasticsearch में अरबी normalization क्या करता है?

arabic\_normalization token filter, Lucene का ArabicNormalizer इस्तेमाल करता है: alef पर hamza वाले रूप सादे alef में, ta marbuta को ha में, alef maksura को ya में, और harakat और tatweel हटाना। बिल्ट-इन arabic analyzer इसमें stop words और एक stemmer जोड़ता है जो जुड़े हुए articles, conjunctions, prepositions और आम suffixes हटाता है।

### क्या अरबी normalize करने से embedding सर्च में मदद मिलती है?

यह साबित नहीं है। मापे गए फ़ायदे keyword retrieval से आते हैं। Embedding मॉडल कच्चे टेक्स्ट से सीखते हैं और अक्सर वर्तनी के रूप संभाल लेते हैं, इसलिए तय करने से पहले असली queries का एक छोटा set बनाएँ और normalization के साथ और बिना recall मिलाएँ।

### क्या LLM को भेजने से पहले अरबी टेक्स्ट normalize करूँ?

आमतौर पर नहीं। मूल टेक्स्ट भेजें ताकि उद्धरण, नाम और हवाले बिल्कुल सही रहें। तश्कील हटाने से कुछ टोकन बचते हैं, लेकिन ऐसा तभी करें जब काम को उन निशानों की ज़रूरत न हो।

## आगे पढ़ें

-   [अरबी RAG: normalisation, chunking और retrieval जो सच में काम करे](https://broadrouter.com/hi/blog/arabic-rag-search/)
-   [अरबी बनाम अंग्रेज़ी में प्रति शब्द टोकन: अरबी महँगी क्यों पड़ती है](https://broadrouter.com/hi/blog/tokens-per-word-arabic-english/)
-   [अरबी ASR में word error rate (WER) क्या है, आसान भाषा में](https://broadrouter.com/hi/blog/arabic-asr-wer-explained/)
-   [Arabizi और LLM: 3 और 7 जैसे अंकों वाली Franco-Arabic को संभालना](https://broadrouter.com/hi/blog/arabizi-llm-handling/)
-   [अरबी के लिए LLM API कैसे चुनें: क्या-क्या टेस्ट करें](https://broadrouter.com/hi/blog/choosing-an-llm-for-arabic/)
-   [LLM से अरबी named entity extraction: JSON, तारीख़ें और जाँच](https://broadrouter.com/hi/blog/arabic-named-entity-extraction-llm/)
-   [LLM से अरबी टेक्स्ट में हरकतें (तश्कील) लगाना: प्रॉम्प्ट, जाँच, DER](https://broadrouter.com/hi/blog/arabic-diacritization-llm/)
-   [LLM से अरबी व्याकरण और वर्तनी सुधार: एक how-to](https://broadrouter.com/hi/blog/arabic-grammar-spelling-correction-llm/)
-   [अरबी रिकॉर्डिंग से मीटिंग मिनट्स: एक API पाइपलाइन](https://broadrouter.com/hi/blog/arabic-meeting-minutes-from-recordings/)
-   [अरबी OCR API की तुलना: Google, Azure, Textract, Mistral, LLM](https://broadrouter.com/hi/blog/arabic-ocr-api-comparison/)
-   [गाइड: 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-arabic-text-normalization-search&utm_content=page-cta) ·

**स्रोत**

-   [Larkey, Ballesteros और Connell, Improving Stemming for Arabic Information Retrieval: Light Stemming and Co-occurrence Analysis, SIGIR 2002 (2026-11-15 को जाँचा गया)](https://ciir.cs.umass.edu/pubfiles/ir-249.pdf)
-   [CAMeL Tools 1.6.0 डॉक्यूमेंटेशन, camel\_tools.utils.normalize (2026-11-15 को जाँचा गया)](https://camel-tools.readthedocs.io/en/latest/api/utils/normalize.html)
-   [CAMeL Tools source, charsets.py: dediac\_ar में इस्तेमाल AR\_DIAC\_CHARSET (2026-11-15 को जाँचा गया)](https://github.com/CAMeL-Lab/camel_tools/blob/master/camel_tools/utils/charsets.py)
-   [GitHub पर PyArabic 0.6.15, araby मॉड्यूल (2026-11-15 को जाँचा गया)](https://github.com/linuxscout/pyarabic)
-   [Apache Lucene 9.12 ArabicNormalizer डॉक्यूमेंटेशन (2026-11-15 को जाँचा गया)](https://lucene.apache.org/core/9_12_0/analysis/common/org/apache/lucene/analysis/ar/ArabicNormalizer.html)
-   [Elasticsearch normalization token filters: arabic\_normalization (2026-11-15 को जाँचा गया)](https://www.elastic.co/docs/reference/text-analysis/analysis-normalization-tokenfilter)
-   [Unicode Standard Annex #15, Unicode Normalization Forms (2026-11-15 को जाँचा गया)](https://unicode.org/reports/tr15/)
-   [Unicode अरबी code chart, U+0600 से U+06FF (2026-11-15 को जाँचा गया)](https://www.unicode.org/charts/PDF/U0600.pdf)
