---
title: "LLM से i18n JSON का अरबी अनुवाद: plural रूप | BroadRouter"
description: "LLM API से i18n JSON फ़ाइलों का अरबी अनुवाद करें: placeholders फ़्रीज़ करें, अरबी के छहों plural रूप बनवाएँ, CI में ICU syntax जाँचें और डाले गए नाम isolate करें।"
url: https://broadrouter.com/hi/blog/translate-app-strings-to-arabic-llm/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/) (2026-11-15 को अपडेट किया गया).

# LLM से ऐप strings का अरबी अनुवाद: placeholders और plurals

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित 2026-11-15

Strings को JSON के रूप में भेजें, हर placeholder की जगह एक marker रखें, अरबी के छहों plural रूप (zero, one, two, few, many, other) माँगें, और ICU plural मॉडल में नहीं, कोड में बनाएँ। CI में जाँचें: वही keys, वही arguments और tags, छहों रूप मौजूद। डाले गए नामों को Unicode isolates में लपेटें ताकि दाएँ से बाएँ टेक्स्ट सही दिखे।

## मुख्य बातें

-   CLDR में अरबी की छह cardinal plural categories हैं। अंग्रेज़ी source फ़ाइलों में दो होती हैं, इसलिए मॉडल को ऐसे चार रूप लिखने पड़ते हैं जो source में हैं ही नहीं।
-   अरबी का छूटा रूप चुपचाप फ़ेल होता है। हमारे टेस्ट में सिर्फ़ one और other वाला ICU message 2 फ़ाइलों के लिए dual ملفان की जगह "2 ملف" दिखा रहा था, बिना किसी error के।
-   अनुरोध से पहले placeholders और tags को ⟦0⟧ जैसे markers से बदलें और बाद में वापस रखें। जो मॉडल देख नहीं सकता, उसका अनुवाद भी नहीं कर सकता।
-   ICU plural syntax को कोड छह सादी strings से जोड़े। फिर CI में हर message को FormatJS parser से parse करें और किसी भी कमी पर build फ़ेल करें।
-   अरबी के अंदर डाले गए नाम और लैटिन प्रोडक्ट नामों को bidi isolation चाहिए: HTML में bdi या dir="auto", सादे टेक्स्ट में U+2068 और U+2069।

**इस पेज पर**

1.  अरबी plurals मशीन से अनूदित string फ़ाइलों को क्यों तोड़ते हैं?
2.  Strings मॉडल को कैसे भेजें?
3.  अनुवाद script
4.  CI में अरबी फ़ाइल कैसे validate करें?
5.  दाएँ से बाएँ दिखने का क्या?
6.  आउटपुट की समीक्षा कौन करे?
7.  लागत कितनी है?
8.  BroadNet Inference कहाँ फ़िट होता है

किसी ऐप की string फ़ाइलों का अनुवाद गद्य के अनुवाद से अलग काम है। हर value छोटी होती है, अक्सर बिना संदर्भ के, और उसमें ऐसा syntax होता है जिसे मॉडल को छूना नहीं चाहिए: placeholders, HTML tags और plural नियम। अरबी आख़िरी वाले को मुश्किल बनाती है। अंग्रेज़ी फ़ाइलों में दो plural रूप होते हैं; अरबी को छह चाहिए। यह पोस्ट OpenAI-compatible LLM पर एक छोटी पाइपलाइन बनाती है: placeholders फ़्रीज़ करें, छह सादी plural strings माँगें, ICU syntax कोड में जोड़ें, फिर CI में सब कुछ validate करें।

दस्तावेज़ों, टिकटों और कॉन्ट्रैक्ट के अनुवाद के लिए देखें [LLM से अरबी–अंग्रेज़ी अनुवाद](https://broadrouter.com/hi/blog/arabic-english-translation-llm/), जो गद्य के लिए लहजा, शब्दावली और मूल्यांकन समझाती है।

## अरबी plurals मशीन से अनूदित string फ़ाइलों को क्यों तोड़ते हैं?

Unicode CLDR, जिसे `Intl.PluralRules`, ICU और i18next सभी मानते हैं, अरबी को छह cardinal categories देता है:

| Category | CLDR नियम | उदाहरण संख्याएँ | उदाहरण: “फ़ाइल” |
| --- | --- | --- | --- |
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (dual) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (बहुवचन) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (एकवचन, accusative) |
| other | बाक़ी सब | 100–102, 1000, 0.5 | 100 ملف (एकवचन) |

दो बातें लोगों को चौंकाती हैं। पहली, categories संख्याएँ नहीं हैं: 103 few है और 111 many। दूसरी, अंग्रेज़ी source मॉडल को सिर्फ़ `one` और `other` देता है, इसलिए उसे चार रूप सिर्फ़ व्याकरण से गढ़ने पड़ते हैं। ज़्यादातर नाकामियाँ मॉडल के अंग्रेज़ी जोड़े की नक़ल करने से आती हैं।

नाकामी चुपचाप होती है। हमने intl-messageformat 12.1.5 से एक ऐसा अरबी message render किया जिसमें सिर्फ़ `one` और `other` थे: 0, 2 और 11 फ़ाइलें सभी “N ملف” के रूप में आईं। `_many` key न होने पर i18next 27.1.2 ने भी यही किया: 11 फ़ाइलों पर `_other` वाला टेक्स्ट दिखा। कोई error नहीं, कोई चेतावनी नहीं, बस ग़लत अरबी।

## Strings मॉडल को कैसे भेजें?

उन्हें batch में भेजें। हर string के लिए एक अनुरोध system prompt पर टोकन बर्बाद करता है और जुड़ी strings के बीच का संदर्भ खो देता है। एक बार में 50 से 200 keys एक JSON object के रूप में भेजें, स्क्रीन या फ़ीचर के हिसाब से समूह बनाकर, ताकि “Cancel” के पास रखा “Save” बटन की तरह पढ़ा जाए।

तीन नियम जवाब को जाँचने लायक़ बनाते हैं:

1.  **Placeholders फ़्रीज़ करें।** `{name}`, i18next के double-brace placeholders, `%s`, `%1$s` और `<b>` जैसे tags को ⟦0⟧ जैसे markers से बदलें। मॉडल “Welcome back, ⟦0⟧!” देखता है और `name` का اسم में अनुवाद नहीं कर सकता।
2.  **Plural रूप सादी strings के रूप में माँगें।** अंग्रेज़ी के `one` और `other` टेक्स्ट भेजें और छह अरबी strings माँगें। ICU syntax कोड बनाता है। मॉडल कभी brace नहीं लिखता।
3.  **शब्दावली और अनुवाद-न-करें सूची दें।** प्रोडक्ट नाम, प्लान नाम और आपकी सपोर्ट टीम के शब्द। [अनुवाद वाली पोस्ट का शब्दावली हिस्सा](https://broadrouter.com/hi/blog/arabic-english-translation-llm/) बताता है कि यह मॉडल चुनने से ज़्यादा क्यों मायने रखता है।

## अनुवाद script

Source फ़ाइल ICU MessageFormat इस्तेमाल करती है, वह syntax जिसे FormatJS document करता है। यही फ़्रीज़िंग i18next के अपने JSON फ़ॉर्मैट पर भी काम करती है, जिसकी plural keys `_zero`, `_one`, `_two`, `_few`, `_many` और `_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)
```

हमने इसे OpenAI Python SDK के साथ live API पर नहीं, एक लोकल mock सर्वर पर चलाया, पहले से तय अरबी जवाब के साथ। मॉडल को दिखने वाले अनुरोध में “Welcome back, ⟦0⟧!” और “⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace” थे, और script ने यह `ar.json` लिखा:

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

कोड पर नोट्स:

-   **Markers जगह बदलते हैं, ग़ायब नहीं होते।** अरबी अक्सर क्रिया पहले रखती है, इसलिए ⟦0⟧ खिसक सकता है। नीचे की जाँच markers गिनती है; उसे परवाह नहीं कि वे कहाँ हैं।
-   **Nested ICU इंसान के पास जाता है।** `plural` के अंदर `select` कम मिलता है और आसानी से टूटता है। Script अंदाज़ा लगाने की जगह उसे मना कर देती है।
-   **`max_tokens=4000` reasoning के लिए जगह छोड़ता है।** BroadNet के docs कहते हैं कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले reasoning करते हैं, और reasoning [max\_tokens](https://broadrouter.com/hi/glossary/max-tokens/) में गिनी जाती है। देखें [reasoning मॉडलों से ख़ाली जवाब](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)।
-   **`json.loads` फ़ेल हो सकता है।** उसे wrap करें और error के साथ एक बार दोबारा भेजें; [LLM से आए invalid JSON को ठीक करना](https://broadrouter.com/hi/blog/fix-invalid-json-from-llm/) में एक टेस्ट किया हुआ repair function है। GLM 5.3 और Qwen3.8 27B पर, जो [structured output](https://broadrouter.com/hi/glossary/structured-output/) के साथ documented दो BroadNet मॉडल हैं, एक `response_format` schema भी जोड़ें। नीचे की जाँच दोनों हालात में रहती है।

## CI में अरबी फ़ाइल कैसे validate करें?

हर message को उसी parser से parse करें जो आपका ऐप runtime पर इस्तेमाल करता है, और source से मिलाएँ। यह Node script `@formatjs/icu-messageformat-parser` इस्तेमाल करती है (हमारे टेस्ट में वर्ज़न 3.5.23):

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

ऊपर वाली फ़ाइल पर इसने `ok` छापा। फिर हमने mock जवाब से `many` रूप और `{workspace}` marker हटवा दिए। Script code 1 के साथ बाहर निकली और यह छापा:

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

“no Arabic letters” नियम उन strings को पकड़ता है जिन्हें मॉडल ने अंग्रेज़ी में छोड़ दिया। यह उन values को भी पकड़ता है जो सिर्फ़ प्रोडक्ट नाम या संख्या हैं, इसलिए उनके लिए एक allow-list रखें। i18next के अपने फ़ॉर्मैट के लिए हर key पर वही जाँचें लगाएँ: अंग्रेज़ी के हर `_one`/`_other` जोड़े के लिए अरबी में छहों suffix वाली keys चाहिए, और हर एक में वही placeholders, सिवाय इसके कि `_zero`, `_one` और `_two` count छोड़ सकते हैं।

आख़िर में, कुछ संख्याएँ अपने असली formatter से render करें। intl-messageformat 12.1.5 के साथ ऊपर वाले `files` message ने 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف और 111 → 111 ملفًا दिया। यह छोटी जाँच ऐसा रूप पकड़ती है जो parse तो होता है पर ग़लत संज्ञा इस्तेमाल करता है।

## दाएँ से बाएँ दिखने का क्या?

अनुवाद शब्द सही करता है; ब्राउज़र को फिर भी उन्हें क्रम में लगाना होता है। जब कोई लैटिन नाम या संख्या अरबी वाक्य में डाली जाती है, तो Unicode bidirectional algorithm विराम चिह्न खिसका सकता है या पास के हिस्सों को अदल-बदल सकता है। W3C की सलाह है कि डाले गए टेक्स्ट को isolate करें: HTML में उसे `<bdi>` या `dir="auto"` वाले element में लपेटें, या सादे टेक्स्ट, जैसे push notifications, में उसके दोनों ओर U+2068 FIRST STRONG ISOLATE और U+2069 POP DIRECTIONAL ISOLATE लगाएँ।

यह वहाँ करें जहाँ आप interpolate करते हैं, अनुवाद में नहीं। हमारे टेस्ट में, नाम को U+2068 और U+2069 में लपेटकर welcome message format करने पर दोनों अक्षर आउटपुट में बने रहे और अरबी अछूती रही। पेज या container पर `dir="rtl"` और `lang="ar"` भी सेट करें। [अरबी प्रॉम्प्ट इंजीनियरिंग](https://broadrouter.com/hi/blog/arabic-prompt-engineering/) में RTL display bugs की एक छोटी चेकलिस्ट है।

अंक formatter का फ़ैसला हैं, अनुवाद का नहीं। string में `#` या argument रखें। Node 24 (ICU 78.3) में `Intl.NumberFormat` ने 1234 को `ar` के लिए 1,234 और `ar-EG` और `ar-SA` के लिए ١٬٢٣٤ लिखा। अपने बाज़ार से मेल खाता locale tag चुनें। प्रोडक्ट के बड़े सवालों (इंटरफ़ेस locale बनाम मॉडल की भाषा, मिली-जुली दिशाओं वाले chat bubbles, भाषा पहचान और हर भाषा की लागत) के लिए देखें [कई भाषाओं के लिए AI अनुभव डिज़ाइन करना](https://broadrouter.com/hi/blog/multilingual-product-design/)।

## आउटपुट की समीक्षा कौन करे?

इन जाँचों वाली LLM पाइपलाइन यह गारंटी देती है कि फ़ाइल सही बनी है। यह गारंटी नहीं देती कि अरबी सही है। किसी अरबी भाषी से इनकी समीक्षा करवाएँ:

-   **सिर्फ़ नई और बदली strings।** `en.json` का पिछली release से diff निकालें और सिर्फ़ बदला हुआ अनुवाद करें। समीक्षाएँ छोटी रहती हैं, और मंज़ूर strings कभी नहीं बदलतीं।
-   **Plural रूप, शब्द-दर-शब्द।** संख्याओं के साथ मेल ही वह जगह है जहाँ मॉडल सबसे ज़्यादा फिसलता है, ख़ासकर 11 से 99 के बाद accusative।
-   **लिंग।** अरबी में “आप” और क्रियाएँ पढ़ने वाले के लिंग के साथ बदलती हैं। अगर आपका UI यूज़र को सीधे संबोधित करता है, तो एक नियम तय करें, जैसे एक तय रूप या तटस्थ वाक्य-रचना, और उसे system prompt में डालें।
-   **लंबाई।** अरबी strings अंग्रेज़ी से लंबी या छोटी हो सकती हैं। बटन और tabs असली layout में mobile चौड़ाई पर जाँचें।

Repo में समीक्षा की हुई शब्दावली फ़ाइल रखें और हर अनुरोध के साथ भेजें, ताकि मंज़ूर शब्द तय रहें।

## लागत कितनी है?

String फ़ाइलें छोटी होती हैं। आउटपुट लगभग इनपुट जितना लंबा होता है, और अरबी को आमतौर पर अंग्रेज़ी से प्रति शब्द ज़्यादा टोकन चाहिए; [अरबी और अंग्रेज़ी में प्रति शब्द टोकन](https://broadrouter.com/hi/blog/tokens-per-word-arabic-english/) में मापे गए अनुपात हैं। एक batch [अरबी टोकन काउंटर](https://broadrouter.com/tools/arabic-token-counter/) में पेस्ट करें, batches की संख्या से गुणा करें, और हर एक में system prompt जोड़ें। Reasoning मॉडल सोचने में भी टोकन ख़र्च करते हैं; BroadNet उन्हें `usage` में `completion_tokens_details.reasoning_tokens` के रूप में बताता है, इसलिए अनुमान बढ़ाने से पहले किसी असली अनुरोध का `usage` पढ़ें।

| मॉडल | इस काम के लिए नोट्स | प्रति 1M टोकन इनपुट / आउटपुट |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) | Structured output documented | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) | Structured output documented; 1,048,576 टोकन का कॉन्टेक्स्ट | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/) | $5 के शुरुआती क्रेडिट पर चलता है; JSON सिर्फ़ प्रॉम्प्ट से, इसलिए validator ज़्यादा मायने रखता है | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) | फ़्लैट प्लान पर भी, जैसे $15 प्रति हफ़्ता प्रति सेशन, हर सेशन में एक समय में एक अनुरोध | $0.175 / $0.52 |

कीमतें BroadNet के pricing feed से हैं, 2026-11-14 को अपडेट। एक मॉडल चुनने से पहले वही 100 strings दो मॉडलों से अनुवाद करवाएँ और अपने समीक्षक से तुलना करवाएँ; प्रति टोकन कीमत सुधारों की संख्या से कम मायने रखती है। कई भाषाओं में हज़ारों keys के लिए, [Batch API के बिना batch processing](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/) concurrency और retries समझाती है।

## BroadNet Inference कहाँ फ़िट होता है

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference ऊपर के मॉडलों तक OpenAI-compatible पहुँच देता है, इसलिए base URL और मॉडल ID बदलने के बाद script [OpenAI Python SDK](https://broadrouter.com/hi/guides/openai-python-sdk/) के साथ चलती है; हर मॉडल किन parameters को सपोर्ट करता है, इसके लिए [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-translate-app-strings-to-arabic-llm&utm_content=body) देखें। इसके पास अनुवाद endpoint नहीं है और यह कोई localization benchmark प्रकाशित नहीं करता, इसलिए validator और इंसानी समीक्षक ही आपकी क्वालिटी की कसौटी रहते हैं। समर्पित localization प्लेटफ़ॉर्म translation memory, समीक्षक workflows और संदर्भ वाले screenshots जोड़ते हैं; अगर वे चाहिए, तो कोई प्लेटफ़ॉर्म इस्तेमाल करें और ऊपर वाली CI जाँच को दूसरी पंक्ति के रूप में रखें।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

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

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[सिस्टम प्रॉम्प्ट (system prompt)](https://broadrouter.com/hi/glossary/system-prompt/)

सिस्टम प्रॉम्प्ट वह निर्देश टेक्स्ट है जो कोई ऐप्लिकेशन बातचीत से पहले लैंग्वेज मॉडल को भेजता है, आम तौर पर system या developer रोल वाले मैसेज के रूप में। यह मॉडल की भूमिका, नियम, लहजा और आउटपुट फ़ॉर्मैट तय करता है, और टकराव होने पर मॉडल को यूज़र के मैसेज के बजाय इसी का पालन करना होता है।

[स्ट्रक्चर्ड आउटपुट (structured output)](https://broadrouter.com/hi/glossary/structured-output/)

स्ट्रक्चर्ड आउटपुट LLM API का एक फ़ीचर है जो मॉडल के जवाब को डेवलपर के तय फ़ॉर्मैट, आम तौर पर JSON Schema, तक सीमित करता है, ताकि कोड उसे भरोसे से पार्स कर सके। यह JSON mode से सख़्त है, जो मान्य JSON की गारंटी देता है, लेकिन किसी ख़ास ढाँचे की नहीं।

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

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

base URL किसी API का तय मूल पता है, जैसे https://api.example.com/v1, जिसे क्लाइंट /chat/completions जैसे हर एंडपॉइंट पाथ के आगे जोड़ता है। OpenAI-compatible SDK में base URL को API key और मॉडल ID के साथ बदलने से वही कोड किसी दूसरे प्रोवाइडर से जुड़ जाता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[प्रॉम्प्ट इंजीनियरिंग (prompt engineering)](https://broadrouter.com/hi/glossary/prompt-engineering/)

प्रॉम्प्ट इंजीनियरिंग, लैंग्वेज मॉडल को दिए जाने वाले निर्देशों को लिखने, ढाँचा देने और टेस्ट करने की प्रक्रिया है, ताकि मॉडल लगातार आपकी ज़रूरतों के मुताबिक़ आउटपुट दे। इसमें रोल मैसेज, साफ़ निर्देश, उदाहरण, फ़ॉर्मैटिंग और टेस्ट केस पर नतीजों को मापना शामिल है।

[राइट-टू-लेफ़्ट टेक्स्ट (right-to-left, RTL text)](https://broadrouter.com/hi/glossary/rtl-text/)

राइट-टू-लेफ़्ट (RTL) टेक्स्ट वह लिखावट है, जैसे अरबी या हिब्रू, जो दाएँ से बाएँ दिखाई जाती है। कंप्यूटर इसे लॉजिकल पढ़ने के क्रम में सेव करते हैं, और जब RTL टेक्स्ट लेफ़्ट-टू-राइट टेक्स्ट, अंकों, मॉडल नामों या कोड के साथ मिलता है, तब Unicode Bidirectional Algorithm दिखने का क्रम तय करता है।

## अक्सर पूछे जाने वाले सवाल

### अरबी में कितने plural रूप होते हैं?

Unicode CLDR में छह cardinal categories: zero (0), one (1), two (2), few (03 से 10 पर ख़त्म होने वाली संख्याएँ, जैसे 3 से 10 और 103), many (11 से 99 पर ख़त्म होने वाली) और other (100 से 102, 1000, और 0.5 जैसे दशमलव)। अंग्रेज़ी फ़ाइल में सिर्फ़ one और other होते हैं।

### क्या ChatGPT या कोई दूसरा LLM मेरी i18n JSON फ़ाइल का अरबी अनुवाद कर सकता है?

हाँ, अगर फ़ॉर्मैट आपके नियंत्रण में है। सिर्फ़ values भेजें, placeholders को markers से बदलें, छह plural रूप माँगें, और नतीजा कोड में जाँचें: keys, arguments, tags और plural categories। रिलीज़ से पहले नई strings की समीक्षा किसी अरबी भाषी से करवाएँ।

### अगर अरबी अनुवाद में कोई plural रूप छूट जाए तो क्या होता है?

आमतौर पर कुछ भी दिखने वाले ढंग से फ़ेल नहीं होता। i18next और intl-messageformat other रूप पर लौट जाते हैं, इसलिए 2 फ़ाइलें dual ملفان की जगह "2 ملف" दिखती हैं। सिर्फ़ छहों रूप माँगने वाला validator इसे यूज़र से पहले पकड़ता है।

### क्या LLM को ख़ुद ICU MessageFormat syntax लिखना चाहिए?

बेहतर है नहीं। हर plural message के लिए छह सादी strings माँगें और ICU syntax कोड में जोड़ें। मॉडल कभी-कभी कोई brace छोड़ देते हैं या argument के नाम का अनुवाद कर देते हैं, और तब parser error runtime पर पूरा bundle तोड़ देता है।

### अरबी UI strings में कौन-से अंक इस्तेमाल हों?

यह अनुवाद नहीं, number formatter तय करे। string में # या argument रखें। हमारे Node 24 टेस्ट में Intl.NumberFormat ने 1234 को ar के लिए 1,234 और ar-EG और ar-SA के लिए ١٬٢٣٤ लिखा, यानी locale tag अंक तय करता है।

## आगे पढ़ें

-   [LLM से अरबी–अंग्रेज़ी अनुवाद: प्रॉम्प्ट, शब्दावली, मूल्यांकन](https://broadrouter.com/hi/blog/arabic-english-translation-llm/)
-   [अरबी प्रॉम्प्ट इंजीनियरिंग: register, RTL, अंक और मिला-जुला टेक्स्ट](https://broadrouter.com/hi/blog/arabic-prompt-engineering/)
-   [JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/blog/structured-output-json-schema/)
-   [LLM का अमान्य JSON कैसे ठीक करें: कारण, रिपेयर, रीट्राई](https://broadrouter.com/hi/blog/fix-invalid-json-from-llm/)
-   [अरबी बनाम अंग्रेज़ी में प्रति शब्द टोकन: अरबी महँगी क्यों पड़ती है](https://broadrouter.com/hi/blog/tokens-per-word-arabic-english/)
-   [Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/)
-   [कई भाषाओं के लिए AI प्रोडक्ट कैसे डिज़ाइन करें](https://broadrouter.com/hi/blog/multilingual-product-design/)
-   [LLM से अरबी टेक्स्ट में हरकतें (तश्कील) लगाना: प्रॉम्प्ट, जाँच, DER](https://broadrouter.com/hi/blog/arabic-diacritization-llm/)
-   [LLM से अरबी व्याकरण और वर्तनी सुधार: एक how-to](https://broadrouter.com/hi/blog/arabic-grammar-spelling-correction-llm/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**स्रोत**

-   [Unicode CLDR, Language Plural Rules चार्ट: अरबी की cardinal categories zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (2026-11-15 को जाँचा गया)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): अरबी में cardinal संख्याओं के 6 रूप (2026-11-15 को जाँचा गया)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, Message syntax: plural categories, सटीक =value मिलान, # चिह्न, other ज़रूरी है, apostrophe escaping (2026-11-15 को जाँचा गया)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [i18next डॉक्यूमेंटेशन, Plurals: \_zero, \_one, \_two, \_few, \_many, \_other suffixes, अरबी उदाहरण, Intl.PluralRules, count variable (2026-11-15 को जाँचा गया)](https://www.i18next.com/translation-function/plurals)
-   [i18next डॉक्यूमेंटेशन, JSON फ़ॉर्मैट: v4 plural keys और interpolation (2026-11-15 को जाँचा गया)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, HTML में inline markup और bidirectional टेक्स्ट: dir, bdi, FSI U+2068 और PDI U+2069 (2026-11-15 को जाँचा गया)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [BroadNet Inference API रेफ़रंस: मॉडल IDs, GLM 5.3 और Qwen3.8 27B के लिए structured output, reasoning max\_tokens में गिनी जाती है (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
