---
title: "Traducir JSON de i18n al árabe con un LLM: plurales | BroadRouter"
description: "Traduzca archivos JSON de i18n al árabe con una API de LLM: congele placeholders, genere las seis formas de plural, valide ICU en CI y aísle los nombres insertados."
url: https://broadrouter.com/es/blog/translate-app-strings-to-arabic-llm/
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/translate-app-strings-to-arabic-llm/) (actualizado el 2026-11-15).

# Traducir textos de apps al árabe con un LLM: placeholders y plurales

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

Para traducir textos de una app al árabe con un LLM, envíelos como JSON con cada placeholder sustituido por un marcador, pida las seis formas de plural del árabe (zero, one, two, few, many, other) y construya el plural ICU en código, no en el modelo. Valide en CI: mismas claves, argumentos y etiquetas, y las seis formas. Envuelva los nombres insertados en aislantes Unicode para mostrar bien el texto de derecha a izquierda.

## Puntos clave

-   El árabe tiene seis categorías de plural cardinal en CLDR. Los archivos fuente en inglés tienen dos, así que el modelo debe escribir cuatro formas que no existen en el original.
-   Una forma árabe que falta falla en silencio. En nuestra prueba, un mensaje ICU con solo one y other mostró «2 ملف» para 2 archivos en lugar del dual ملفان, sin ningún error.
-   Sustituya placeholders y etiquetas por marcadores como ⟦0⟧ antes de la solicitud y restáurelos después. El modelo no puede traducir lo que no ve.
-   Deje que el código arme la sintaxis de plural ICU a partir de seis cadenas simples. Luego analice cada mensaje con el parser de FormatJS en CI y haga fallar el build ante cualquier hueco.
-   Los nombres interpolados y los nombres de producto en alfabeto latino dentro del árabe necesitan aislamiento bidireccional: bdi o dir="auto" en HTML, U+2068 y U+2069 en texto plano.

**En esta página**

1.  ¿Por qué los plurales árabes rompen los archivos de cadenas traducidos automáticamente?
2.  ¿Cómo debe enviar las cadenas al modelo?
3.  El script de traducción
4.  ¿Cómo se valida el archivo árabe en CI?
5.  ¿Y la visualización de derecha a izquierda?
6.  ¿Quién debe revisar la salida?
7.  ¿Cuánto cuesta?
8.  Dónde encaja BroadNet Inference

Traducir los archivos de cadenas de una app es un trabajo distinto de traducir prosa. Cada valor es corto, a menudo no tiene contexto y lleva sintaxis que el modelo no debe tocar: placeholders, etiquetas HTML y reglas de plural. El árabe complica esto último: los archivos en inglés tienen dos formas de plural y el árabe necesita seis. Este artículo construye un pequeño pipeline sobre un LLM compatible con OpenAI: congelar los placeholders, pedir seis cadenas de plural simples, armar la sintaxis ICU en código y validarlo todo en CI.

Para traducir documentos, tickets y contratos, consulte [traducción árabe–inglés con LLM](https://broadrouter.com/es/blog/arabic-english-translation-llm/), que cubre el tono, los glosarios y la evaluación para prosa.

## ¿Por qué los plurales árabes rompen los archivos de cadenas traducidos automáticamente?

Unicode CLDR, que siguen `Intl.PluralRules`, ICU e i18next, asigna al árabe seis categorías cardinales:

| Categoría | Regla de CLDR | Números de ejemplo | Ejemplo: “archivo” |
| --- | --- | --- | --- |
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (dual) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (plural) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (singular, acusativo) |
| other | todo lo demás | 100–102, 1000, 0.5 | 100 ملف (singular) |

Dos detalles confunden a la gente. Primero, las categorías no son los números: 103 es few y 111 es many. Segundo, un original en inglés solo da al modelo `one` y `other`, así que tiene que inventar cuatro formas a partir de la gramática. La mayoría de los fallos vienen de que el modelo copia el par inglés.

El fallo es silencioso. Renderizamos un mensaje árabe que solo tenía `one` y `other` con intl-messageformat 12.1.5: 0, 2 y 11 archivos salieron todos como «N ملف». i18next 27.1.2 se comportó igual cuando faltaba la clave `_many`: 11 archivos mostraron el texto de `_other`. Ni error ni aviso, solo árabe incorrecto.

## ¿Cómo debe enviar las cadenas al modelo?

Agrúpelas en lotes. Una solicitud por cadena desperdicia tokens en el prompt de sistema y pierde el contexto entre cadenas relacionadas. Envíe de 50 a 200 claves a la vez como un objeto JSON, agrupadas por pantalla o por función, para que “Save” junto a “Cancel” se lea como un botón.

Tres reglas hacen que la respuesta sea verificable:

1.  **Congele los placeholders.** Sustituya `{name}`, los placeholders de i18next con llaves dobles, `%s`, `%1$s` y etiquetas como `<b>` por marcadores como ⟦0⟧. El modelo ve “Welcome back, ⟦0⟧!” y no puede traducir `name` por اسم.
2.  **Pida las formas de plural como cadenas simples.** Envíe los textos `one` y `other` en inglés y pida seis cadenas en árabe. El código construye la sintaxis ICU. El modelo nunca escribe una llave.
3.  **Dé un glosario y una lista de términos que no se traducen.** Nombres de producto, nombres de planes y términos que usa su equipo de soporte. La [sección de glosario del artículo sobre traducción](https://broadrouter.com/es/blog/arabic-english-translation-llm/) explica por qué esto importa más que la elección del modelo.

## El script de traducción

El archivo fuente usa ICU MessageFormat, la sintaxis que documenta FormatJS. La misma congelación funciona con el formato JSON propio de i18next, cuyas claves de plural terminan en `_zero`, `_one`, `_two`, `_few`, `_many` y `_other`.

```json
{
  "save": "Save",
  "welcome": "Welcome back, {name}!",
  "invite": "<b>{inviter}</b> invited you to the {workspace} workspace",
  "billing": "Pay with AcmePay",
  "files": "{count, plural, one {# file} other {# files}}"
}
```

```python
import json, os, re
from openai import OpenAI

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

FORMS = ["zero", "one", "two", "few", "many", "other"]
# ICU arguments, double-brace and printf placeholders, HTML-style tags
PH = re.compile(r"\{\{\s*\w+\s*\}\}|\{\w+\}|%(?:\d+\$)?[sdif@]|</?\w+[^>]*>")
PLURAL = re.compile(r"^\{(\w+), plural,(.*)\}$", re.S)

def freeze(text):
    """Replace each placeholder with ⟦n⟧ so the model cannot translate or break it."""
    found = PH.findall(text)
    for i, p in enumerate(found):
        text = text.replace(p, f"⟦{i}⟧", 1)
    return text, found

def thaw(text, found):
    for i, p in enumerate(found):
        text = text.replace(f"⟦{i}⟧", p)
    return text

def branches(body):
    """'one {# file} other {# files}' -> {'one': '# file', 'other': '# files'}."""
    out, i = {}, 0
    while i < len(body):
        m = re.compile(r"\s*([=\w]+)\s*\{").match(body, i)
        if not m:
            break
        depth, j = 1, m.end()
        while depth:
            depth += {"{": 1, "}": -1}.get(body[j], 0)
            j += 1
        out[m.group(1)] = body[m.end():j - 1]
        i = j
    return out

SYSTEM = """You translate app interface strings from English to Modern Standard Arabic.
Reply with one JSON object only: {"STRINGS": {key: Arabic}, "PLURALS": {key: {six forms}}}.
Rules:
- ⟦0⟧, ⟦1⟧ ... are placeholders. Keep every one exactly once and unchanged; move it if Arabic word order needs it.
- # stands for the number. Keep it where the number should appear.
- Interface style: short, no full stops on buttons or labels.
- Never translate terms in DO_NOT_TRANSLATE. Use GLOSSARY translations exactly.
- For each PLURALS key, return all six Arabic forms: zero, one, two, few, many, other.
  zero = none; one = singular without a number; two = dual without a number;
  few = 3-10: # + plural noun; many = 11-99: # + singular noun in the accusative;
  other = 100, 1000 and also 0.5 and 1.5: # + singular noun."""

def translate(src, glossary=None, dnt=(), model="broadnet/qwen3.8-27b"):
    strings, plurals, frozen = {}, {}, {}
    for key, text in src.items():
        m = PLURAL.match(text)
        if m:
            b = branches(m.group(2))
            fone, ph = freeze(b.get("one", b["other"]))
            fother, _ = freeze(b["other"])
            plurals[key] = {"one": fone, "other": fother}
            frozen[key] = (m.group(1), ph)
        elif "{" in PH.sub("", text):
            raise ValueError(f"{key}: nested ICU, send to a human")
        else:
            strings[key], ph = freeze(text)
            frozen[key] = (None, ph)
    payload = {"STRINGS": strings, "PLURALS": plurals,
               "GLOSSARY": glossary or {}, "DO_NOT_TRANSLATE": list(dnt)}
    r = client.chat.completions.create(
        model=model, max_tokens=4000, temperature=0.2,
        messages=[{"role": "system", "content": SYSTEM},
                  {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}])
    out = json.loads(r.choices[0].message.content)
    ar = {k: thaw(v, frozen[k][1]) for k, v in out.get("STRINGS", {}).items() if k in frozen}
    for k, forms in out.get("PLURALS", {}).items():
        if k not in frozen:
            continue
        arg, ph = frozen[k]
        ar[k] = "{%s, plural, %s}" % (arg, " ".join(
            f + " {" + thaw(forms[f], ph) + "}" for f in FORMS if f in forms))
    return ar

en = json.load(open("en.json"))
ar = translate(en, glossary={"workspace": "مساحة العمل"}, dnt=["AcmePay"])
json.dump(ar, open("ar.json", "w"), ensure_ascii=False, indent=2)
```

Lo ejecutamos con el SDK de OpenAI para Python contra un servidor simulado local, no contra la API real, con una respuesta en árabe predefinida. La solicitud que vería el modelo contenía “Welcome back, ⟦0⟧!” y “⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace”, y el script escribió este `ar.json`:

```json
{
  "save": "حفظ",
  "welcome": "مرحبًا بعودتك يا {name}!",
  "invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
  "billing": "ادفع عبر AcmePay",
  "files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}
```

Notas sobre el código:

-   **Los marcadores se mueven, no desaparecen.** El árabe suele poner el verbo primero, así que ⟦0⟧ puede cambiar de sitio. El control de abajo cuenta los marcadores; no le importa dónde estén.
-   **El ICU anidado va a una persona.** Un `select` dentro de un `plural` es raro y fácil de romper. El script lo rechaza en lugar de adivinar.
-   **`max_tokens=4000` deja margen para el razonamiento.** La documentación de BroadNet indica que DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder, y que el razonamiento cuenta para [max\_tokens](https://broadrouter.com/es/glossary/max-tokens/). Consulte [respuestas vacías de los modelos de razonamiento](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/).
-   **`json.loads` puede fallar.** Envuélvalo y reenvíe una vez con el error; [cómo arreglar JSON no válido de un LLM](https://broadrouter.com/es/blog/fix-invalid-json-from-llm/) tiene una función de reparación probada. En GLM 5.3 y Qwen3.8 27B, los dos modelos de BroadNet documentados con [salida estructurada](https://broadrouter.com/es/glossary/structured-output/), añada también un esquema `response_format`. El control de abajo se mantiene en ambos casos.

## ¿Cómo se valida el archivo árabe en CI?

Analice cada mensaje con el mismo parser que usa su app en tiempo de ejecución y compárelo con el original. Este script de Node usa `@formatjs/icu-messageformat-parser` (versión 3.5.23 en nuestra prueba):

```js
// node check-ar.mjs en.json ar.json  -> exits 1 on any problem
import { readFileSync } from "node:fs";
import { parse, TYPE } from "@formatjs/icu-messageformat-parser";

const AR_FORMS = ["zero", "one", "two", "few", "many", "other"];
const [en, ar] = process.argv.slice(2).map((p) => JSON.parse(readFileSync(p, "utf8")));
const errors = [];

// Collect argument and tag names; return the plural elements too.
function walk(nodes, names = [], plurals = []) {
  for (const n of nodes) {
    if (n.type === TYPE.literal || n.type === TYPE.pound) continue;
    names.push(n.type === TYPE.tag ? `<${n.value}>` : `{${n.value}}`);
    if (n.type === TYPE.tag) walk(n.children, names, plurals);
    if (n.type === TYPE.plural) plurals.push(n);
    if (n.options) for (const o of Object.values(n.options)) walk(o.value, [], plurals);
  }
  return { names: names.sort().join(" "), plurals };
}

for (const key of Object.keys(en)) {
  if (!(key in ar)) { errors.push(`${key}: missing`); continue; }
  let src, dst;
  try { src = walk(parse(en[key])); dst = walk(parse(ar[key], { requiresOtherClause: true })); }
  catch (e) { errors.push(`${key}: ICU syntax error ${e.message}`); continue; }
  if (src.names !== dst.names) errors.push(`${key}: arguments differ: [${src.names}] vs [${dst.names}]`);
  for (const p of dst.plurals) {
    const missing = AR_FORMS.filter((f) => !(f in p.options));
    if (missing.length) errors.push(`${key}: plural {${p.value}} lacks ${missing.join(", ")}`);
  }
  if (!/[؀-ۿ]/.test(ar[key])) errors.push(`${key}: no Arabic letters`);
  if (/⟦\d+⟧/.test(ar[key])) errors.push(`${key}: placeholder marker left in text`);
}
for (const key of Object.keys(ar)) if (!(key in en)) errors.push(`${key}: not in source`);
console.log(errors.join("\n") || "ok");
process.exit(errors.length ? 1 : 0);
```

Con el archivo anterior imprimió `ok`. Luego hicimos que la respuesta simulada omitiera la forma `many` y el marcador `{workspace}`. El script terminó con código 1 e imprimió:

```text
invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many
```

La regla “no Arabic letters” detecta las cadenas que el modelo dejó en inglés. También marca valores que son solo un nombre de producto o un número, así que mantenga una lista de excepciones para ellos. Para el formato propio de i18next, aplique los mismos controles por clave: cada par `_one`/`_other` en inglés necesita las seis claves con sufijo en árabe, y cada una necesita los mismos placeholders, salvo que `_zero`, `_one` y `_two` pueden prescindir del número.

Por último, renderice unos cuantos números con su formateador real. Con intl-messageformat 12.1.5, el mensaje `files` de arriba dio 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف y 111 → 111 ملفًا. Esa comprobación puntual detecta una forma que se analiza bien pero usa el sustantivo equivocado.

## ¿Y la visualización de derecha a izquierda?

La traducción acierta con las palabras; el navegador todavía tiene que ordenarlas. Cuando se inserta un nombre latino o un número en una oración árabe, el algoritmo bidireccional de Unicode puede mover la puntuación o intercambiar tramos contiguos. El consejo del W3C es aislar el texto insertado: envolverlo en `<bdi>` o en un elemento con `dir="auto"` en HTML, o rodearlo con U+2068 FIRST STRONG ISOLATE y U+2069 POP DIRECTIONAL ISOLATE en texto plano, como en las notificaciones push.

Hágalo donde interpola, no en la traducción. En nuestra prueba, formatear el mensaje de bienvenida con el nombre envuelto en U+2068 y U+2069 conservó ambos caracteres en la salida y dejó intacto el árabe. Configure también `dir="rtl"` y `lang="ar"` en la página o el contenedor. [Ingeniería de prompts para árabe](https://broadrouter.com/es/blog/arabic-prompt-engineering/) tiene una breve lista de comprobación para errores de visualización RTL.

Los dígitos son una decisión del formateador, no de la traducción. Mantenga `#` o el argumento en la cadena. En Node 24 (ICU 78.3), `Intl.NumberFormat` escribió 1234 como 1,234 para `ar` y como ١٬٢٣٤ para `ar-EG` y `ar-SA`. Elija la etiqueta de configuración regional que corresponda a su mercado. Para las cuestiones de producto más amplias (idioma de la interfaz frente a idioma del modelo, burbujas de chat con direcciones mezcladas, detección de idioma y costo por idioma), consulte [diseñar una experiencia de IA en varios idiomas](https://broadrouter.com/es/blog/multilingual-product-design/).

## ¿Quién debe revisar la salida?

Un pipeline de LLM con estos controles garantiza que el archivo esté bien formado. No garantiza que el árabe sea correcto. Pida a un hablante de árabe que revise:

-   **Solo las cadenas nuevas y modificadas.** Compare `en.json` con la última versión y traduzca solo lo que cambió. Las revisiones se mantienen pequeñas y las cadenas aprobadas no se mueven.
-   **Las formas de plural, palabra por palabra.** La concordancia con los números es donde el modelo falla más a menudo, sobre todo el acusativo tras 11 a 99.
-   **El género.** En árabe, “tú” y los verbos cambian según el género del lector. Si su interfaz se dirige directamente a los usuarios, decida una convención, como una forma fija o una reformulación neutra, y póngala en el prompt de sistema.
-   **La longitud.** Las cadenas en árabe pueden ser más largas o más cortas que en inglés. Revise botones y pestañas en el diseño real con ancho de móvil.

Mantenga un archivo de glosario revisado en el repositorio y envíelo con cada solicitud, para que los términos aprobados no cambien.

## ¿Cuánto cuesta?

Los archivos de cadenas son pequeños. La salida es casi tan larga como la entrada, y el árabe suele necesitar más tokens por palabra que el inglés; [tokens por palabra en árabe e inglés](https://broadrouter.com/es/blog/tokens-per-word-arabic-english/) tiene proporciones medidas. Pegue un lote en el [contador de tokens en árabe](https://broadrouter.com/tools/arabic-token-counter/), multiplique por el número de lotes y añada el prompt de sistema a cada uno. Los modelos de razonamiento también gastan tokens pensando; BroadNet los reporta en `usage` como `completion_tokens_details.reasoning_tokens`, así que lea `usage` de una solicitud real antes de extrapolar.

| Modelo | Notas para este trabajo | Entrada / salida por 1M de tokens |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) | Salida estructurada documentada | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) | Salida estructurada documentada; contexto de 1,048,576 tokens | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/) | Funciona con el crédito inicial de $5; JSON solo por prompt, así que el validador importa más | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) | También en planes de tarifa plana, como $15 a la semana por sesión, una solicitud a la vez por sesión | $0.175 / $0.52 |

Los precios proceden del feed de precios de BroadNet, actualizado el 2026-11-14. Traduzca las mismas 100 cadenas con dos modelos y pida a su revisor que las compare antes de elegir; el precio por token importa menos que el número de correcciones. Para miles de claves en muchos idiomas, [procesamiento por lotes sin una Batch API](https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/) cubre la concurrencia y los reintentos.

## Dónde encaja BroadNet Inference

BroadRouter es el sitio de la propia BroadNet. BroadNet Inference ofrece acceso compatible con OpenAI a los modelos anteriores, así que el script funciona con el [SDK de OpenAI para Python](https://broadrouter.com/es/guides/openai-python-sdk/) tras cambiar la URL base y el ID del modelo; consulte la [referencia de la API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-translate-app-strings-to-arabic-llm&utm_content=body) para los parámetros que admite cada modelo. No tiene endpoint de traducción y no publica un benchmark de localización, así que el validador y un revisor humano siguen siendo su control de calidad. Las plataformas de localización dedicadas añaden memoria de traducción, flujos de revisión y capturas de pantalla en contexto; si las necesita, use una y mantenga el control de CI anterior como segunda línea.

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

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

[Prompt de sistema (system prompt)](https://broadrouter.com/es/glossary/system-prompt/)

Un prompt de sistema es el texto de instrucciones que una aplicación envía a un modelo de lenguaje antes de la conversación, normalmente como mensaje con el rol system o developer. Define el rol, las reglas, el tono y el formato de salida del modelo, que debe priorizarlo sobre mensajes del usuario que lo contradigan.

[Salida estructurada (structured output)](https://broadrouter.com/es/glossary/structured-output/)

La salida estructurada es una función de las APIs de LLM que restringe la respuesta del modelo a un formato que define el desarrollador, normalmente un JSON Schema, para que el código pueda procesarla de forma fiable. Es más estricta que JSON mode, que garantiza JSON válido pero no una forma concreta.

[Batch API (API de procesamiento por lotes)](https://broadrouter.com/es/glossary/batch-api/)

Una Batch API es un endpoint asíncrono de LLM que acepta muchas solicitudes a la vez, normalmente en un archivo, las procesa dentro de un plazo fijado en lugar de inmediatamente y devuelve los resultados juntos. Proveedores como OpenAI y Anthropic cobran las solicitudes por lotes con descuento respecto de sus APIs estándar.

[Concurrencia (concurrency)](https://broadrouter.com/es/glossary/concurrency/)

La concurrencia es el número de solicitudes que un cliente tiene en curso al mismo tiempo. Las APIs de LLM suelen limitarla por clave o por plan, aparte de las solicitudes por minuto, porque cada solicitud abierta ocupa capacidad de GPU hasta que su respuesta termina.

[Ingeniería de prompts (prompt engineering)](https://broadrouter.com/es/glossary/prompt-engineering/)

La ingeniería de prompts es el proceso de escribir, estructurar y probar las instrucciones que se dan a un modelo de lenguaje para que produzca de forma constante una salida que cumpla sus requisitos. Abarca los mensajes de rol, instrucciones claras, ejemplos, formato y la medición de resultados con casos de prueba.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[max\_tokens (límite de tokens de salida)](https://broadrouter.com/es/glossary/max-tokens/)

max\_tokens es un parámetro de las APIs de LLM que fija el máximo de tokens que un modelo puede generar en una respuesta. Cuando la generación llega al límite, se detiene y la respuesta queda marcada como cortada, por ejemplo con finish\_reason en "length".

## Preguntas frecuentes

### ¿Cuántas formas de plural tiene el árabe?

Seis categorías cardinales en Unicode CLDR: zero (0), one (1), two (2), few (números que terminan en 03 a 10, como 3 a 10 y 103), many (que terminan en 11 a 99) y other (100 a 102, 1000 y decimales como 0.5). Un archivo en inglés solo tiene one y other.

### ¿Puede ChatGPT u otro LLM traducir mi archivo JSON de i18n al árabe?

Sí, si usted controla el formato. Envíe solo los valores, sustituya los placeholders por marcadores, pida seis formas de plural y verifique el resultado en código: claves, argumentos, etiquetas y categorías de plural. Pida a un hablante de árabe que revise las cadenas nuevas antes de publicar.

### ¿Qué pasa si a una traducción al árabe le falta una forma de plural?

Normalmente no falla nada visible. i18next e intl-messageformat recurren a la forma other, así que 2 archivos se muestra como «2 ملف» en lugar del dual ملفان. Solo un validador que exija las seis formas lo detecta antes que los usuarios.

### ¿Debe el LLM escribir él mismo la sintaxis ICU MessageFormat?

Mejor que no. Pida seis cadenas simples por mensaje de plural y arme la sintaxis ICU en código. Los modelos a veces pierden una llave o traducen el nombre del argumento, y entonces un error del parser rompe todo el paquete en tiempo de ejecución.

### ¿Qué dígitos deben usar las cadenas de interfaz en árabe?

Deje que decida el formateador de números, no la traducción. Mantenga # o el argumento en la cadena. En nuestra prueba con Node 24, Intl.NumberFormat formateó 1234 como 1,234 para ar y como ١٬٢٣٤ para ar-EG y ar-SA, así que la etiqueta de configuración regional fija los dígitos.

## Siga leyendo

-   [Traducción árabe–inglés con LLM: prompts, glosarios y evaluación](https://broadrouter.com/es/blog/arabic-english-translation-llm/)
-   [Ingeniería de prompts en árabe: registro, RTL, cifras y texto mixto](https://broadrouter.com/es/blog/arabic-prompt-engineering/)
-   [Modo JSON o json\_schema: salida estructurada que no falla](https://broadrouter.com/es/blog/structured-output-json-schema/)
-   [Cómo corregir JSON inválido de un LLM: causas, reparación y reintento](https://broadrouter.com/es/blog/fix-invalid-json-from-llm/)
-   [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/)
-   [Procesamiento por lotes con LLM sin Batch API: un runner reanudable](https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/)
-   [Cómo diseñar una experiencia de IA para varios idiomas](https://broadrouter.com/es/blog/multilingual-product-design/)
-   [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/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)

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-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**Fuentes**

-   [Unicode CLDR, tabla Language Plural Rules: categorías cardinales del árabe zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (consultada el 2026-11-15)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): el árabe tiene 6 formas para los números cardinales (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, sintaxis de mensajes: categorías de plural, coincidencias exactas =value, el símbolo #, other es obligatorio, escape con apóstrofo (consultado el 2026-11-15)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [Documentación de i18next, plurales: sufijos \_zero, \_one, \_two, \_few, \_many, \_other, ejemplo en árabe, Intl.PluralRules, variable count (consultada el 2026-11-15)](https://www.i18next.com/translation-function/plurals)
-   [Documentación de i18next, formato JSON: claves de plural de v4 e interpolación (consultada el 2026-11-15)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, marcado en línea y texto bidireccional en HTML: dir, bdi, FSI U+2068 y PDI U+2069 (consultado el 2026-11-15)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [Referencia de la API de BroadNet Inference: IDs de modelo, salida estructurada para GLM 5.3 y Qwen3.8 27B, el razonamiento cuenta para max\_tokens (consultada el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
