---
title: "Normalisation du texte arabe pour la recherche et le RAG"
description: "Tachkil, alif, taa marbouta, supports de hamza, lettres persanes, chiffres, Unicode : quelles règles aident la recherche, lesquelles nuisent, Python testé."
url: https://broadrouter.com/fr/blog/arabic-text-normalization-search/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/arabic-text-normalization-search/) (mis à jour le 2026-11-16).

# Normaliser le texte arabe pour la recherche et le RAG : quoi changer

Par l’équipe BroadNet Inference · 7 min de lecture · Publié 2026-11-15 · Mis à jour 2026-11-16

Pour les index de recherche et le RAG, normalisez de la même façon la copie stockée et chaque requête : Unicode NFKC, suppression du tachkil et du tatweel, unification des formes d’alif, ى vers ي et ة vers ه, conversion des chiffres. Gardez le texte original pour l’affichage et pour le LLM. Supports de hamza et taa marbouta sont réglables : ils augmentent le rappel mais fusionnent certains mots distincts.

## À retenir

-   Normalisez la clé de recherche, jamais le texte que vous affichez ou citez. Stockez l’original à côté.
-   Dans une étude classique sur les dépêches arabes de TREC-2001, la normalisation seule a fait passer la précision moyenne de .194 à .238, et un stemming léger par-dessus a atteint .376.
-   Appliquez Unicode NFKC en premier. Il recompose la hamza décomposée, déplie formes de présentation et ligatures, et fiabilise les règles suivantes.
-   Les bibliothèques divergent. normalize\_alef de PyArabic ramène ى à ا ; CAMeL Tools ramène ى à ي. Choisissez un jeu de règles et utilisez-le partout.
-   Pour la recherche par embeddings, testez entrée normalisée et entrée brute sur vos propres requêtes. Les règles de normalisation ont été mesurées sur la recherche par mots-clés.

**Sur cette page**

1.  La normalisation améliore-t-elle vraiment la recherche ?
2.  Que faut-il normaliser, et que coûte chaque règle ?
3.  Pourquoi la normalisation Unicode doit-elle passer en premier ?
4.  Que ne faut-il pas normaliser ?
5.  En quoi CAMeL Tools, PyArabic et Lucene diffèrent-ils ?
6.  À quoi ressemble un normaliseur testé ?
7.  Comment la normalisation s’articule-t-elle avec les embeddings et le RAG ?
8.  Où se situe BroadNet Inference

L’arabe permet d’écrire un même mot de plusieurs façons. Un utilisateur tape احمد ; le document porte أَحْمَد. Un index de recherche qui compare les caractères exacts manque cette correspondance, tout comme la moitié mots-clés d’une chaîne RAG. La normalisation règle cela en ramenant les variantes à une forme unique avant comparaison. Appliquée sans soin, elle fusionne aussi des mots de sens différents. Cet article avance règle par règle : ce que fait chacune, quand l’appliquer, ce qu’elle casse, et en quoi les principales bibliothèques diffèrent. Il se termine par du Python testé.

Pour la chaîne RAG arabe complète (découpage, recherche hybride, réponses sourcées), voir [Un RAG arabe qui fonctionne](https://broadrouter.com/fr/blog/arabic-rag-search/). Cet article approfondit l’étape de normalisation.

## La normalisation améliore-t-elle vraiment la recherche ?

Oui, pour la recherche par mots-clés, et les preuves sont anciennes mais nettes. Larkey, Ballesteros et Connell (SIGIR 2002) ont testé la recherche en arabe sur la collection de dépêches de TREC-2001. Avant le stemming, ils ont normalisé corpus et requêtes : suppression des diacritiques et de la ponctuation, unification des formes d’alif, et transformation de ى et ة en fin de mot. Leurs résultats monolingues, avec requêtes non étendues :

| Traitement | Précision moyenne | Variation vs brut (d’après les chiffres arrondis) |
| --- | --- | --- |
| Texte brut | .194 | — |
| Normalisé | .238 | +22.7% |
| Normalisé + stemming léger (light8) | .376 | +93.8% |

Deux réserves. Il s’agit de recherche par mots-clés sur de la presse, en 2002, pas de recherche par embeddings. Et le gain le plus important venait du stemming léger (suppression de préfixes comme و et ال et des suffixes courants), une étape distincte de la normalisation. L’`ArabicAnalyzer` de Lucene et l’analyseur `arabic` d’Elasticsearch appliquent les deux : un normaliseur, puis un stemmer léger.

## Que faut-il normaliser, et que coûte chaque règle ?

| Règle | Exemple | Index de recherche | Risque |
| --- | --- | --- | --- |
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Oui, toujours en premier | Réécrit aussi les caractères de compatibilité d’autres écritures |
| Supprimer les caractères invisibles | zero-width joiners, RLM/LRM, BOM | Oui | Aucun pour l’arabe ; le ZWNJ compte en persan |
| Retirer le tachkil | أَحْمَدُ → أحمد | Oui | Fusionne des mots distingués seulement par les voyelles |
| Supprimer le tatweel (ـ) | الـــمدينة → المدينة | Oui | Aucun |
| Unifier l’alif | أ إ آ ٱ → ا | Oui | Fusionne quelques paires : سأل (a demandé) et سال (a coulé) |
| Alif maqsoura | ى → ي | En général | Fusionne على (sur) et علي (Ali) |
| Taa marbouta | ة → ه | En général | Fusionne كتابة (écriture) et كتابه (son livre) |
| Supports de hamza | ؤ ئ → ء | Facultatif | Fusionne مسؤول et مسئول (bien) mais aussi certains mots distincts |
| Lettres persanes | ی → ي, ک → ك | Oui, si vos utilisateurs ont des claviers persans | Aucun pour un texte arabe |
| Chiffres | ٢٠٢٦ et ۲۰۲۶ → 2026 | Oui | Aucun ; gardez l’original pour l’affichage |

La colonne « Index de recherche » vaut pour la clé d’index et pour la requête. Le texte que vous stockez, affichez et passez au modèle reste tel qu’il a été écrit.

## Pourquoi la normalisation Unicode doit-elle passer en premier ?

Une même lettre visible peut être stockée de plusieurs façons. أ peut être un seul point de code (U+0623) ou un alif nu suivi d’une hamza combinante (U+0627 U+0654). Les vieux PDF et certains claviers produisent des formes de présentation arabes (U+FB50 à U+FEFF), comme le lam-alif ﻻ en un seul caractère. Dans la [normalisation Unicode](https://unicode.org/reports/tr15/), NFC compose la hamza sur l’alif, et NFKC déplie en plus les formes de présentation et les ligatures. En Python, `unicodedata.normalize("NFKC", "ﻻ")` renvoie لا, et `ﷲ` devient الله.

Faites-le avant tout le reste. Sinon, une expression régulière qui remplace أ rate la forme décomposée. Il y a un second piège : `dediac_ar` de CAMeL Tools supprime les caractères de son `AR_DIAC_CHARSET` (U+064B à U+0652 et U+0670). Cet ensemble omet les signes combinants de hamza et de madda (U+0653 à U+0655) : sur un texte décomposé, ils survivent donc à la suppression des diacritiques. NFKC les compose au préalable.

NFKC est une correspondance de compatibilité. Il modifie aussi des caractères hors de l’arabe, par exemple les lettres latines pleine chasse. C’est en général ce que l’on veut dans une clé de recherche, et une raison de plus de garder l’original à côté.

## Que ne faut-il pas normaliser ?

-   **Le texte que vous affichez, citez ou référencez.** L’arabe normalisé a l’air mal orthographié (المدينه). Stockez l’original à côté de la clé.
-   **Ce que vous envoyez au LLM.** Les modèles lisent très bien hamza et tachkil, et un texte exact garde noms et citations corrects. Retirer le tachkil économise quelques tokens ; vérifiez combien avec le [compteur de tokens arabe](https://broadrouter.com/tools/arabic-token-counter/) avant d’y sacrifier de la précision.
-   **Les textes où les signes portent du sens :** Coran, hadith, poésie, livres pour enfants, tâches de prononciation et de vocalisation (voir [ajouter les diacritiques avec un LLM](https://broadrouter.com/fr/blog/arabic-diacritization-llm/)).
-   **La correction orthographique ou grammaticale :** normaliser d’abord efface les fautes de hamza et de taa marbouta que vous voulez corriger ; voir [correction grammaticale et orthographique de l’arabe par LLM](https://broadrouter.com/fr/blog/arabic-grammar-spelling-correction-llm/).
-   **Les identifiants.** Codes produit, adresses e-mail, URL et texte latin ne doivent pas passer par des règles arabes. N’appliquez la normalisation qu’aux champs en écriture arabe, ou aux seuls tokens arabes.
-   **Les champs recherchés à l’identique.** Pour les raisons sociales ou les champs de type identifiant, indexez aussi une copie brute, pour qu’une correspondance exacte puisse encore passer en tête.

## En quoi CAMeL Tools, PyArabic et Lucene diffèrent-ils ?

Ils n’implémentent pas les mêmes règles, et les mélanger donne un index et des requêtes qui ne se rencontrent jamais. Nous avons lu la documentation et le code source de chaque bibliothèque, et exécuté PyArabic 0.6.15 :

| Fonction | Ce qu’elle fait réellement |
| --- | --- |
| CAMeL `normalize_unicode` | NFKC (ou NFC avec `compatibility=False`) ; développe aussi ﷼ en ريال et ﷽ en sa formule complète |
| CAMeL `normalize_alef_ar` | إ أ ٱ آ → ا |
| CAMeL `normalize_alef_maksura_ar` | ى → ي |
| CAMeL `normalize_teh_marbuta_ar` | ة → ه |
| CAMeL `dediac_ar` | Supprime U+064B à U+0652 et U+0670 ; laisse le tatweel |
| PyArabic `strip_tashkeel` | Supprime toutes les harakat, chadda comprise |
| PyArabic `strip_tatweel` | Supprime ـ |
| PyArabic `normalize_alef` | Toutes les formes d’alif **et ى** → ا, si bien que إلى devient الا |
| PyArabic `normalize_hamza` | La méthode par défaut ramène toutes les formes de hamza à ء, y compris أ, si bien que أحمد devient ءحمد |
| Lucene `ArabicNormalizer` | Formes d’alif à hamza → ا, ة → ه, ى → ي, supprime harakat et tatweel |

Les lignes PyArabic surprennent. La docstring de `normalize_alef` présente l’alif maqsoura comme une exception, mais dans la 0.6.15 l’ensemble `ALEFAT` inclut ى, et la fonction le ramène à ا. Son `normalize_hamza` est conçu pour un appariement indifférent à la hamza, pas pour la recherche en général. L’ordre compte aussi : appliquez d’abord la normalisation de l’alif, et `normalize_hamza` ne touche alors plus que ؤ, ئ et ء, si bien que مسؤول et مسئول deviennent tous deux مسءول. Sa méthode `tasheel` donne à la place مسوول et مسيول, qui ne se correspondent pas.

Le filtre `arabic_normalization` d’Elasticsearch utilise le normaliseur de Lucene : une chaîne Python qui doit correspondre à un index Elasticsearch doit donc reprendre exactement les règles de Lucene. Autrement dit ى → ي, pas ى → ا.

## À quoi ressemble un normaliseur testé ?

Cette fonction suit les choix de Lucene, ajoute la gestion d’Unicode, des chiffres et des lettres persanes, et rend désactivables les règles risquées. Elle n’utilise que la bibliothèque standard.

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

Ce qu’elle a renvoyé sur nos chaînes de test :

| Entrée | Sortie | Remarque |
| --- | --- | --- |
| أَحْمَدُ | احمد | Tachkil et hamza supprimés |
| الـــمدينة | المدينه | Tatweel et taa marbouta |
| إلى | الي | Alif et alif maqsoura |
| ا + U+0654 + مل | امل | Hamza décomposée recomposée, puis unifiée |
| ﻻبد | لابد | Forme de présentation dépliée |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Chiffres arabes orientaux et persans |
| مسؤول / مسئول | Tous deux مسءول avec `hamza_seats=True` | Inchangés par défaut |
| فارسی | فارسي | Ya persan |

Utilisez-la à deux endroits : à la construction de la clé d’index et à la lecture d’une requête. Stockez `original` et `normalize(original)` côte à côte, cherchez sur le second et renvoyez le premier. Le [normaliseur de texte arabe](https://broadrouter.com/tools/arabic-text-normalizer/) gratuit vous permet de coller un texte et de voir l’effet de chaque règle avant de choisir vos réglages.

## Comment la normalisation s’articule-t-elle avec les embeddings et le RAG ?

Une chaîne RAG a généralement deux moteurs de récupération : la recherche par mots-clés (BM25) et les [embeddings](https://broadrouter.com/fr/glossary/embeddings/). La normalisation aide clairement le côté mots-clés. Côté embeddings, les preuves ci-dessus ne s’appliquent pas : les modèles d’embeddings sont entraînés sur du texte brut, et beaucoup placent déjà احمد et أحمد tout près l’un de l’autre. Normaliser avant l’embedding peut aider, ne rien changer ou nuire. Constituez 50 à 100 vraies requêtes aux réponses connues, lancez-les avec entrée brute et entrée normalisée, et gardez la variante qui rappelle le plus. Quel que soit votre choix, appliquez-le à l’identique aux documents et aux requêtes.

La normalisation réduit aussi légèrement le nombre de tokens, car diacritiques et tatweel sont des caractères en plus pour le [tokenizer](https://broadrouter.com/fr/glossary/tokenizer/). Les rapports mesurés figurent dans le [jeu de données sur l’efficacité des tokenizers](https://broadrouter.com/data/tokenizer-efficiency/) et dans [tokens par mot en arabe](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/). La même normalisation sert à évaluer équitablement la reconnaissance vocale ; voir [le WER arabe expliqué](https://broadrouter.com/fr/blog/arabic-asr-wer-explained/).

L’arabizi (de l’arabe en caractères latins) demande une tout autre approche : [comment les LLM gèrent l’arabizi](https://broadrouter.com/fr/blog/arabizi-llm-handling/).

## Où se situe BroadNet Inference

La normalisation tourne dans votre propre code, sans API. BroadNet Inference intervient après la récupération. Il ne vend pas d’embeddings : associez un moteur de récupération et un fournisseur d’embeddings de votre choix à un modèle de chat BroadNet pour l’étape de réponse. [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) et DeepSeek V4.1 Flash acceptent 1 048 576 tokens de contexte, vous pouvez donc passer de nombreux passages récupérés dans leur arabe original, non normalisé. Pour choisir un modèle selon sa qualité en arabe, voir [choisir un LLM pour l’arabe](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/). Si vous n’avez besoin que de recherche par mots-clés, l’analyseur `arabic` intégré d’Elasticsearch peut suffire.

Outils gratuits sur ce sujet (en anglais)

-   [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.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Embeddings (plongements vectoriels)](https://broadrouter.com/fr/glossary/embeddings/)

Les embeddings sont des listes de nombres à virgule flottante (des vecteurs) qu’un modèle produit pour représenter un texte, une image ou une autre entrée. Des entrées de sens proche obtiennent des vecteurs voisins : la distance entre vecteurs permet de classer des résultats de recherche, de regrouper des documents ou de trouver des éléments apparentés.

[Hamza](https://broadrouter.com/fr/glossary/hamza/)

La hamza (ء) est la lettre arabe qui note le coup de glotte. Elle s’écrit seule ou sur un support : alif (أ إ), waw (ؤ) ou ya (ئ), et آ combine alif et madda. Comme le texte saisi l’écrit de façon irrégulière, les moteurs de recherche et l’évaluation de la parole ramènent souvent les formes d’alif à ا.

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Normalisation Unicode](https://broadrouter.com/fr/glossary/unicode-normalization/)

La normalisation Unicode convertit un texte dans une forme standard afin que des chaînes d’apparence identique utilisent les mêmes points de code. Les quatre formes sont NFD, NFC, NFKD et NFKC ; les formes K ramènent aussi les caractères de compatibilité, comme les formes de présentation arabes et les ligatures, à des lettres ordinaires.

[Normalisation du texte arabe](https://broadrouter.com/fr/glossary/arabic-text-normalization/)

La normalisation du texte arabe est l’étape qui ramène les variantes orthographiques d’un même mot à une seule forme avant la comparaison : suppression des diacritiques et du tatweel, unification des formes d’alif, et souvent ى vers ي et ة vers ه. Elle s’applique aux clés de recherche et à l’évaluation, pas au texte affiché.

[Tokenizer (tokeniseur)](https://broadrouter.com/fr/glossary/tokenizer/)

Un tokenizer est le composant qui convertit un texte en la suite d’ID entiers de tokens que lit un modèle de langage, et reconvertit les ID générés en texte. Chaque modèle a son propre tokenizer : un même texte peut donc produire un nombre de tokens différent selon le modèle.

[RAG (génération augmentée par récupération)](https://broadrouter.com/fr/glossary/rag/)

Le RAG (retrieval-augmented generation, génération augmentée par récupération) est une approche dans laquelle une application récupère d’abord, dans une source externe comme un index de recherche ou un index vectoriel, les passages pertinents pour une question, puis les ajoute au prompt pour qu’un modèle de langage réponde à partir de ce texte et pas seulement de sa mémoire.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

## Questions fréquentes

### Faut-il retirer le tachkil (diacritiques) avant d’indexer un texte arabe ?

Pour la recherche, oui : la plupart des requêtes et des textes modernes n’en ont pas, et les documents vocalisés ne seraient sinon pas trouvés. Retirez-les de la clé d’index et de la requête, gardez le texte original pour l’affichage, et conservez-les pour le Coran, la poésie ou les tâches de prononciation, où ils portent du sens.

### Faut-il normaliser le taa marbouta (ة) en ha (ه) ?

En général pour la recherche, car beaucoup de gens tapent ه en fin de mot. Cela fusionne toutefois certaines paires, comme كتابة (écriture) et كتابه (son livre). Si ces collisions comptent dans votre domaine, gardez ة et testez les deux réglages.

### Que fait la normalisation arabe dans Elasticsearch ?

Le filtre de tokens arabic\_normalization utilise l’ArabicNormalizer de Lucene : formes d’alif à hamza vers l’alif nu, taa marbouta vers ha, alif maqsoura vers ya, et suppression des harakat et du tatweel. L’analyseur arabic intégré y ajoute des mots vides et un stemmer qui retire articles, conjonctions et prépositions attachés ainsi que les suffixes courants.

### Normaliser l’arabe aide-t-il la recherche par embeddings ?

Ce n’est pas établi. Les gains mesurés viennent de la recherche par mots-clés. Les modèles d’embeddings apprennent sur du texte brut et gèrent souvent les variantes d’écriture : constituez un petit jeu de vraies requêtes et comparez le rappel avec et sans normalisation avant de trancher.

### Faut-il normaliser le texte arabe avant de l’envoyer à un LLM ?

En général, non. Envoyez le texte original pour que citations, noms et références restent exacts. Retirer le tachkil économise quelques tokens, mais ne le faites que si la tâche n’a pas besoin des signes.

## À lire ensuite

-   [RAG en arabe : normalisation, chunking et recherche qui fonctionnent](https://broadrouter.com/fr/blog/arabic-rag-search/)
-   [Tokens par mot, arabe ou anglais : pourquoi l’arabe coûte plus cher](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/)
-   [Taux d’erreur de mots (WER) en reconnaissance vocale arabe](https://broadrouter.com/fr/blog/arabic-asr-wer-explained/)
-   [L’arabizi et les LLM : traiter le franco-arabe et ses chiffres 3 et 7](https://broadrouter.com/fr/blog/arabizi-llm-handling/)
-   [Choisir une API LLM pour l’arabe : ce qu’il faut tester](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/)
-   [Extraction d’entités nommées en arabe par LLM : JSON, dates, contrôles](https://broadrouter.com/fr/blog/arabic-named-entity-extraction-llm/)
-   [Vocaliser un texte arabe avec un LLM : prompt, contrôles, DER](https://broadrouter.com/fr/blog/arabic-diacritization-llm/)
-   [Correction grammaticale et orthographique de l’arabe par LLM : guide](https://broadrouter.com/fr/blog/arabic-grammar-spelling-correction-llm/)
-   [Comptes rendus de réunion en arabe depuis l’audio : un pipeline API](https://broadrouter.com/fr/blog/arabic-meeting-minutes-from-recordings/)
-   [Comparatif des API OCR pour l’arabe : Google, Azure, Textract, Mistral](https://broadrouter.com/fr/blog/arabic-ocr-api-comparison/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-arabic-text-normalization-search&utm_content=page-cta) ·

**Sources**

-   [Larkey, Ballesteros et Connell, Improving Stemming for Arabic Information Retrieval: Light Stemming and Co-occurrence Analysis, SIGIR 2002 (vérifié le 2026-11-15)](https://ciir.cs.umass.edu/pubfiles/ir-249.pdf)
-   [Documentation de CAMeL Tools 1.6.0, camel\_tools.utils.normalize (vérifiée le 2026-11-15)](https://camel-tools.readthedocs.io/en/latest/api/utils/normalize.html)
-   [Code source de CAMeL Tools, charsets.py : l’AR\_DIAC\_CHARSET utilisé par dediac\_ar (vérifié le 2026-11-15)](https://github.com/CAMeL-Lab/camel_tools/blob/master/camel_tools/utils/charsets.py)
-   [PyArabic 0.6.15 sur GitHub, module araby (vérifié le 2026-11-15)](https://github.com/linuxscout/pyarabic)
-   [Documentation d’ArabicNormalizer dans Apache Lucene 9.12 (vérifiée le 2026-11-15)](https://lucene.apache.org/core/9_12_0/analysis/common/org/apache/lucene/analysis/ar/ArabicNormalizer.html)
-   [Filtres de tokens de normalisation d’Elasticsearch : arabic\_normalization (vérifiés le 2026-11-15)](https://www.elastic.co/docs/reference/text-analysis/analysis-normalization-tokenfilter)
-   [Unicode Standard Annex #15, Unicode Normalization Forms (vérifié le 2026-11-15)](https://unicode.org/reports/tr15/)
-   [Table de codes Unicode de l’arabe, U+0600 à U+06FF (vérifiée le 2026-11-15)](https://www.unicode.org/charts/PDF/U0600.pdf)
