---
title: "i18n-JSON per LLM ins Arabische übersetzen: Plurale | BroadRouter"
description: "i18n-JSON-Dateien per LLM-API ins Arabische übersetzen: Platzhalter einfrieren, alle sechs arabischen Pluralformen erzeugen, ICU in CI prüfen, Namen isolieren."
url: https://broadrouter.com/de/blog/translate-app-strings-to-arabic-llm/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/) (aktualisiert am 2026-11-15).

# App-Strings per LLM ins Arabische übersetzen: Platzhalter und Plurale

Vom Team von BroadNet Inference · 7 Min. Lesezeit · Veröffentlicht 2026-11-15

Senden Sie die Strings als JSON, ersetzen Sie jeden Platzhalter durch einen Marker, fordern Sie alle sechs arabischen Pluralformen an (zero, one, two, few, many, other) und bauen Sie den ICU-Plural im Code, nicht im Modell. Prüfen Sie in CI: gleiche Schlüssel, gleiche Argumente und Tags, alle sechs Formen vorhanden. Umschließen Sie eingefügte Namen mit Unicode-Isolates, damit rechtsläufiger Text korrekt angezeigt wird.

## Das Wichtigste in Kürze

-   Arabisch hat in CLDR sechs Kardinal-Pluralkategorien. Englische Quelldateien haben zwei, das Modell muss also vier Formen schreiben, die in der Quelle nicht vorkommen.
-   Eine fehlende arabische Form scheitert lautlos. In unserem Test rendete eine ICU-Nachricht mit nur one und other für 2 Dateien „2 ملف“ statt des Duals ملفان, ohne Fehlermeldung.
-   Ersetzen Sie Platzhalter und Tags vor der Anfrage durch Marker wie ⟦0⟧ und stellen Sie sie danach wieder her. Was das Modell nicht sieht, kann es nicht übersetzen.
-   Lassen Sie den Code die ICU-Pluralsyntax aus sechs einfachen Strings zusammensetzen. Parsen Sie dann jede Nachricht in CI mit dem FormatJS-Parser und lassen Sie den Build bei jeder Lücke fehlschlagen.
-   Interpolierte Namen und lateinische Produktnamen in arabischem Text brauchen Bidi-Isolation: bdi oder dir="auto" in HTML, U+2068 und U+2069 in reinem Text.

**Auf dieser Seite**

1.  Warum zerbrechen arabische Plurale maschinell übersetzte String-Dateien?
2.  Wie sollten Sie Strings an das Modell senden?
3.  Das Übersetzungsskript
4.  Wie prüfen Sie die arabische Datei in CI?
5.  Was ist mit der Anzeige von rechts nach links?
6.  Wer sollte die Ausgabe prüfen?
7.  Was kostet das?
8.  Wo BroadNet Inference ins Bild passt

Die String-Dateien einer App zu übersetzen ist eine andere Aufgabe als Fließtext zu übersetzen. Jeder Wert ist kurz, hat oft keinen Kontext und enthält Syntax, die das Modell nicht anrühren darf: Platzhalter, HTML-Tags und Pluralregeln. Arabisch macht Letzteres schwer. Englische Dateien enthalten zwei Pluralformen, Arabisch braucht sechs. Dieser Beitrag baut eine kleine Pipeline auf einem OpenAI-kompatiblen LLM: Platzhalter einfrieren, sechs einfache Plural-Strings anfordern, die ICU-Syntax im Code zusammensetzen und dann alles in CI prüfen.

Für die Übersetzung von Dokumenten, Tickets und Verträgen siehe [Übersetzung Arabisch–Englisch mit LLMs](https://broadrouter.com/de/blog/arabic-english-translation-llm/); dort geht es um Tonfall, Glossare und Bewertung bei Fließtext.

## Warum zerbrechen arabische Plurale maschinell übersetzte String-Dateien?

Unicode CLDR, dem `Intl.PluralRules`, ICU und i18next alle folgen, gibt Arabisch sechs Kardinalkategorien:

| Kategorie | CLDR-Regel | Beispielzahlen | Beispiel: „Datei“ |
| --- | --- | --- | --- |
| 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, Akkusativ) |
| other | alles andere | 100–102, 1000, 0.5 | 100 ملف (Singular) |

Zwei Details bringen Leute ins Stolpern. Erstens sind die Kategorien nicht die Zahlen: 103 ist few und 111 ist many. Zweitens gibt eine englische Quelle dem Modell nur `one` und `other`, es muss also vier Formen allein aus der Grammatik erfinden. Die meisten Fehler entstehen, weil das Modell das englische Paar kopiert.

Der Fehler ist lautlos. Wir haben eine arabische Nachricht mit nur `one` und `other` mit intl-messageformat 12.1.5 gerendert: 0, 2 und 11 Dateien kamen alle als „N ملف“ heraus. i18next 27.1.2 verhielt sich genauso, als der Schlüssel `_many` fehlte: 11 Dateien zeigten den Text von `_other`. Kein Fehler, keine Warnung, nur falsches Arabisch.

## Wie sollten Sie Strings an das Modell senden?

Bündeln Sie sie. Eine Anfrage pro String verschwendet Tokens für den System-Prompt und verliert den Kontext zwischen zusammengehörigen Strings. Senden Sie 50 bis 200 Schlüssel auf einmal als JSON-Objekt, gruppiert nach Bildschirm oder Funktion, damit „Save“ neben „Cancel“ als Button gelesen wird.

Drei Regeln machen die Antwort prüfbar:

1.  **Platzhalter einfrieren.** Ersetzen Sie `{name}`, i18next-Platzhalter mit doppelten Klammern, `%s`, `%1$s` und Tags wie `<b>` durch Marker wie ⟦0⟧. Das Modell sieht „Welcome back, ⟦0⟧!“ und kann `name` nicht in اسم übersetzen.
2.  **Pluralformen als einfache Strings anfordern.** Senden Sie die englischen Texte für `one` und `other` und fordern Sie sechs arabische Strings an. Der Code baut die ICU-Syntax. Das Modell schreibt nie eine Klammer.
3.  **Ein Glossar und eine Liste nicht zu übersetzender Begriffe mitgeben.** Produktnamen, Plannamen und Begriffe, die Ihr Support verwendet. Der [Glossar-Abschnitt des Übersetzungsbeitrags](https://broadrouter.com/de/blog/arabic-english-translation-llm/) erklärt, warum das mehr zählt als die Modellwahl.

## Das Übersetzungsskript

Die Quelldatei verwendet ICU MessageFormat, die Syntax, die FormatJS dokumentiert. Dasselbe Einfrieren funktioniert für das eigene JSON-Format von i18next, dessen Pluralschlüssel auf `_zero`, `_one`, `_two`, `_few`, `_many` und `_other` enden.

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

Wir haben es mit dem OpenAI Python SDK gegen einen lokalen Mock-Server ausgeführt, nicht gegen die Live-API, mit einer vorgefertigten arabischen Antwort. Die Anfrage, die das Modell sehen würde, enthielt „Welcome back, ⟦0⟧!“ und „⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace“, und das Skript schrieb diese `ar.json`:

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

Hinweise zum Code:

-   **Marker wandern, sie verschwinden nicht.** Im Arabischen steht das Verb oft vorn, ⟦0⟧ kann sich also verschieben. Die Prüfung unten zählt Marker; wo sie stehen, ist ihr egal.
-   **Verschachteltes ICU geht an einen Menschen.** Ein `select` innerhalb eines `plural` ist selten und leicht zu zerstören. Das Skript lehnt es ab, statt zu raten.
-   **`max_tokens=4000` lässt Raum für Reasoning.** Laut der Dokumentation von BroadNet denken DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B vor der Antwort nach, und das Reasoning zählt zu [max\_tokens](https://broadrouter.com/de/glossary/max-tokens/). Siehe [leere Antworten von Reasoning-Modellen](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).
-   **`json.loads` kann fehlschlagen.** Fangen Sie das ab und senden Sie einmal erneut mit dem Fehler; [ungültiges JSON aus einem LLM reparieren](https://broadrouter.com/de/blog/fix-invalid-json-from-llm/) enthält eine getestete Reparaturfunktion. Bei GLM 5.3 und Qwen3.8 27B, den beiden BroadNet-Modellen mit dokumentierter [strukturierter Ausgabe](https://broadrouter.com/de/glossary/structured-output/), ergänzen Sie zusätzlich ein Schema in `response_format`. Die Prüfung unten bleibt in jedem Fall.

## Wie prüfen Sie die arabische Datei in CI?

Parsen Sie jede Nachricht mit demselben Parser, den Ihre App zur Laufzeit nutzt, und vergleichen Sie sie mit der Quelle. Dieses Node-Skript verwendet `@formatjs/icu-messageformat-parser` (in unserem Test Version 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);
```

Für die Datei oben gab es `ok` aus. Dann ließen wir die Mock-Antwort die Form `many` und den Marker für `{workspace}` weglassen. Das Skript endete mit Code 1 und gab aus:

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

Die Regel „no Arabic letters“ markiert Strings, die das Modell auf Englisch gelassen hat. Sie markiert auch Werte, die nur aus einem Produktnamen oder einer Zahl bestehen; führen Sie für diese eine Allow-List. Für das eigene Format von i18next wenden Sie dieselben Prüfungen pro Schlüssel an: Jedes Paar `_one`/`_other` im Englischen braucht im Arabischen alle sechs Schlüssel mit Suffix, und jeder braucht dieselben Platzhalter, nur dass `_zero`, `_one` und `_two` den count weglassen dürfen.

Rendern Sie zum Schluss einige Zahlen mit Ihrem echten Formatierer. Mit intl-messageformat 12.1.5 ergab die Nachricht `files` oben 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف und 111 → 111 ملفًا. Diese Stichprobe fängt eine Form ab, die zwar parst, aber das falsche Nomen verwendet.

## Was ist mit der Anzeige von rechts nach links?

Die Übersetzung sorgt für die richtigen Wörter; ordnen muss sie trotzdem der Browser. Wird ein lateinischer Name oder eine Zahl in einen arabischen Satz eingefügt, kann der bidirektionale Unicode-Algorithmus Satzzeichen verschieben oder benachbarte Abschnitte vertauschen. Das W3C rät, eingefügten Text zu isolieren: in HTML mit `<bdi>` oder einem Element mit `dir="auto"` umschließen, in reinem Text wie Push-Benachrichtigungen mit U+2068 FIRST STRONG ISOLATE und U+2069 POP DIRECTIONAL ISOLATE einrahmen.

Tun Sie das beim Interpolieren, nicht in der Übersetzung. In unserem Test behielt die Begrüßungsnachricht, mit dem Namen in U+2068 und U+2069 eingeschlossen formatiert, beide Zeichen in der Ausgabe, und das Arabische blieb unberührt. Setzen Sie außerdem `dir="rtl"` und `lang="ar"` auf der Seite oder dem Container. [Prompt Engineering für Arabisch](https://broadrouter.com/de/blog/arabic-prompt-engineering/) enthält eine kurze Checkliste für RTL-Anzeigefehler.

Ziffern sind eine Entscheidung des Formatierers, nicht der Übersetzung. Behalten Sie `#` oder das Argument im String. In Node 24 (ICU 78.3) schrieb `Intl.NumberFormat` 1234 für `ar` als 1,234 und für `ar-EG` und `ar-SA` als ١٬٢٣٤. Wählen Sie das Locale-Tag, das zu Ihrem Markt passt. Für die übergreifenden Produktfragen (Oberflächensprache vs. Modellsprache, Chat-Blasen mit gemischter Laufrichtung, Spracherkennung und Kosten pro Sprache) siehe [ein KI-Erlebnis für mehrere Sprachen gestalten](https://broadrouter.com/de/blog/multilingual-product-design/).

## Wer sollte die Ausgabe prüfen?

Eine LLM-Pipeline mit diesen Prüfungen garantiert, dass die Datei wohlgeformt ist. Sie garantiert nicht, dass das Arabisch stimmt. Lassen Sie eine arabischsprachige Person prüfen:

-   **Nur neue und geänderte Strings.** Vergleichen Sie `en.json` mit dem letzten Release und übersetzen Sie nur, was sich geändert hat. Reviews bleiben klein, und freigegebene Strings bewegen sich nie.
-   **Pluralformen, Wort für Wort.** Bei der Kongruenz mit Zahlen rutscht das Modell am häufigsten aus, besonders beim Akkusativ nach 11 bis 99.
-   **Genus.** „Du/Sie“ und Verben ändern sich im Arabischen mit dem Geschlecht der lesenden Person. Spricht Ihre UI Nutzer direkt an, legen Sie eine Konvention fest, etwa eine feste Form oder eine neutrale Umformulierung, und schreiben Sie sie in den System-Prompt.
-   **Länge.** Arabische Strings können länger oder kürzer als englische ausfallen. Prüfen Sie Buttons und Tabs im echten Layout in Mobilbreite.

Führen Sie eine geprüfte Glossardatei im Repository und senden Sie sie mit jeder Anfrage, damit freigegebene Begriffe fest bleiben.

## Was kostet das?

String-Dateien sind klein. Die Ausgabe ist etwa so lang wie die Eingabe, und Arabisch braucht pro Wort meist mehr Tokens als Englisch; [Tokens pro Wort auf Arabisch und Englisch](https://broadrouter.com/de/blog/tokens-per-word-arabic-english/) enthält gemessene Verhältnisse. Fügen Sie einen Batch in den [Token-Zähler für Arabisch](https://broadrouter.com/tools/arabic-token-counter/) ein, multiplizieren Sie mit der Anzahl der Batches und rechnen Sie bei jedem den System-Prompt hinzu. Reasoning-Modelle verbrauchen außerdem Tokens fürs Nachdenken; BroadNet meldet sie in `usage` als `completion_tokens_details.reasoning_tokens`, lesen Sie `usage` also aus einer echten Anfrage aus, bevor Sie hochrechnen.

| Modell | Hinweise für diese Aufgabe | Input / Output pro 1 Mio. Tokens |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/) | Strukturierte Ausgabe dokumentiert | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) | Strukturierte Ausgabe dokumentiert; Kontext von 1.048.576 Tokens | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) | Läuft mit dem Startguthaben von $5; JSON nur per Prompt, der Validator zählt also mehr | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) | Auch mit Pauschalplänen, etwa $15 pro Woche und Session, jeweils eine Anfrage pro Session | $0.175 / $0.52 |

Die Preise stammen aus dem Preis-Feed von BroadNet, aktualisiert am 2026-11-14. Übersetzen Sie dieselben 100 Strings mit zwei Modellen und lassen Sie Ihre Prüferin oder Ihren Prüfer vergleichen, bevor Sie sich entscheiden; der Preis pro Token zählt weniger als die Anzahl der Korrekturen. Für Tausende Schlüssel in vielen Sprachen behandelt [Batch-Verarbeitung ohne Batch API](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/) Parallelität und Wiederholungen.

## Wo BroadNet Inference ins Bild passt

BroadRouter ist BroadNets eigene Website. BroadNet Inference bietet OpenAI-kompatiblen Zugriff auf die Modelle oben, das Skript läuft also mit dem [OpenAI Python SDK](https://broadrouter.com/de/guides/openai-python-sdk/), nachdem Sie Base-URL und Modell-ID geändert haben; welche Parameter jedes Modell unterstützt, steht in der [API-Referenz](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-translate-app-strings-to-arabic-llm&utm_content=body). Es hat keinen Übersetzungs-Endpoint und veröffentlicht keinen Lokalisierungs-Benchmark, Validator und menschliche Prüfung bleiben also Ihr Qualitäts-Gate. Spezialisierte Lokalisierungsplattformen bieten zusätzlich Translation Memory, Review-Workflows und Screenshots im Kontext; brauchen Sie das, nutzen Sie eine und behalten Sie die CI-Prüfung oben als zweite Verteidigungslinie.

Kostenlose Tools zum Thema (auf Englisch)

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

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

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

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

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

Eine Batch API ist ein asynchroner LLM-Endpoint, der viele Anfragen auf einmal annimmt, meist als Datei, sie innerhalb eines festgelegten Zeitfensters statt sofort verarbeitet und die Ergebnisse gesammelt zurückgibt. Anbieter wie OpenAI und Anthropic berechnen Batch-Anfragen mit Rabatt gegenüber ihren Standard-APIs.

[Prompt Engineering](https://broadrouter.com/de/glossary/prompt-engineering/)

Prompt Engineering ist das Schreiben, Strukturieren und Testen der Anweisungen an ein Sprachmodell, damit es zuverlässig Output liefert, der Ihre Anforderungen erfüllt. Dazu gehören Rollennachrichten, klare Anweisungen, Beispiele, Formatierung und das Messen der Ergebnisse an Testfällen.

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

Ein System-Prompt ist der Anweisungstext, den eine Anwendung einem Sprachmodell vor dem Gespräch sendet, meist als Nachricht mit der Rolle system oder developer. Er legt Rolle, Regeln, Ton und Ausgabeformat des Modells fest, und das Modell soll ihm auch bei widersprechenden Nutzernachrichten folgen.

[Strukturierte Ausgabe (Structured Output)](https://broadrouter.com/de/glossary/structured-output/)

Strukturierte Ausgabe (Structured Output) ist eine Funktion von LLM-APIs, die die Antwort eines Modells auf ein vom Entwickler vorgegebenes Format beschränkt, meist ein JSON Schema, damit Code sie zuverlässig parsen kann. Sie ist strenger als der JSON-Modus, der gültiges JSON garantiert, aber keine bestimmte Struktur.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Concurrency (Parallelität)](https://broadrouter.com/de/glossary/concurrency/)

Concurrency (Parallelität) ist die Zahl der Anfragen, die ein Client gleichzeitig offen hat. LLM-APIs begrenzen sie oft pro Schlüssel oder Plan, getrennt von den Anfragen pro Minute, weil jede offene Anfrage GPU-Kapazität belegt, bis ihre Antwort fertig ist.

[max\_tokens](https://broadrouter.com/de/glossary/max-tokens/)

max\_tokens ist ein Parameter von LLM-APIs, der festlegt, wie viele Tokens ein Modell in einer Antwort höchstens erzeugen darf. Erreicht die Generierung das Limit, bricht sie ab, und die Antwort wird als abgeschnitten markiert, zum Beispiel mit finish\_reason „length“.

## Häufige Fragen

### Wie viele Pluralformen hat Arabisch?

Sechs Kardinalkategorien in Unicode CLDR: zero (0), one (1), two (2), few (Zahlen, die auf 03 bis 10 enden, etwa 3 bis 10 und 103), many (Endung 11 bis 99) und other (100 bis 102, 1000 sowie Dezimalzahlen wie 0,5). Eine englische Datei hat nur one und other.

### Kann ChatGPT oder ein anderes LLM meine i18n-JSON-Datei ins Arabische übersetzen?

Ja, wenn Sie das Format kontrollieren. Senden Sie nur die Werte, ersetzen Sie Platzhalter durch Marker, fordern Sie sechs Pluralformen an und prüfen Sie das Ergebnis im Code: Schlüssel, Argumente, Tags und Pluralkategorien. Lassen Sie neue Strings vor dem Release von einer arabischsprachigen Person prüfen.

### Was passiert, wenn einer arabischen Übersetzung eine Pluralform fehlt?

Meist schlägt nichts sichtbar fehl. i18next und intl-messageformat greifen auf die Form other zurück, sodass 2 Dateien als „2 ملف“ statt des Duals ملفان erscheinen. Nur ein Validator, der alle sechs Formen verlangt, bemerkt das vor den Nutzern.

### Sollte das LLM die ICU-MessageFormat-Syntax selbst schreiben?

Besser nicht. Fordern Sie pro Pluralnachricht sechs einfache Strings an und setzen Sie die ICU-Syntax im Code zusammen. Modelle lassen gelegentlich eine Klammer weg oder übersetzen den Argumentnamen, und ein Parserfehler legt dann zur Laufzeit das ganze Bundle lahm.

### Welche Ziffern sollten arabische UI-Strings verwenden?

Das entscheidet der Zahlenformatierer, nicht die Übersetzung. Behalten Sie # oder das Argument im String. In unserem Test mit Node 24 formatierte Intl.NumberFormat 1234 für ar als 1,234 und für ar-EG und ar-SA als ١٬٢٣٤; das Locale-Tag bestimmt also die Ziffern.

## Weiterlesen

-   [Übersetzung Arabisch–Englisch mit LLMs: Prompts, Glossare, Bewertung](https://broadrouter.com/de/blog/arabic-english-translation-llm/)
-   [Prompt Engineering auf Arabisch: Register, RTL, Ziffern, Mischtext](https://broadrouter.com/de/blog/arabic-prompt-engineering/)
-   [JSON Mode vs. json\_schema: strukturierte Ausgabe, die hält](https://broadrouter.com/de/blog/structured-output-json-schema/)
-   [Ungültiges JSON vom LLM reparieren: Ursachen, Reparatur, Retry](https://broadrouter.com/de/blog/fix-invalid-json-from-llm/)
-   [Tokens pro Wort, Arabisch vs. Englisch: Warum Arabisch mehr kostet](https://broadrouter.com/de/blog/tokens-per-word-arabic-english/)
-   [LLM-Batch-Verarbeitung ohne Batch API: ein fortsetzbarer Runner](https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/)
-   [Mehrsprachige KI-Produkte gestalten: Arabisch, Englisch, Spanisch](https://broadrouter.com/de/blog/multilingual-product-design/)
-   [Arabischen Text per LLM vokalisieren: Prompt, Prüfung, DER](https://broadrouter.com/de/blog/arabic-diacritization-llm/)
-   [Arabische Grammatik- und Rechtschreibkorrektur per LLM: Anleitung](https://broadrouter.com/de/blog/arabic-grammar-spelling-correction-llm/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**Quellen**

-   [Unicode CLDR, Übersicht Language Plural Rules: arabische Kardinalkategorien zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (geprüft am 15.11.2026)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): Arabisch hat 6 Formen für Kardinalzahlen (geprüft am 15.11.2026)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, Message syntax: Pluralkategorien, exakte =value-Treffer, das Symbol #, other ist Pflicht, Escaping mit Apostroph (geprüft am 15.11.2026)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [i18next-Dokumentation, Plurals: Suffixe \_zero, \_one, \_two, \_few, \_many, \_other, arabisches Beispiel, Intl.PluralRules, Variable count (geprüft am 15.11.2026)](https://www.i18next.com/translation-function/plurals)
-   [i18next-Dokumentation, JSON-Format: Pluralschlüssel in v4 und Interpolation (geprüft am 15.11.2026)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, Inline markup and bidirectional text in HTML: dir, bdi, FSI U+2068 und PDI U+2069 (geprüft am 15.11.2026)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [API-Referenz von BroadNet Inference: Modell-IDs, strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B, Reasoning zählt zu max\_tokens (geprüft am 15.11.2026) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
