किसी ऐप की string फ़ाइलों का अनुवाद गद्य के अनुवाद से अलग काम है। हर value छोटी होती है, अक्सर बिना संदर्भ के, और उसमें ऐसा syntax होता है जिसे मॉडल को छूना नहीं चाहिए: placeholders, HTML tags और plural नियम। अरबी आख़िरी वाले को मुश्किल बनाती है। अंग्रेज़ी फ़ाइलों में दो plural रूप होते हैं; अरबी को छह चाहिए। यह पोस्ट OpenAI-compatible LLM पर एक छोटी पाइपलाइन बनाती है: placeholders फ़्रीज़ करें, छह सादी plural strings माँगें, ICU syntax कोड में जोड़ें, फिर CI में सब कुछ validate करें।
दस्तावेज़ों, टिकटों और कॉन्ट्रैक्ट के अनुवाद के लिए देखें 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” बटन की तरह पढ़ा जाए।
तीन नियम जवाब को जाँचने लायक़ बनाते हैं:
- Placeholders फ़्रीज़ करें।
{name}, i18next के double-brace placeholders,%s,%1$sऔर<b>जैसे tags को ⟦0⟧ जैसे markers से बदलें। मॉडल “Welcome back, ⟦0⟧!” देखता है औरnameका اسم में अनुवाद नहीं कर सकता। - Plural रूप सादी strings के रूप में माँगें। अंग्रेज़ी के
oneऔरotherटेक्स्ट भेजें और छह अरबी strings माँगें। ICU syntax कोड बनाता है। मॉडल कभी brace नहीं लिखता। - शब्दावली और अनुवाद-न-करें सूची दें। प्रोडक्ट नाम, प्लान नाम और आपकी सपोर्ट टीम के शब्द। अनुवाद वाली पोस्ट का शब्दावली हिस्सा बताता है कि यह मॉडल चुनने से ज़्यादा क्यों मायने रखता है।
अनुवाद script
Source फ़ाइल ICU MessageFormat इस्तेमाल करती है, वह syntax जिसे FormatJS document करता है। यही फ़्रीज़िंग i18next के अपने JSON फ़ॉर्मैट पर भी काम करती है, जिसकी plural keys _zero, _one, _two, _few, _many और _other पर ख़त्म होती हैं।
{
"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}}"
}
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 लिखा:
{
"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=4000reasoning के लिए जगह छोड़ता है। BroadNet के docs कहते हैं कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले reasoning करते हैं, और reasoning max_tokens में गिनी जाती है। देखें reasoning मॉडलों से ख़ाली जवाब।json.loadsफ़ेल हो सकता है। उसे wrap करें और error के साथ एक बार दोबारा भेजें; LLM से आए invalid JSON को ठीक करना में एक टेस्ट किया हुआ repair function है। GLM 5.3 और Qwen3.8 27B पर, जो structured output के साथ documented दो BroadNet मॉडल हैं, एकresponse_formatschema भी जोड़ें। नीचे की जाँच दोनों हालात में रहती है।
CI में अरबी फ़ाइल कैसे validate करें?
हर message को उसी parser से parse करें जो आपका ऐप runtime पर इस्तेमाल करता है, और source से मिलाएँ। यह Node script @formatjs/icu-messageformat-parser इस्तेमाल करती है (हमारे टेस्ट में वर्ज़न 3.5.23):
// 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 के साथ बाहर निकली और यह छापा:
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" भी सेट करें। अरबी प्रॉम्प्ट इंजीनियरिंग में 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 अनुभव डिज़ाइन करना।
आउटपुट की समीक्षा कौन करे?
इन जाँचों वाली LLM पाइपलाइन यह गारंटी देती है कि फ़ाइल सही बनी है। यह गारंटी नहीं देती कि अरबी सही है। किसी अरबी भाषी से इनकी समीक्षा करवाएँ:
- सिर्फ़ नई और बदली strings।
en.jsonका पिछली release से diff निकालें और सिर्फ़ बदला हुआ अनुवाद करें। समीक्षाएँ छोटी रहती हैं, और मंज़ूर strings कभी नहीं बदलतीं। - Plural रूप, शब्द-दर-शब्द। संख्याओं के साथ मेल ही वह जगह है जहाँ मॉडल सबसे ज़्यादा फिसलता है, ख़ासकर 11 से 99 के बाद accusative।
- लिंग। अरबी में “आप” और क्रियाएँ पढ़ने वाले के लिंग के साथ बदलती हैं। अगर आपका UI यूज़र को सीधे संबोधित करता है, तो एक नियम तय करें, जैसे एक तय रूप या तटस्थ वाक्य-रचना, और उसे system prompt में डालें।
- लंबाई। अरबी strings अंग्रेज़ी से लंबी या छोटी हो सकती हैं। बटन और tabs असली layout में mobile चौड़ाई पर जाँचें।
Repo में समीक्षा की हुई शब्दावली फ़ाइल रखें और हर अनुरोध के साथ भेजें, ताकि मंज़ूर शब्द तय रहें।
लागत कितनी है?
String फ़ाइलें छोटी होती हैं। आउटपुट लगभग इनपुट जितना लंबा होता है, और अरबी को आमतौर पर अंग्रेज़ी से प्रति शब्द ज़्यादा टोकन चाहिए; अरबी और अंग्रेज़ी में प्रति शब्द टोकन में मापे गए अनुपात हैं। एक batch अरबी टोकन काउंटर में पेस्ट करें, batches की संख्या से गुणा करें, और हर एक में system prompt जोड़ें। Reasoning मॉडल सोचने में भी टोकन ख़र्च करते हैं; BroadNet उन्हें usage में completion_tokens_details.reasoning_tokens के रूप में बताता है, इसलिए अनुमान बढ़ाने से पहले किसी असली अनुरोध का usage पढ़ें।
| मॉडल | इस काम के लिए नोट्स | प्रति 1M टोकन इनपुट / आउटपुट |
|---|---|---|
| Qwen3.8 27B | Structured output documented | $0.175 / $2.17 |
| GLM 5.3 | Structured output documented; 1,048,576 टोकन का कॉन्टेक्स्ट | $0.78 / $3.46 |
| Gemma 4 VL 26B | $5 के शुरुआती क्रेडिट पर चलता है; JSON सिर्फ़ प्रॉम्प्ट से, इसलिए validator ज़्यादा मायने रखता है | $0.10 / $0.22 |
| DeepSeek V4.1 Flash | फ़्लैट प्लान पर भी, जैसे $15 प्रति हफ़्ता प्रति सेशन, हर सेशन में एक समय में एक अनुरोध | $0.175 / $0.52 |
कीमतें BroadNet के pricing feed से हैं, 2026-11-14 को अपडेट। एक मॉडल चुनने से पहले वही 100 strings दो मॉडलों से अनुवाद करवाएँ और अपने समीक्षक से तुलना करवाएँ; प्रति टोकन कीमत सुधारों की संख्या से कम मायने रखती है। कई भाषाओं में हज़ारों keys के लिए, Batch API के बिना batch processing concurrency और retries समझाती है।
BroadNet Inference कहाँ फ़िट होता है
BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference ऊपर के मॉडलों तक OpenAI-compatible पहुँच देता है, इसलिए base URL और मॉडल ID बदलने के बाद script OpenAI Python SDK के साथ चलती है; हर मॉडल किन parameters को सपोर्ट करता है, इसके लिए API रेफ़रंस देखें। इसके पास अनुवाद endpoint नहीं है और यह कोई localization benchmark प्रकाशित नहीं करता, इसलिए validator और इंसानी समीक्षक ही आपकी क्वालिटी की कसौटी रहते हैं। समर्पित localization प्लेटफ़ॉर्म translation memory, समीक्षक workflows और संदर्भ वाले screenshots जोड़ते हैं; अगर वे चाहिए, तो कोई प्लेटफ़ॉर्म इस्तेमाल करें और ऊपर वाली CI जाँच को दूसरी पंक्ति के रूप में रखें।
