---
title: "Normalización de texto árabe para búsqueda y RAG | BroadRouter"
description: "Tashkeel, alef, ta marbuta, hamza, letras persas, dígitos y Unicode: qué reglas de normalización del árabe ayudan a la búsqueda, cuáles perjudican y código Python."
url: https://broadrouter.com/es/blog/arabic-text-normalization-search/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/arabic-text-normalization-search/) (actualizado el 2026-11-16).

# Normalización de texto árabe para búsqueda y RAG: qué cambiar y qué no

Por el equipo de BroadNet Inference · 7 min de lectura · Publicado 2026-11-15 · Actualizado 2026-11-16

Para índices de búsqueda y RAG, normalice igual la copia almacenada y cada consulta: Unicode NFKC, elimine el tashkeel y el tatweel, unifique las formas de alef, convierta ى en ي y ة en ه, y convierta los dígitos. Conserve el texto original para mostrarlo y para el LLM. Trate los soportes de hamza y la ta marbuta como ajustables: aumentan la exhaustividad pero fusionan algunas palabras distintas.

## Puntos clave

-   Normalice la clave de búsqueda, nunca el texto que muestra o cita. Guarde el original a su lado.
-   En un estudio clásico sobre noticias árabes de TREC-2001, la normalización por sí sola elevó la precisión media de .194 a .238, y con light stemming encima llegó a .376.
-   Ejecute primero Unicode NFKC. Compone la hamza descompuesta, desempaqueta las formas de presentación y las ligaduras, y hace fiables las reglas posteriores.
-   Las bibliotecas no coinciden. normalize\_alef de PyArabic convierte ى en ا; CAMeL Tools convierte ى en ي. Elija un conjunto de reglas y úselo en todas partes.
-   Para la búsqueda por embeddings, pruebe la entrada normalizada y la original con sus propias consultas. Las reglas de normalización se midieron en búsqueda por palabras clave.

**En esta página**

1.  ¿La normalización mejora realmente la recuperación?
2.  ¿Qué debería normalizar y qué cuesta cada regla?
3.  ¿Por qué la normalización Unicode debe ir primero?
4.  ¿Qué no debería normalizar?
5.  ¿En qué se diferencian CAMeL Tools, PyArabic y Lucene?
6.  ¿Cómo es un normalizador probado?
7.  ¿Cómo encaja la normalización con los embeddings y RAG?
8.  Dónde encaja BroadNet Inference

El árabe permite escribir la misma palabra de varias maneras. Un usuario escribe احمد; el documento dice أَحْمَد. Un índice de búsqueda que compara caracteres exactos no encuentra esa coincidencia, y tampoco la mitad de palabras clave de un pipeline RAG. La normalización lo resuelve convirtiendo las variantes en una sola forma antes de compararlas. Hecha sin cuidado, también fusiona palabras que significan cosas distintas. Este artículo repasa regla por regla: qué hace cada una, cuándo aplicarla, qué rompe y en qué difieren las principales bibliotecas. Termina con código Python probado.

Para el pipeline RAG completo en árabe (fragmentación, búsqueda híbrida, respuestas con citas), consulte [RAG en árabe que funciona](https://broadrouter.com/es/blog/arabic-rag-search/). Este artículo profundiza en el paso de normalización.

## ¿La normalización mejora realmente la recuperación?

Sí, en la búsqueda por palabras clave, y la evidencia es antigua pero clara. Larkey, Ballesteros y Connell (SIGIR 2002) probaron la recuperación en árabe con la colección de noticias de TREC-2001. Antes del stemming, normalizaron el corpus y las consultas: eliminaron diacríticos y puntuación, unificaron las formas de alef y convirtieron ى y ة al final de palabra. Sus resultados monolingües, con consultas sin expandir:

| Procesamiento | Precisión media | Cambio frente al texto original (a partir de las cifras redondeadas) |
| --- | --- | --- |
| Texto original | .194 | — |
| Normalizado | .238 | +22.7% |
| Normalizado + light stemming (light8) | .376 | +93.8% |

Dos advertencias. Se trata de recuperación por palabras clave sobre noticias en 2002, no de búsqueda por embeddings. Y la mayor mejora vino del light stemming (eliminar prefijos como و y ال y sufijos comunes), que es un paso distinto de la normalización. El `ArabicAnalyzer` de Lucene y el analizador `arabic` de Elasticsearch aplican ambos: un normalizador y luego un stemmer ligero.

## ¿Qué debería normalizar y qué cuesta cada regla?

| Regla | Ejemplo | Índice de búsqueda | Riesgo |
| --- | --- | --- | --- |
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Sí, siempre primero | También reescribe caracteres de compatibilidad de otros alfabetos |
| Eliminar marcas invisibles | zero-width joiners, RLM/LRM, BOM | Sí | Ninguno para el árabe; el ZWNJ importa en persa |
| Eliminar el tashkeel | أَحْمَدُ → أحمد | Sí | Fusiona palabras que solo se distinguen por las vocales |
| Eliminar el tatweel (ـ) | الـــمدينة → المدينة | Sí | Ninguno |
| Unificar el alef | أ إ آ ٱ → ا | Sí | Fusiona algunos pares: سأل (preguntó) y سال (fluyó) |
| Alef maqsura | ى → ي | Normalmente | Fusiona على (sobre) y علي (Ali) |
| Ta marbuta | ة → ه | Normalmente | Fusiona كتابة (escritura) y كتابه (su libro) |
| Soportes de hamza | ؤ ئ → ء | Opcional | Fusiona مسؤول y مسئول (bien), pero también algunas palabras distintas |
| Letras persas | ی → ي, ک → ك | Sí, si los usuarios tienen teclados persas | Ninguno para texto árabe |
| Dígitos | ٢٠٢٦ y ۲۰۲۶ → 2026 | Sí | Ninguno; conserve el original para mostrarlo |

La primera columna se refiere a la clave del índice y a la consulta. El texto que almacena, muestra y pasa al modelo se queda como se escribió.

## ¿Por qué la normalización Unicode debe ir primero?

La misma letra visible puede almacenarse de distintas maneras. أ puede ser un único punto de código (U+0623) o un alef simple seguido de una hamza combinante (U+0627 U+0654). Los PDF antiguos y algunos teclados producen formas de presentación árabes (U+FB50 a U+FEFF), como el lam-alef de un solo carácter ﻻ. En la [normalización Unicode](https://unicode.org/reports/tr15/), NFC compone la hamza sobre el alef, y NFKC además desempaqueta las formas de presentación y las ligaduras. En Python, `unicodedata.normalize("NFKC", "ﻻ")` devuelve لا, y `ﷲ` se convierte en الله.

Ejecute esto antes que cualquier otra cosa. De lo contrario, una expresión regular que reemplaza أ no detecta la forma descompuesta. Hay una segunda trampa: `dediac_ar` de CAMeL Tools elimina los caracteres de su `AR_DIAC_CHARSET` (U+064B a U+0652 y U+0670). Ese conjunto deja fuera las marcas combinantes de hamza y madda (U+0653 a U+0655), así que en texto descompuesto sobreviven a la eliminación de diacríticos. NFKC las compone primero.

NFKC es una correspondencia de compatibilidad. También cambia caracteres fuera del árabe, por ejemplo las letras latinas de ancho completo. Normalmente eso es lo que quiere en una clave de búsqueda, y es una razón más para guardar el original al lado.

## ¿Qué no debería normalizar?

-   **El texto que muestra, cita o reproduce.** El árabe normalizado parece mal escrito (المدينه). Guarde el original junto a la clave.
-   **Lo que envía al LLM.** Los modelos leen bien la hamza y el tashkeel, y el texto exacto mantiene correctos los nombres y las citas. Eliminar el tashkeel ahorra algunos tokens; compruebe cuántos con el [contador de tokens en árabe](https://broadrouter.com/tools/arabic-token-counter/) antes de sacrificar precisión por ello.
-   **Texto en el que las marcas aportan significado:** Corán, hadices, poesía, libros infantiles, tareas de pronunciación y de diacritización (consulte [añadir diacríticos con un LLM](https://broadrouter.com/es/blog/arabic-diacritization-llm/)).
-   **Corrección ortográfica o gramatical:** normalizar primero borra los errores de hamza y de taa marbuta que quiere corregir; consulte [corrección gramatical y ortográfica del árabe con un LLM](https://broadrouter.com/es/blog/arabic-grammar-spelling-correction-llm/).
-   **Identificadores.** Los códigos de producto, los correos electrónicos, las URL y el texto latino no deben pasar por reglas del árabe. Aplique la normalización solo a los campos en alfabeto árabe, o solo a los tokens árabes.
-   **Campos en los que la gente busca de forma exacta.** Para nombres legales o campos tipo identificador, indexe también una copia sin procesar, para que una coincidencia exacta pueda seguir apareciendo primero.

## ¿En qué se diferencian CAMeL Tools, PyArabic y Lucene?

No implementan las mismas reglas, y mezclarlas produce un índice y unas consultas que nunca coinciden. Leímos la documentación y el código fuente de cada biblioteca y ejecutamos PyArabic 0.6.15:

| Función | Qué hace realmente |
| --- | --- |
| CAMeL `normalize_unicode` | NFKC (o NFC con `compatibility=False`); además expande ﷼ a ريال y ﷽ a su frase completa |
| CAMeL `normalize_alef_ar` | إ أ ٱ آ → ا |
| CAMeL `normalize_alef_maksura_ar` | ى → ي |
| CAMeL `normalize_teh_marbuta_ar` | ة → ه |
| CAMeL `dediac_ar` | Elimina de U+064B a U+0652 y U+0670; deja el tatweel |
| PyArabic `strip_tashkeel` | Elimina todos los harakat, incluida la shadda |
| PyArabic `strip_tatweel` | Elimina ـ |
| PyArabic `normalize_alef` | Todas las formas de alef **y ى** → ا, así que إلى se convierte en الا |
| PyArabic `normalize_hamza` | El método por defecto convierte todas las formas de hamza en ء, incluida أ, así que أحمد se convierte en ءحمد |
| Lucene `ArabicNormalizer` | Formas de alef con hamza → ا, ة → ه, ى → ي, elimina harakat y tatweel |

Las filas de PyArabic sorprenden. El docstring de `normalize_alef` dice que el alef maqsura es una excepción, pero en la 0.6.15 el conjunto `ALEFAT` incluye ى, y la función lo convierte en ا. Su `normalize_hamza` está pensada para comparaciones que ignoran la hamza, no para la búsqueda general. El orden también importa: ejecute primero la normalización del alef, y entonces `normalize_hamza` solo toca ؤ, ئ y ء, así que مسؤول y مسئول se convierten ambas en مسءول. Su método `tasheel` da en cambio مسوول y مسيول, que no coinciden entre sí.

El filtro `arabic_normalization` de Elasticsearch usa el normalizador de Lucene, así que un pipeline en Python que quiera coincidir con un índice de Elasticsearch debe copiar exactamente las reglas de Lucene. Es decir, ى → ي, no ى → ا.

## ¿Cómo es un normalizador probado?

Esta función sigue las decisiones de Lucene, añade el tratamiento de Unicode, dígitos y letras persas, y permite activar o desactivar las reglas arriesgadas. Solo usa la biblioteca estándar.

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

Lo que devolvió con nuestras cadenas de prueba:

| Entrada | Salida | Nota |
| --- | --- | --- |
| أَحْمَدُ | احمد | Sin tashkeel ni hamza |
| الـــمدينة | المدينه | Tatweel y ta marbuta |
| إلى | الي | Alef y alef maqsura |
| ا + U+0654 + مل | امل | Hamza descompuesta compuesta y luego unificada |
| ﻻبد | لابد | Forma de presentación desempaquetada |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Dígitos arábigo-índicos y persas |
| مسؤول / مسئول | Ambas مسءول con `hamza_seats=True` | Sin cambios por defecto |
| فارسی | فارسي | Ya persa |

Úsela en dos lugares: al construir la clave del índice y al leer una consulta. Guarde `original` y `normalize(original)` uno junto al otro, busque sobre el segundo y devuelva el primero. El [normalizador de texto árabe](https://broadrouter.com/tools/arabic-text-normalizer/) gratuito le permite pegar texto y ver el efecto de cada regla antes de elegir su configuración.

## ¿Cómo encaja la normalización con los embeddings y RAG?

Un pipeline RAG suele tener dos recuperadores: búsqueda por palabras clave (BM25) y [embeddings](https://broadrouter.com/es/glossary/embeddings/). La normalización ayuda claramente al lado de las palabras clave. Para el lado de los embeddings, la evidencia anterior no aplica: los modelos de embeddings se entrenan con texto sin procesar, y muchos ya sitúan احمد y أحمد muy cerca. Normalizar antes de generar embeddings puede ayudar, no hacer nada o perjudicar. Cree de 50 a 100 consultas reales con respuestas conocidas, ejecútelas con entrada original y normalizada, y quédese con la que recupere más. Elija lo que elija, aplíquelo igual a documentos y consultas.

La normalización también reduce ligeramente el número de tokens, porque los diacríticos y el tatweel son caracteres adicionales para el [tokenizador](https://broadrouter.com/es/glossary/tokenizer/). Las proporciones medidas están en el [conjunto de datos de eficiencia de tokenizadores](https://broadrouter.com/data/tokenizer-efficiency/) y en [tokens por palabra en árabe](https://broadrouter.com/es/blog/tokens-per-word-arabic-english/). La misma normalización se usa para evaluar con justicia el reconocimiento de voz; consulte [el WER en árabe explicado](https://broadrouter.com/es/blog/arabic-asr-wer-explained/).

El arabizi (árabe en letras latinas) necesita un enfoque totalmente distinto: [cómo manejan los LLM el arabizi](https://broadrouter.com/es/blog/arabizi-llm-handling/).

## Dónde encaja BroadNet Inference

La normalización se ejecuta en su propio código, así que no necesita ninguna API. BroadNet Inference entra después de la recuperación. No vende embeddings, así que combine un recuperador y un proveedor de embeddings de su elección con un modelo de chat de BroadNet para el paso de respuesta. [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) y DeepSeek V4.1 Flash admiten 1,048,576 tokens de contexto, así que puede pasar muchos fragmentos recuperados en su árabe original, sin normalizar. Para elegir un modelo según su calidad en árabe, consulte [cómo elegir un LLM para árabe](https://broadrouter.com/es/blog/choosing-an-llm-for-arabic/). Si solo necesita búsqueda por palabras clave, el analizador `arabic` integrado de Elasticsearch puede ser todo lo que necesita.

Herramientas gratuitas sobre este tema (en inglés)

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

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

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

La hamza (ء) es la letra árabe que representa la oclusiva glotal. Se escribe sola o sobre un soporte: alef (أ إ), waw (ؤ) o yeh (ئ), y آ combina alef con madda. Como el texto escrito es irregular al respecto, los buscadores y la evaluación de voz suelen plegar las formas de alef en ا.

[Embeddings (vectores de texto)](https://broadrouter.com/es/glossary/embeddings/)

Los embeddings son listas de números de punto flotante (vectores) que un modelo produce para representar un texto, una imagen u otra entrada. Las entradas de significado parecido obtienen vectores cercanos, así que la distancia entre vectores sirve para ordenar resultados de búsqueda, agrupar documentos o encontrar elementos relacionados.

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

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Normalización Unicode (Unicode normalization)](https://broadrouter.com/es/glossary/unicode-normalization/)

La normalización Unicode convierte el texto a una forma estándar para que las cadenas que se ven iguales usen los mismos puntos de código. Las cuatro formas son NFD, NFC, NFKD y NFKC; las formas K también convierten caracteres de compatibilidad, como las formas de presentación árabes y las ligaduras, en letras normales.

[Diacríticos árabes (tashkeel)](https://broadrouter.com/es/glossary/arabic-diacritics/)

Los diacríticos árabes, o tashkeel, son pequeñas marcas que se escriben encima o debajo de las letras para indicar vocales breves, consonantes dobles y la ausencia de vocal. Son opcionales: la mayor parte del texto árabe, incluidas las noticias, las omite, así que lectores y software deducen las vocales por el contexto.

[Arabizi (franco-árabe)](https://broadrouter.com/es/glossary/arabizi/)

El arabizi es árabe escrito de manera informal con letras latinas, usando dígitos para los sonidos árabes sin equivalente latino, como 3 para ع. Es habitual en chats y redes sociales, es sobre todo dialectal, no tiene ortografía estándar y a menudo se mezcla con inglés o francés.

[Normalización de texto árabe](https://broadrouter.com/es/glossary/arabic-text-normalization/)

La normalización de texto árabe es el paso que lleva las variantes ortográficas de una misma palabra a una sola forma antes de compararlas: quitar diacríticos y tatweel, unificar las formas de alef y, a menudo, convertir ى en ي y ة en ه. Se aplica a claves de búsqueda y evaluación, no al texto que se muestra.

[RAG (generación aumentada por recuperación)](https://broadrouter.com/es/glossary/rag/)

RAG (generación aumentada por recuperación) es un patrón en el que una aplicación primero recupera, de un almacén externo como un índice de búsqueda o vectorial, fragmentos relevantes para una pregunta, y luego los agrega al prompt para que un modelo de lenguaje responda con ese texto y no solo de memoria.

## Preguntas frecuentes

### ¿Debo eliminar el tashkeel (diacríticos) antes de indexar texto árabe?

Para la búsqueda, sí: la mayoría de las consultas y del texto moderno no lo llevan, así que de otro modo los documentos con diacríticos no coincidirían. Elimínelo de la clave del índice y de la consulta, conserve el texto original para mostrarlo y manténgalo en el Corán, la poesía o las tareas de pronunciación, donde aporta significado.

### ¿Se debe normalizar la ta marbuta (ة) a ha (ه)?

Normalmente sí para la búsqueda, porque mucha gente escribe ه al final de la palabra. Eso fusiona algunos pares, como كتابة (escritura) y كتابه (su libro). Si esas colisiones importan en su dominio, conserve ة y pruebe ambas opciones.

### ¿Qué hace la normalización del árabe en Elasticsearch?

El filtro de tokens arabic\_normalization usa el ArabicNormalizer de Lucene: formas de alef con hamza a alef simple, ta marbuta a ha, alef maqsura a ya, y eliminación de harakat y tatweel. El analizador arabic integrado añade palabras vacías y un stemmer que elimina artículos, conjunciones y preposiciones unidos, y sufijos comunes.

### ¿Normalizar el árabe ayuda a la búsqueda por embeddings?

No está demostrado. Las mejoras medidas vienen de la recuperación por palabras clave. Los modelos de embeddings aprenden del texto sin procesar y a menudo manejan las variantes ortográficas, así que cree un pequeño conjunto de consultas reales y compare la exhaustividad con y sin normalización antes de decidir.

### ¿Debo normalizar el texto árabe antes de enviarlo a un LLM?

En general, no. Envíe el texto original para que las citas, los nombres y las referencias se mantengan exactos. Eliminar el tashkeel ahorra algunos tokens, pero hágalo solo cuando la tarea no necesite las marcas.

## Siga leyendo

-   [RAG en árabe: normalización, chunking y recuperación que funciona](https://broadrouter.com/es/blog/arabic-rag-search/)
-   [Tokens por palabra en árabe vs inglés: por qué el árabe cuesta más](https://broadrouter.com/es/blog/tokens-per-word-arabic-english/)
-   [Tasa de error de palabras (WER) en el reconocimiento de voz en árabe](https://broadrouter.com/es/blog/arabic-asr-wer-explained/)
-   [Arabizi y LLM: cómo manejar el franco-árabe con números como 3 y 7](https://broadrouter.com/es/blog/arabizi-llm-handling/)
-   [Cómo elegir una API de LLM para árabe: qué probar](https://broadrouter.com/es/blog/choosing-an-llm-for-arabic/)
-   [Extracción de entidades nombradas en árabe con un LLM: JSON y fechas](https://broadrouter.com/es/blog/arabic-named-entity-extraction-llm/)
-   [Añadir diacríticos al texto árabe con un LLM: prompt, controles y DER](https://broadrouter.com/es/blog/arabic-diacritization-llm/)
-   [Corrección gramatical y ortográfica del árabe con un LLM: cómo hacerla](https://broadrouter.com/es/blog/arabic-grammar-spelling-correction-llm/)
-   [Actas de reuniones en árabe a partir de grabaciones: pipeline con API](https://broadrouter.com/es/blog/arabic-meeting-minutes-from-recordings/)
-   [Comparativa de OCR árabe: Google, Azure, Textract, Mistral y LLM](https://broadrouter.com/es/blog/arabic-ocr-api-comparison/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

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

**Fuentes**

-   [Larkey, Ballesteros y Connell, Improving Stemming for Arabic Information Retrieval: Light Stemming and Co-occurrence Analysis, SIGIR 2002 (consultado el 2026-11-15)](https://ciir.cs.umass.edu/pubfiles/ir-249.pdf)
-   [Documentación de CAMeL Tools 1.6.0, camel\_tools.utils.normalize (consultada el 2026-11-15)](https://camel-tools.readthedocs.io/en/latest/api/utils/normalize.html)
-   [Código fuente de CAMeL Tools, charsets.py: el AR\_DIAC\_CHARSET que usa dediac\_ar (consultado el 2026-11-15)](https://github.com/CAMeL-Lab/camel_tools/blob/master/camel_tools/utils/charsets.py)
-   [PyArabic 0.6.15 en GitHub, módulo araby (consultado el 2026-11-15)](https://github.com/linuxscout/pyarabic)
-   [Documentación de ArabicNormalizer de Apache Lucene 9.12 (consultada el 2026-11-15)](https://lucene.apache.org/core/9_12_0/analysis/common/org/apache/lucene/analysis/ar/ArabicNormalizer.html)
-   [Filtros de tokens de normalización de Elasticsearch: arabic\_normalization (consultado el 2026-11-15)](https://www.elastic.co/docs/reference/text-analysis/analysis-normalization-tokenfilter)
-   [Unicode Standard Annex #15, Unicode Normalization Forms (consultado el 2026-11-15)](https://unicode.org/reports/tr15/)
-   [Tabla de códigos árabes de Unicode, U+0600 a U+06FF (consultada el 2026-11-15)](https://www.unicode.org/charts/PDF/U0600.pdf)
