---
title: "Corretor ortográfico e gramatical de árabe com um LLM"
description: "Corrija ortografia e gramática do árabe com uma API de LLM: prompt de edição mínima, proteção contra reescritas, edições por tipo de erro e pontuação no estilo M2."
url: https://broadrouter.com/pt/blog/arabic-grammar-spelling-correction-llm/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/arabic-grammar-spelling-correction-llm/) (atualizado em 2026-11-16).

# Correção gramatical e ortográfica do árabe com um LLM: passo a passo

Pela equipe da BroadNet Inference · 8 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Peça ao modelo só o texto corrigido, com o mínimo possível de edições e sem reformular. Depois compare a resposta com a entrada no código: rejeite respostas que mudaram demais e rotule cada edição de palavra como hamza, taa marbuta, alef maqsura, junção, separação ou outra. Avalie uma amostra corrigida à mão pelas edições, com precision, recall e F0.5.

## Pontos principais

-   No conjunto de teste QALB-2014, o GPT-4 com cinco exemplos marcou 65,49 de F1, contra 67,70 de um AraT5v2 com fine-tuning (Kwon et al., ArabicNLP 2023). LLMs com prompt são utilizáveis, não automaticamente melhores.
-   Segundo os organizadores da shared task QALB, os alifs com hamza e a confusão entre alef maqsura e ya são os erros ortográficos mais comuns do árabe.
-   A correção é avaliada por edições, não por frases inteiras. Extraia da resposta as edições no nível da palavra, compare com as edições de referência e informe o F0.5, que dá à precision o dobro do peso da recall.
-   Nunca normalize o texto antes de corrigi-lo. A normalização transforma de propósito أ إ آ em ا e ة em ه, apagando justamente os erros que você quer corrigir.
-   Proteja-se contra reescritas no código: se, no nível de caracteres, a resposta for menos de 80% parecida com a entrada, mantenha o original e registre a resposta em log.

**Nesta página**

1.  Quão bons são os LLMs em corrigir a gramática do árabe?
2.  Por que não simplesmente normalizar o texto?
3.  O que o prompt deve dizer?
4.  Como conferir a resposta do modelo?
5.  Quais classes de erro você deve acompanhar?
6.  Como pontuar um corretor?
7.  E o Tibyan e os dados sintéticos?
8.  Qual modelo da BroadNet usar?
9.  Onde a BroadNet Inference entra

Revisar texto em árabe parece um prompt de uma linha: “corrija este texto”. Na prática, o modelo também reformula, adiciona diacríticos, troca uma palavra dialetal por uma formal e explica as mudanças, e você não consegue saber quais edições eram necessárias. Este post constrói, sobre um LLM compatível com a OpenAI, um corretor que faz o mínimo de edições, confere a resposta no código, rotula cada edição por tipo de erro e avalia o conjunto do jeito que os benchmarks de pesquisa fazem.

## Quão bons são os LLMs em corrigir a gramática do árabe?

Os benchmarks de referência são as shared tasks QALB. O QALB-2014 usou comentários em árabe padrão moderno do site da Al Jazeera: mais de um milhão de palavras de texto de treino com cerca de 306.000 correções, e conjuntos de teste de cerca de 50.000 palavras. O QALB-2015 acrescentou uma segunda trilha com redações de estudantes de árabe como língua estrangeira (L2). Os dois avaliaram os sistemas pelas edições, com o M2 scorer. As melhores pontuações, em F1 (quanto maior, melhor):

| Conjunto de teste | F1 do melhor sistema | Texto |
| --- | --- | --- |
| Teste QALB-2014 | 67,91 | Comentários de notícias escritos por nativos |
| Teste QALB-2015 nativos | 72,87 | Comentários de notícias escritos por nativos |
| Teste QALB-2015 L2 | 41,20 | Redações de estudantes |

A linha L2 é o alerta útil. Texto de estudantes tem mais erros de escolha lexical e palavras faltando, e o melhor sistema pontuou bem menos. Se os seus usuários estão aprendendo árabe, espere números mais parecidos com essa linha.

Kwon, Bhatia, Nagoudi e Abdul-Mageed (ArabicNLP 2023) rodaram depois o ChatGPT e o GPT-4 no conjunto de teste QALB-2014. Com o mesmo scorer:

| Sistema | F1 |
| --- | --- |
| ChatGPT, 1 exemplo | 53,59 |
| ChatGPT, 5 exemplos | 63,98 |
| GPT-4, 5 exemplos | 65,49 |
| AraT5v2, com fine-tuning | 67,70 |

Dois detalhes importam para o seu prompt. Mais exemplos ajudaram muito. E prompts zero-shot e prompts em árabe geraram respostas cheias de explicações que os autores não conseguiam avaliar automaticamente. Um corretor precisa de uma saída que um programa consiga comparar com um diff.

## Por que não simplesmente normalizar o texto?

O [normalizador de texto em árabe](https://broadrouter.com/tools/arabic-text-normalizer/) deste site remove tashkeel e tatweel, transforma أ إ آ em ا e, opcionalmente, ى em ي e ة em ه. É o passo certo para a busca, porque quem digita احمد deve encontrar أحمد. É o passo errado antes da correção, porque apaga a distinção que o corretor precisa restaurar. Depois da normalização, انا e أنا viram a mesma string: o erro de hamza some, e a correção junto.

Se você precisa das duas coisas, mantenha três cópias: o texto original, o texto corrigido que você mostra aos usuários e uma cópia normalizada do texto corrigido para o índice de busca. [Normalização de texto em árabe para busca](https://broadrouter.com/pt/blog/arabic-text-normalization-search/) cobre o lado da indexação. Um único passo de normalização deve vir antes da correção: Unicode NFC, que junta um alif decomposto mais a hamza combinante num só caractere, para que o diff não aponte uma mudança que não existe.

## O que o prompt deve dizer?

Peça edições mínimas, nomeie os tipos de erro que interessam, proíba as mudanças que você não quer e peça só o texto corrigido. Escrever as instruções em inglês ou em árabe é escolha sua; [engenharia de prompt em árabe](https://broadrouter.com/pt/blog/arabic-prompt-engineering/) discute os prós e contras. Kwon et al. obtiveram saídas utilizáveis com instruções em inglês e exemplos. Acrescentar de três a cinco pares de frases corrigidas dos seus próprios dados (few-shot) é a melhoria mais barata para testar primeiro.

Use temperatura 0: você quer a mesma correção sempre. Se o texto estiver num dialeto, como o árabe egípcio ou do Golfo, diga se o dialeto deve ser mantido. O prompt abaixo assume árabe padrão moderno ([MSA](https://broadrouter.com/pt/glossary/msa/)) e manda o modelo não mudar o estilo, o que também cobre o dialeto.

## Como conferir a resposta do modelo?

O código faz uma requisição, mede quanto a resposta difere da entrada, extrai as edições no nível da palavra e rotula cada uma.

```python
import difflib, os, re, unicodedata
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = """You are an Arabic proofreader. Correct spelling, grammar and punctuation
errors in the user's Modern Standard Arabic text with the fewest possible edits.
Rules:
- Fix hamza, taa marbuta (ة/ه), alef maqsura (ى/ي), agreement, missing or extra
  letters, wrongly split or merged words, and punctuation.
- Do not rephrase, reorder, shorten, translate or change the style or dialect.
- Do not add or remove diacritics (tashkeel).
- If the text is already correct, return it unchanged.
Reply with the corrected text only: no explanation, no quotes, no list of changes."""

def tokens(s: str) -> list[str]:
    s = unicodedata.normalize("NFC", s)        # composed hamza forms, so أ is one character
    return re.findall(r"\w+|[^\w\s]", s)       # Arabic letters are \w; ، ؟ ؛ become tokens

def edits(src: str, hyp: str) -> list[tuple]:
    """Word-level edits (start, end, replacement, original): the idea behind an M2 file's A lines."""
    a, b = tokens(src), tokens(hyp)
    out = []
    for op, i1, i2, j1, j2 in difflib.SequenceMatcher(None, a, b, autojunk=False).get_opcodes():
        i, j = i1, j1
        while op != "equal" and (i < i2 or j < j2):     # split the block into one-word edits
            if i + 1 < i2 and j < j2 and a[i] + a[i + 1] == b[j]:      # و قابلت -> وقابلت
                out.append((i, i + 2, b[j], f"{a[i]} {a[i + 1]}")); i += 2; j += 1
            elif i < i2 and j + 1 < j2 and a[i] == b[j] + b[j + 1]:    # عبدالله -> عبد الله
                out.append((i, i + 1, f"{b[j]} {b[j + 1]}", a[i])); i += 1; j += 2
            elif i < i2 and j < j2:
                out.append((i, i + 1, b[j], a[i])); i += 1; j += 1
            elif i < i2:                                                # deleted word
                out.append((i, i + 1, "", a[i])); i += 1
            else:                                                       # inserted word
                out.append((i, i, b[j], "")); j += 1
    return out

HAMZA = str.maketrans("أإآٱؤئ", "ااااوي")
RULES = [("hamza", lambda w: w.translate(HAMZA).replace("ء", "")),
         ("taa marbuta", lambda w: w.replace("ة", "ه")),
         ("alef maqsura", lambda w: w.replace("ى", "ي"))]

def error_class(orig: str, corr: str) -> str:
    if all(not c.isalnum() for c in (orig + corr).replace(" ", "")):
        return "punctuation"
    if orig != corr and orig.replace(" ", "") == corr.replace(" ", ""):
        return "merge" if " " in orig else "split"
    for name, f in RULES:
        if orig != corr and f(orig) == f(corr):
            return name
    both = lambda w: RULES[2][1](RULES[1][1](RULES[0][1](w)))
    if both(orig) == both(corr):
        return "mixed orthography"
    return "other"

def correct(text: str, model="broadnet/qwen3.8-27b", min_similarity=0.8) -> dict:
    r = client.chat.completions.create(
        model=model, temperature=0, max_tokens=2000,
        messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": text}])
    out = r.choices[0].message.content.strip()
    sim = difflib.SequenceMatcher(None, text, out, autojunk=False).ratio()
    if sim < min_similarity:             # a rewrite, not a correction: keep the original
        return {"text": text, "edits": [], "rejected": out, "similarity": round(sim, 2)}
    return {"text": out, "similarity": round(sim, 2),
            "edits": [{"from": o, "to": c, "class": error_class(o, c)} for _, _, c, o in edits(text, out)]}
```

Rodamos isso contra um servidor mock local com respostas prontas (nenhuma chamada à API real, já que o mock devolve o que nós escrevemos). Para ذهبت الى المدرسه و قابلت المعلمه في الصباح, a resposta ذهبت إلى المدرسة وقابلت المعلمة في الصباح gerou quatro edições: الى para إلى (hamza), المدرسه para المدرسة (taa marbuta), و قابلت para وقابلت (junção) e المعلمه para المعلمة (taa marbuta). Para مشي الي, listou مشي para مشى (alef maqsura) e الي para إلى (ortografia mista, porque corrige hamza e alef maqsura de uma vez). Uma resposta pronta que transformava الطقس جميل اليوم numa frase com o dobro do tamanho teve 0,52 de similaridade, então o código manteve o original e registrou a resposta em log.

Observações sobre o código:

-   **A proteção por similaridade é uma ferramenta grosseira.** Uma frase com muitos erros pode, legitimamente, ficar perto de 0,8. Ajuste o limite nos seus dados e mande as respostas rejeitadas para uma pessoa, não para o lixo.
-   **`max_tokens=2000`** deixa espaço para o raciocínio. A documentação da BroadNet diz que DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder e que o raciocínio conta para `max_tokens`; você também pode definir `reasoning_effort` como low. Veja [respostas vazias de modelos de raciocínio](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **Os rótulos de classe são regras, não um parser.** “Other” inclui letras faltando (مسؤل para مسؤول), concordância e escolha de palavras. Para uma taxonomia completa, rode o ARETA (abaixo) nos mesmos pares.

## Quais classes de erro você deve acompanhar?

Os organizadores do QALB apontam os alifs com hamza e a confusão entre alef maqsura e ya como os erros ortográficos mais comuns do árabe. O ARETA, anotador de tipos de erro do CAMeL Lab (Belkebir e Habash, CoNLL 2021), usa um conjunto de tags baseado no Arabic Learner Corpus. Suas tags ortográficas incluem OH (hamza), OT (ha e taa marbuta) e OA (alif e ya), ao lado de tags morfológicas, sintáticas, semânticas, de pontuação, de junção (MG) e de separação (SP). O artigo informa 85,8% de F1 micro-médio contra texto de estudantes rotulado à mão.

| Classe | Errado | Certo | O que dá errado |
| --- | --- | --- | --- |
| Hamza | انا، الى، مسأله | أنا، إلى، مسألة | Hamza faltando, no suporte errado ou do lado errado do alif |
| Taa marbuta | المدرسه | المدرسة | ة final escrito como ه, ou o contrário |
| Alef maqsura | مشي، علي (preposição) | مشى، على | ى final escrito como ي; علي também é um nome, então o contexto decide |
| Junção ou separação | و قابلت، عبدالله | وقابلت، عبد الله | Espaços ao redor de و e ال, nomes compostos |
| Pontuação | ، ou ؟ faltando | adicionados | Foi na pontuação que os anotadores do QALB menos concordaram |

Acompanhe a recall por classe. Um modelo que corrige o taa marbuta mas deixa passar a hamza depois de uma preposição precisa de exemplos desse padrão, não de outro modelo.

## Como pontuar um corretor?

A correção de erros gramaticais (GEC) é avaliada por edições. Compare as edições que transformam a fonte numa frase de referência corrigida à mão com as edições que a transformam na saída do modelo. A precision é a proporção de edições do modelo que coincidem com a referência. A recall é a proporção de edições de referência que o modelo fez. O QALB informava F1; trabalhos posteriores, inclusive o de Kwon et al., também informam F0.5, que dá à precision o dobro do peso da recall, porque uma “correção” errada irrita mais o usuário do que uma que faltou.

```python
from collections import Counter

def score(sources, golds, hyps, beta=0.5):
    """Exact-match edit scoring: an edit counts only if span and replacement both match gold."""
    tp = fp = fn = 0
    by_class = Counter()
    for s, g, h in zip(sources, golds, hyps):
        G = {e[:3] for e in edits(s, g)}
        H = {e[:3] for e in edits(s, h)}
        tp += len(G & H); fp += len(H - G); fn += len(G - H)
        for e in edits(s, g):
            by_class[(error_class(e[3], e[2]), e[:3] in H)] += 1
    p = tp / (tp + fp) if tp + fp else 1.0
    r = tp / (tp + fn) if tp + fn else 1.0
    f = (1 + beta**2) * p * r / (beta**2 * p + r) if p + r else 0.0
    recall = {c: f"{by_class[(c, True)]}/{by_class[(c, True)] + by_class[(c, False)]}"
              for c in sorted({c for c, _ in by_class})}
    return {"P": round(p, 3), "R": round(r, 3), f"F{beta}": round(f, 3), "recall by class": recall}
```

Num conjunto de brinquedo de duas frases com sete edições de referência, em que a saída deixou passar a junção e um taa marbuta e acrescentou um ponto final, o script imprimiu P 0.833, R 0.714 e F0.5 0.806, com recall por classe: hamza 2/2, taa marbuta 2/3, junção 0/1.

Essa é a ideia do M2, simplificada. O M2 scorer oficial procura o alinhamento das edições do sistema que melhor bate com a referência, então uma correção certa dividida em edições de outro jeito não é penalizada. A nossa correspondência exata é mais rígida. Use o scorer oficial quando for comparar com números publicados (a versão de desenvolvimento ainda exige Python 2). O ERRANT faz a mesma extração de edições, mas só para inglês.

Monte o conjunto de referência com texto real de usuários, de 100 a 200 frases, corrigidas por um único anotador cuidadoso com as mesmas regras de edição mínima que você deu ao modelo. Rode cada modelo e prompt candidato sobre ele e compare o F0.5 e a recall por classe. [Como avaliar um LLM antes de trocar](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/) explica como fazer essa comparação de forma justa.

## E o Tibyan e os dados sintéticos?

Dados rotulados de correção em árabe são escassos. Alrehili e Alhothali observam que o QALB-14 e o QALB-15 juntos têm cerca de 20.500 exemplos paralelos. O corpus Tibyan deles (arXiv 2024, depois na PeerJ Computer Science) usou o ChatGPT para gerar pares de frases com erro e corrigidas a partir de livros sobre erros comuns do árabe, revisados por linguistas. Ele tem cerca de 600.000 tokens, com sete tipos de erro: ortografia, morfologia, sintaxe, semântica, pontuação, junção e separação. Os autores dizem que o corpus é público; não encontramos um link de download para conferir a licença. Ele é útil para exemplos few-shot e testes de estresse, mas é sintético, então não o use como teste de aceitação.

Se você precisa de uma baseline sem LLM, o repositório arabic-gec do CAMeL Lab publica o código e os modelos de Alhafni et al. (EMNLP 2023). Só para ortografia, o pacote ar-corrector sugere palavras do dicionário a uma ou duas edições de distância; ele não trata gramática, e o último lançamento foi em 2021.

## Qual modelo da BroadNet usar?

Os preços são por 1M de tokens, da página de preços da BroadNet. A saída de uma correção tem mais ou menos o tamanho da entrada, então o preço de saída pesa.

| Modelo | Por quê | Entrada / saída |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) | Raciocínio documentado; a BroadNet informa testes em árabe, incluindo a compreensão dos dialetos do Golfo e egípcio | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) | Raciocínio documentado; contexto longo para documentos inteiros | $0.78 / $3.46 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | O menor preço de saída entre os modelos de raciocínio daqui; também disponível em planos de sessão com preço fixo | $0.175 / $0.52 |
| [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) | Roda com o crédito inicial de $5, então você monta o pipeline antes de recarregar | $0.10 / $0.22 |

Rode o scorer com cada modelo no seu conjunto de referência e escolha pelo F0.5 e pelo preço. O árabe costuma usar mais tokens por palavra que o inglês; cole uma amostra no [contador de tokens para árabe](https://broadrouter.com/tools/arabic-token-counter/) e estime a conta com a [calculadora de custo de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/). Para revisar um grande acervo: a BroadNet não tem Batch API; [processamento em lote sem uma Batch API](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/) mostra como fazer com concorrência limitada, ou numa sessão DeepSeek por $15 por semana (uma requisição por vez por sessão).

## Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. A [BroadNet Inference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-grammar-spelling-correction-llm&utm_content=body) dá acesso compatível com a OpenAI aos modelos acima, então o código roda com o [SDK Python da OpenAI](https://broadrouter.com/pt/guides/openai-python-sdk/) depois de trocar a base URL. Ela não tem endpoint de revisão de texto e não publica benchmark próprio de correção em árabe, então meça no seu texto. A declaração de privacidade dela diz que o conteúdo da inferência não é retido, o que importa quando você revisa mensagens de clientes. Se você precisa de um corretor auto-hospedado para volume muito alto, um modelo com fine-tuning como os do CAMeL Lab pode ser mais barato e mais consistente; as pontuações publicadas acima são o motivo para testar os dois.

Ferramentas gratuitas sobre o tema (em 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.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Hamza (letra árabe)](https://broadrouter.com/pt/glossary/hamza/)

Hamza (ء) é a letra árabe que representa a oclusiva glotal. Ela é escrita sozinha ou sobre um suporte: alef (أ إ), waw (ؤ) ou yeh (ئ), e آ junta alef e madda. Como o texto digitado é inconsistente com ela, buscadores e a avaliação de fala costumam reduzir as formas com alef a ا.

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

Ta marbuta (ة, U+0629) é uma letra árabe que só aparece no fim da palavra, muitas vezes marcando substantivos e adjetivos femininos. Ela parece um heh (ه, U+0647) com dois pontos, por isso o texto digitado mistura as duas, e muitos normalizadores de busca convertem ة em ه.

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Árabe padrão moderno (MSA)](https://broadrouter.com/pt/glossary/msa/)

O árabe padrão moderno (MSA) é a forma padronizada do árabe usada na escrita, no noticiário, na educação e na fala formal em todo o mundo árabe. Ele não é a língua materna do dia a dia de ninguém: as pessoas falam dialetos regionais, como o egípcio ou o árabe do Golfo, e passam para o MSA em contextos formais.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Base URL (URL base)](https://broadrouter.com/pt/glossary/base-url/)

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Batch API (API de lote)](https://broadrouter.com/pt/glossary/batch-api/)

Batch API é um endpoint assíncrono de LLM que aceita muitas requisições de uma vez, normalmente em um arquivo, processa tudo dentro de uma janela definida em vez de na hora e devolve os resultados juntos. Provedores como OpenAI e Anthropic cobram as requisições em lote com desconto em relação às APIs padrão.

[Fine-tuning (ajuste fino de LLM)](https://broadrouter.com/pt/glossary/fine-tuning/)

Fine-tuning é o processo de continuar treinando um modelo de linguagem pré-treinado com um conjunto de dados menor e específico, como conversas de exemplo, para que seus pesos mudem e ele execute aquela tarefa ou estilo de forma mais confiável, sem instruções longas ou exemplos em todo prompt.

## Perguntas frequentes

### O ChatGPT ou outro LLM consegue corrigir a gramática do árabe?

Sim, com limites. Num teste publicado no benchmark QALB-2014, o GPT-4 com cinco exemplos chegou a 65,49 de F1, perto mas abaixo de um AraT5v2 com fine-tuning, que fez 67,70. Use um prompt de edição mínima, confira a resposta no código e meça numa amostra do seu próprio texto.

### Quais são os erros de ortografia mais comuns em árabe?

Hamza sobre o alif (انا por أنا, الى por إلى), alef maqsura escrito como ya (مشي por مشى), taa marbuta escrito como ha (المدرسه por المدرسة) e palavras separadas ou juntadas por engano, como و قابلت por وقابلت. Os organizadores do QALB apontam os alifs com hamza e a confusão entre alef maqsura e ya como os mais comuns.

### Normalizar texto em árabe é o mesmo que corrigir a ortografia?

Não. A normalização junta de propósito variantes de grafia, como أ e ا, para que a busca e o matching as ignorem. A correção decide qual variante está certa no contexto. Corrija o texto original e normalize só a cópia que você indexa para a busca.

### Como avaliar um corretor gramatical de árabe?

Corrija à mão de 100 a 200 frases reais com edições mínimas. Extraia as edições no nível da palavra da fonte para a referência e da fonte para a saída do modelo, depois conte as que coincidem para calcular precision, recall e F0.5. O M2 scorer usado no QALB faz isso com um alinhamento de edições mais esperto.

### Existe uma biblioteca Python para checar a gramática do árabe?

Só para ortografia, o ar-corrector sugere palavras do dicionário a uma ou duas edições de distância. Para gramática, o CAMeL Lab publica código e modelos de GEC de pesquisa (arabic-gec). Uma API de LLM é o jeito mais rápido de começar; um modelo com fine-tuning pode ser mais consistente em alto volume.

## Continue lendo

-   [Normalizar texto em árabe para busca e RAG: o que mudar e o que não](https://broadrouter.com/pt/blog/arabic-text-normalization-search/)
-   [Diacríticos no árabe com um LLM: prompt, checagens e DER](https://broadrouter.com/pt/blog/arabic-diacritization-llm/)
-   [Engenharia de prompt em árabe: registro, RTL, números e texto misto](https://broadrouter.com/pt/blog/arabic-prompt-engineering/)
-   [Extrair entidades nomeadas em árabe com LLM: JSON, datas e checagens](https://broadrouter.com/pt/blog/arabic-named-entity-extraction-llm/)
-   [Como escolher uma API de LLM para árabe: o que testar](https://broadrouter.com/pt/blog/choosing-an-llm-for-arabic/)
-   [Como avaliar um LLM antes de trocar de provedor](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/)
-   [Processamento em lote com LLM sem Batch API: um runner retomável](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/)
-   [Atas de reuniões em árabe a partir de gravações: um pipeline de API](https://broadrouter.com/pt/blog/arabic-meeting-minutes-from-recordings/)
-   [OCR para árabe por API: Google, Azure, Textract, Mistral e LLMs](https://broadrouter.com/pt/blog/arabic-ocr-api-comparison/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-grammar-spelling-correction-llm&utm_content=page-cta) ·

**Fontes**

-   [Mohit et al., The First QALB Shared Task on Automatic Text Correction for Arabic, workshop ANLP no EMNLP 2014: dados, M2 scorer, Tabela 3 e Tabela 7 (consultado em 2026-11-15)](https://aclanthology.org/W14-3605/)
-   [Rozovskaya et al., The Second QALB Shared Task on Automatic Text Correction for Arabic, WANLP 2015: trilhas de nativos e L2, Tabelas 4, 8 e 9 (consultado em 2026-11-15)](https://aclanthology.org/W15-3204/)
-   [Kwon, Bhatia, Nagoudi e Abdul-Mageed, Beyond English: Evaluating LLMs for Arabic Grammatical Error Correction, ArabicNLP 2023, Tabela 2 (consultado em 2026-11-15)](https://aclanthology.org/2023.arabicnlp-1.9/)
-   [Alrehili e Alhothali, Tibyan Corpus: Balanced and Comprehensive Error Coverage Corpus Using ChatGPT for Arabic GEC, arXiv 2411.04588 (consultado em 2026-11-15)](https://arxiv.org/abs/2411.04588)
-   [Belkebir e Habash, Automatic Error Type Annotation for Arabic (ARETA), CoNLL 2021 (consultado em 2026-11-15)](https://aclanthology.org/2021.conll-1.47/)
-   [CAMeL Lab, ARETA no GitHub (MIT): tags de erro baseadas no ALC, como OH hamza, OT ha/ta marbuta, OA alif/ya, MG junção, SP separação (consultado em 2026-11-15)](https://github.com/CAMeL-Lab/arabic_error_type_annotation)
-   [Alhafni, Inoue, Khairallah e Habash, Advancements in Arabic Grammatical Error Detection and Correction, EMNLP 2023; código e modelos em CAMeL-Lab/arabic-gec (consultado em 2026-11-15)](https://aclanthology.org/2023.emnlp-main.396/)
-   [NUS M2Scorer no GitHub: precision, recall e F-beta no nível de edição para GEC; a versão de desenvolvimento exige Python 2 (consultado em 2026-11-15)](https://github.com/nusnlp/m2scorer)
-   [ERRANT no GitHub: extrai e classifica edições no formato M2; só inglês (consultado em 2026-11-15)](https://github.com/chrisjbryant/errant)
-   [ar-corrector no PyPI: corretor por dicionário, mais de 500.000 palavras, candidatos a 1-2 edições, versão 1.1.6 de abril de 2021 (consultado em 2026-11-15)](https://pypi.org/project/ar-corrector/)
-   [Referência da API da BroadNet Inference: IDs de modelo, o raciocínio conta para max\_tokens, reasoning\_effort (consultado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-grammar-spelling-correction-llm&utm_content=sources)
