---
title: "Normalizzazione del testo arabo per ricerca e RAG | BroadRouter"
description: "Tashkeel, alef, ta marbuta, hamza, lettere persiane, cifre e Unicode: quali regole di normalizzazione dell’arabo aiutano la ricerca e quali no, con Python testato."
url: https://broadrouter.com/it/blog/arabic-text-normalization-search/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/arabic-text-normalization-search/) (aggiornato il 2026-11-16).

# Normalizzare il testo arabo per ricerca e RAG: cosa cambiare, cosa no

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15 · Aggiornato 2026-11-16

Per gli indici di ricerca e RAG, normalizza nello stesso modo la copia indicizzata e ogni query: Unicode NFKC, rimozione di tashkeel e tatweel, unificazione delle forme di alef, ى in ي e ة in ه, conversione delle cifre. Conserva il testo originale per la visualizzazione e per l’LLM. Tratta i supporti della hamza e la ta marbuta come opzioni regolabili: aumentano la recall ma fondono alcune parole distinte.

## Punti chiave

-   Normalizza la chiave di ricerca, mai il testo che mostri o citi. Conserva l’originale accanto.
-   In uno studio classico sulle notizie in arabo di TREC-2001, la sola normalizzazione ha portato la precisione media da 0,194 a 0,238, e con lo stemming leggero in aggiunta si è arrivati a 0,376.
-   Esegui per prima la normalizzazione Unicode NFKC. Compone la hamza scomposta, scompone forme di presentazione e legature e rende affidabili le regole successive.
-   Le librerie non sono d’accordo. normalize\_alef di PyArabic trasforma ى in ا; CAMeL Tools trasforma ى in ي. Scegli un insieme di regole e usalo ovunque.
-   Per la ricerca con embedding, prova sulle tue query sia l’input normalizzato sia quello grezzo. Le regole di normalizzazione sono state misurate sulla ricerca per parole chiave.

**In questa pagina**

1.  La normalizzazione migliora davvero il retrieval?
2.  Cosa normalizzare, e quanto costa ogni regola?
3.  Perché la normalizzazione Unicode va fatta per prima?
4.  Cosa non va normalizzato?
5.  In cosa differiscono CAMeL Tools, PyArabic e Lucene?
6.  Com’è fatto un normalizzatore testato?
7.  Come si inserisce la normalizzazione in embedding e RAG?
8.  Dove si colloca BroadNet Inference

L’arabo permette di scrivere la stessa parola in più modi. Un utente digita احمد; il documento riporta أَحْمَد. Un indice di ricerca che confronta i caratteri esatti perde la corrispondenza, e lo stesso vale per la metà a parole chiave di una pipeline RAG. La normalizzazione risolve il problema riportando le varianti a un’unica forma prima del confronto. Fatta senza attenzione, però, fonde anche parole che significano cose diverse. Questo articolo procede regola per regola: cosa fa ciascuna, quando applicarla, cosa rompe e come differiscono le principali librerie. Si chiude con codice Python testato.

Per la pipeline RAG completa in arabo (chunking, ricerca ibrida, risposte con citazioni), vedi [RAG in arabo che funziona](https://broadrouter.com/it/blog/arabic-rag-search/). Questo articolo approfondisce il passaggio di normalizzazione.

## La normalizzazione migliora davvero il retrieval?

Sì, per la ricerca per parole chiave, e le prove sono datate ma chiare. Larkey, Ballesteros e Connell (SIGIR 2002) hanno testato il retrieval in arabo sulla collezione di notizie TREC-2001. Prima dello stemming hanno normalizzato corpus e query: rimossi diacritici e punteggiatura, unificate le forme di alef e trasformate ى e ة a fine parola. I loro risultati monolingue, con query non espanse:

| Elaborazione | Precisione media | Variazione rispetto al grezzo (dai valori arrotondati) |
| --- | --- | --- |
| Testo grezzo | 0,194 | — |
| Normalizzato | 0,238 | +22,7% |
| Normalizzato + stemming leggero (light8) | 0,376 | +93,8% |

Due cautele. È retrieval per parole chiave del 2002 su notizie, non ricerca con embedding. E il guadagno maggiore è venuto dallo stemming leggero (rimozione di prefissi come و e ال e dei suffissi comuni), che è un passaggio separato dalla normalizzazione. L’`ArabicAnalyzer` di Lucene e l’analyzer `arabic` di Elasticsearch applicano entrambi: prima un normalizzatore, poi uno stemmer leggero.

## Cosa normalizzare, e quanto costa ogni regola?

| Regola | Esempio | Indice di ricerca | Rischio |
| --- | --- | --- | --- |
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Sì, sempre per prima | Riscrive anche i caratteri di compatibilità di altri alfabeti |
| Rimuovere i segni invisibili | zero-width joiner, RLM/LRM, BOM | Sì | Nessuno per l’arabo; lo ZWNJ conta in persiano |
| Togliere il tashkeel | أَحْمَدُ → أحمد | Sì | Fonde parole che si distinguono solo per le vocali |
| Rimuovere il tatweel (ـ) | الـــمدينة → المدينة | Sì | Nessuno |
| Unificare l’alef | أ إ آ ٱ → ا | Sì | Fonde alcune coppie: سأل (chiese) e سال (scorse) |
| Alef maksura | ى → ي | Di solito | Fonde على (su) e علي (Ali) |
| Ta marbuta | ة → ه | Di solito | Fonde كتابة (scrittura) e كتابه (il suo libro) |
| Supporti della hamza | ؤ ئ → ء | Facoltativo | Fonde مسؤول e مسئول (bene) ma anche alcune parole distinte |
| Lettere persiane | ی → ي, ک → ك | Sì, se gli utenti hanno tastiere persiane | Nessuno per il testo arabo |
| Cifre | ٢٠٢٦ e ۲۰۲۶ → 2026 | Sì | Nessuno; conserva l’originale per la visualizzazione |

La terza colonna riguarda la chiave dell’indice e la query. Il testo che salvi, mostri e passi al modello resta com’è scritto.

## Perché la normalizzazione Unicode va fatta per prima?

La stessa lettera visibile può essere memorizzata in modi diversi. أ può essere un unico code point (U+0623) o un alef semplice seguito da una hamza combinante (U+0627 U+0654). I PDF più vecchi e alcune tastiere producono forme di presentazione arabe (da U+FB50 a U+FEFF), come il lam-alef ﻻ in un solo carattere. Nella [normalizzazione Unicode](https://unicode.org/reports/tr15/), NFC compone la hamza sull’alef, e NFKC scompone anche forme di presentazione e legature. In Python, `unicodedata.normalize("NFKC", "ﻻ")` restituisce لا, e `ﷲ` diventa الله.

Eseguila prima di tutto il resto. Altrimenti una regex che sostituisce أ non vede la forma scomposta. C’è una seconda trappola: `dediac_ar` di CAMeL Tools rimuove i caratteri del suo `AR_DIAC_CHARSET` (da U+064B a U+0652 e U+0670). Quell’insieme esclude i segni combinanti di hamza e madda (da U+0653 a U+0655), quindi sul testo scomposto sopravvivono alla rimozione dei diacritici. NFKC li compone prima.

NFKC è una mappatura di compatibilità. Cambia anche caratteri al di fuori dell’arabo, per esempio le lettere latine a larghezza piena. Di solito in una chiave di ricerca è proprio quello che vuoi, ed è un motivo in più per conservare l’originale accanto.

## Cosa non va normalizzato?

-   **Il testo che mostri, citi o riporti.** L’arabo normalizzato sembra scritto male (المدينه). Conserva l’originale accanto alla chiave.
-   **Quello che invii all’LLM.** I modelli leggono senza problemi hamza e tashkeel, e il testo esatto mantiene corretti nomi e citazioni. Togliere il tashkeel fa risparmiare qualche token; controlla quanti con il [contatore di token per l’arabo](https://broadrouter.com/tools/arabic-token-counter/) prima di sacrificare l’accuratezza.
-   **Testi in cui i segni portano significato:** Corano, hadith, poesia, libri per bambini, compiti di pronuncia e di diacritizzazione (vedi [aggiungere i diacritici con un LLM](https://broadrouter.com/it/blog/arabic-diacritization-llm/)).
-   **Correzione ortografica o grammaticale:** normalizzare prima cancella proprio gli errori di hamza e taa marbuta che vuoi correggere; vedi [correzione grammaticale e ortografica dell’arabo con un LLM](https://broadrouter.com/it/blog/arabic-grammar-spelling-correction-llm/).
-   **Identificatori.** Codici prodotto, email, URL e testo latino non devono passare dalle regole dell’arabo. Applica la normalizzazione solo ai campi in alfabeto arabo, o solo ai token arabi.
-   **Campi che le persone cercano in modo esatto.** Per ragioni sociali o campi simili a identificativi, indicizza anche una copia grezza, così una corrispondenza esatta può ancora risultare per prima.

## In cosa differiscono CAMeL Tools, PyArabic e Lucene?

Non implementano le stesse regole, e mescolarle produce un indice e delle query che non coincidono mai. Abbiamo letto documentazione e sorgente di ciascuna libreria ed eseguito PyArabic 0.6.15:

| Funzione | Cosa fa davvero |
| --- | --- |
| CAMeL `normalize_unicode` | NFKC (o NFC con `compatibility=False`); espande anche ﷼ in ريال e ﷽ nella sua frase completa |
| CAMeL `normalize_alef_ar` | إ أ ٱ آ → ا |
| CAMeL `normalize_alef_maksura_ar` | ى → ي |
| CAMeL `normalize_teh_marbuta_ar` | ة → ه |
| CAMeL `dediac_ar` | Rimuove da U+064B a U+0652 e U+0670; lascia il tatweel |
| PyArabic `strip_tashkeel` | Rimuove tutte le harakat, shadda compresa |
| PyArabic `strip_tatweel` | Rimuove ـ |
| PyArabic `normalize_alef` | Ogni forma di alef **e ى** → ا, quindi إلى diventa الا |
| PyArabic `normalize_hamza` | Il metodo predefinito trasforma ogni forma di hamza in ء, أ compresa, quindi أحمد diventa ءحمد |
| Lucene `ArabicNormalizer` | Forme di alef con hamza → ا, ة → ه, ى → ي, rimuove harakat e tatweel |

Le righe di PyArabic sorprendono. La docstring di `normalize_alef` dice che l’alef maksura è un’eccezione, ma nella 0.6.15 l’insieme `ALEFAT` include ى, e la funzione la trasforma in ا. `normalize_hamza` è pensata per un matching indifferente alla hamza, non per la ricerca in generale. Anche l’ordine conta: esegui prima la normalizzazione dell’alef, e a quel punto `normalize_hamza` tocca solo ؤ, ئ e ء, quindi مسؤول e مسئول diventano entrambe مسءول. Il suo metodo `tasheel` dà invece مسوول e مسيول, che non coincidono tra loro.

Il filtro `arabic_normalization` di Elasticsearch usa il normalizzatore di Lucene, quindi una pipeline Python che deve combaciare con un indice Elasticsearch dovrebbe copiare esattamente le regole di Lucene. Cioè ى → ي, non ى → ا.

## Com’è fatto un normalizzatore testato?

Questa funzione segue le scelte di Lucene, aggiunge la gestione di Unicode, cifre e lettere persiane e rende attivabili a piacere le regole rischiose. Usa solo la libreria 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
```

Cosa ha restituito sulle nostre stringhe di test:

| Input | Output | Nota |
| --- | --- | --- |
| أَحْمَدُ | احمد | Via tashkeel e hamza |
| الـــمدينة | المدينه | Tatweel e ta marbuta |
| إلى | الي | Alef e alef maksura |
| ا + U+0654 + مل | امل | Hamza scomposta composta, poi unificata |
| ﻻبد | لابد | Forma di presentazione scomposta |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Cifre arabo-indiane e persiane |
| مسؤول / مسئول | Entrambe مسءول con `hamza_seats=True` | Invariate per impostazione predefinita |
| فارسی | فارسي | Ya persiana |

Usala in due punti: quando costruisci la chiave dell’indice e quando leggi una query. Salva `original` e `normalize(original)` uno accanto all’altro, cerca sul secondo e restituisci il primo. Il [normalizzatore di testo arabo](https://broadrouter.com/tools/arabic-text-normalizer/) gratuito ti permette di incollare un testo e vedere l’effetto di ogni regola prima di scegliere le impostazioni.

## Come si inserisce la normalizzazione in embedding e RAG?

Una pipeline RAG di solito ha due retriever: la ricerca per parole chiave (BM25) e gli [embedding](https://broadrouter.com/it/glossary/embeddings/). La normalizzazione aiuta chiaramente la parte a parole chiave. Per la parte con embedding, le prove viste sopra non valgono: i modelli di embedding sono addestrati su testo grezzo, e molti mettono già احمد e أحمد vicini. Normalizzare prima dell’embedding può aiutare, non cambiare nulla o peggiorare. Prepara da 50 a 100 query reali con risposte note, eseguile con input grezzo e normalizzato e tieni la variante con la recall più alta. Qualunque cosa scegli, applicala in modo identico a documenti e query.

La normalizzazione riduce anche leggermente il numero di token, perché diacritici e tatweel sono caratteri in più per il [tokenizer](https://broadrouter.com/it/glossary/tokenizer/). I rapporti misurati sono nel [dataset sull’efficienza dei tokenizer](https://broadrouter.com/data/tokenizer-efficiency/) e in [token per parola in arabo](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/). La stessa normalizzazione serve a valutare in modo equo il riconoscimento vocale; vedi [il WER in arabo spiegato](https://broadrouter.com/it/blog/arabic-asr-wer-explained/).

L’arabizi (l’arabo in caratteri latini) richiede un approccio del tutto diverso: [come gli LLM gestiscono l’arabizi](https://broadrouter.com/it/blog/arabizi-llm-handling/).

## Dove si colloca BroadNet Inference

La normalizzazione gira nel tuo codice, quindi non serve alcuna API. BroadNet Inference entra in gioco dopo il retrieval. Non vende embedding, quindi abbina un retriever e un fornitore di embedding a tua scelta a un modello di chat di BroadNet per la fase di risposta. [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) e DeepSeek V4.1 Flash accettano 1.048.576 token di contesto, quindi puoi passare molti passaggi recuperati nel loro arabo originale, non normalizzato. Per scegliere un modello in base alla qualità in arabo, vedi [scegliere un LLM per l’arabo](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/). Se ti serve solo la ricerca per parole chiave, l’analyzer `arabic` integrato di Elasticsearch potrebbe bastarti.

Strumenti gratuiti sul tema (in inglese)

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

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Hamza (lettera araba)](https://broadrouter.com/it/glossary/hamza/)

La hamza (ء) è la lettera araba che indica il colpo di glottide. Si scrive da sola o su un supporto: alef (أ إ), waw (ؤ) o yeh (ئ), e آ unisce alef e madda. Dato che il testo digitato la usa in modo incoerente, motori di ricerca e valutazione del parlato spesso riducono le forme con alef a ا.

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Embedding (embeddings)](https://broadrouter.com/it/glossary/embeddings/)

Gli embedding sono liste di numeri in virgola mobile (vettori) che un modello produce per rappresentare un testo, un’immagine o un altro input. Input con significato simile ottengono vettori vicini tra loro, quindi la distanza tra vettori serve a ordinare i risultati di ricerca, raggruppare documenti o trovare elementi correlati.

[Normalizzazione Unicode (Unicode normalization)](https://broadrouter.com/it/glossary/unicode-normalization/)

La normalizzazione Unicode converte il testo in una forma standard, così che stringhe che appaiono uguali usino gli stessi code point. Le quattro forme sono NFD, NFC, NFKD e NFKC; le forme K riducono anche i caratteri di compatibilità, come le forme di presentazione arabe e le legature, a lettere ordinarie.

[Diacritici arabi (tashkeel)](https://broadrouter.com/it/glossary/arabic-diacritics/)

I diacritici arabi, o tashkeel, sono piccoli segni scritti sopra o sotto le lettere per indicare le vocali brevi, le consonanti doppie e l’assenza di vocale. Sono facoltativi: quasi tutto il testo arabo, notizie comprese, li omette, quindi lettori e software deducono le vocali dal contesto.

[Normalizzazione del testo arabo (Arabic text normalization)](https://broadrouter.com/it/glossary/arabic-text-normalization/)

La normalizzazione del testo arabo è il passaggio che riporta a una sola forma le varianti grafiche della stessa parola prima del confronto: toglie diacritici e tatweel, unifica le forme di alef e spesso trasforma ى in ي e ة in ه. Si applica alle chiavi di ricerca e alla valutazione, non al testo che mostri.

[Tā’ marbūṭa (taa marbuta, ة)](https://broadrouter.com/it/glossary/taa-marbuta/)

La taa marbuta (ة, U+0629) è una lettera araba che compare solo alla fine di una parola e spesso segna sostantivi e aggettivi femminili. Somiglia a una heh (ه, U+0647) con due punti, quindi nel testo digitato le due si confondono, e molti normalizzatori per la ricerca mappano ة su ه.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

## Domande frequenti

### Devo togliere il tashkeel (i diacritici) prima di indicizzare un testo arabo?

Per la ricerca sì: la maggior parte delle query e dei testi moderni non ne ha, quindi altrimenti i documenti con diacritici non verrebbero trovati. Toglili dalla chiave dell’indice e dalla query, conserva il testo originale per la visualizzazione e tienili per Corano, poesia o compiti di pronuncia, dove portano significato.

### La ta marbuta (ة) va normalizzata in ha (ه)?

Di solito sì, per la ricerca, perché molte persone digitano ه alla fine della parola. Però fonde alcune coppie, come كتابة (scrittura) e كتابه (il suo libro). Se nel tuo dominio quelle collisioni contano, tieni la ة e prova entrambe le impostazioni.

### Cosa fa la normalizzazione dell’arabo in Elasticsearch?

Il filtro di token arabic\_normalization usa l’ArabicNormalizer di Lucene: le forme di alef con hamza diventano alef semplice, la ta marbuta diventa ha, l’alef maksura diventa ya, e vengono rimossi harakat e tatweel. L’analyzer arabic integrato aggiunge stop word e uno stemmer che toglie articoli, congiunzioni, preposizioni e suffissi comuni attaccati alla parola.

### Normalizzare l’arabo aiuta la ricerca con embedding?

Non è dimostrato. I miglioramenti misurati vengono dal retrieval per parole chiave. I modelli di embedding imparano dal testo grezzo e spesso gestiscono già le varianti grafiche, quindi prepara un piccolo set di query reali e confronta la recall con e senza normalizzazione prima di decidere.

### Conviene normalizzare il testo arabo prima di inviarlo a un LLM?

In generale no. Invia il testo originale, così citazioni, nomi e riferimenti restano esatti. Togliere il tashkeel fa risparmiare qualche token, ma fallo solo quando il compito non ha bisogno dei segni.

## Continua a leggere

-   [RAG in arabo: normalizzazione, chunking e retrieval che funzionano](https://broadrouter.com/it/blog/arabic-rag-search/)
-   [Token per parola in arabo e in inglese: perché l’arabo costa di più](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/)
-   [Word error rate (WER) nell’ASR in arabo: guida pratica](https://broadrouter.com/it/blog/arabic-asr-wer-explained/)
-   [Arabizi e LLM: gestire il franco-arabo con numeri come 3 e 7](https://broadrouter.com/it/blog/arabizi-llm-handling/)
-   [Scegliere un’API LLM per l’arabo: cosa testare](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/)
-   [Estrarre entità nominate dall’arabo con un LLM: JSON, date e controlli](https://broadrouter.com/it/blog/arabic-named-entity-extraction-llm/)
-   [Aggiungere i diacritici all’arabo con un LLM: prompt, controlli, DER](https://broadrouter.com/it/blog/arabic-diacritization-llm/)
-   [Correzione grammaticale e ortografica dell’arabo con un LLM: guida](https://broadrouter.com/it/blog/arabic-grammar-spelling-correction-llm/)
-   [Verbali di riunioni in arabo dalle registrazioni: una pipeline API](https://broadrouter.com/it/blog/arabic-meeting-minutes-from-recordings/)
-   [API OCR per l’arabo a confronto: Google, Azure, Textract, Mistral, LLM](https://broadrouter.com/it/blog/arabic-ocr-api-comparison/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Larkey, Ballesteros e Connell, Improving Stemming for Arabic Information Retrieval: Light Stemming and Co-occurrence Analysis, SIGIR 2002 (consultato il 2026-11-15)](https://ciir.cs.umass.edu/pubfiles/ir-249.pdf)
-   [Documentazione di CAMeL Tools 1.6.0, camel\_tools.utils.normalize (consultata il 2026-11-15)](https://camel-tools.readthedocs.io/en/latest/api/utils/normalize.html)
-   [Sorgente di CAMeL Tools, charsets.py: l’AR\_DIAC\_CHARSET usato da dediac\_ar (consultato il 2026-11-15)](https://github.com/CAMeL-Lab/camel_tools/blob/master/camel_tools/utils/charsets.py)
-   [PyArabic 0.6.15 su GitHub, modulo araby (consultato il 2026-11-15)](https://github.com/linuxscout/pyarabic)
-   [Documentazione di ArabicNormalizer in Apache Lucene 9.12 (consultata il 2026-11-15)](https://lucene.apache.org/core/9_12_0/analysis/common/org/apache/lucene/analysis/ar/ArabicNormalizer.html)
-   [Filtri di token di normalizzazione di Elasticsearch: arabic\_normalization (consultato il 2026-11-15)](https://www.elastic.co/docs/reference/text-analysis/analysis-normalization-tokenfilter)
-   [Unicode Standard Annex #15, Unicode Normalization Forms (consultato il 2026-11-15)](https://unicode.org/reports/tr15/)
-   [Tabella dei codici Unicode per l’arabo, da U+0600 a U+06FF (consultata il 2026-11-15)](https://www.unicode.org/charts/PDF/U0600.pdf)
