Django-Datenbankinhalt mit KI übersetzen

Wenn du mit Djangos eingebautem Internationalisierungs-Framework (i18n) gearbeitet hast, weißt du, dass es statische Strings gut verarbeitet. Text in gettext() zu wrappen oder das {% trans %} Template-Tag zu verwenden, extrahiert Strings in .po-Dateien, die Übersetzer ausfüllen. Das System ist kampferprobt und funktioniert hervorragend für Code und Templates.

Aber was ist mit den Inhalten in deiner Datenbank?

Produktnamen, Artikeltitel, Kategoriebeschreibungen, FAQ-Antworten, nutzergenerierte Inhalte. Nichts davon befindet sich in deinem Quellcode. Djangos makemessages-Befehl wird es nie finden, und .po-Dateien können dir hier nicht helfen. Wenn deine Anwendung dynamische Inhalte in mehreren Sprachen ausliefert, brauchst du eine andere Strategie.

So geht's: Verwende django-modeltranslation, um übersetzbare Felder zu deinen Models hinzuzufügen, und automatisiere dann die Übersetzung mit KI mithilfe von TranslateBot.

Django Datenbank-Übersetzungspakete

Mehrere Drittanbieter-Pakete lösen das Problem der Datenbankübersetzung, jedes mit einer anderen Architektur.

django-modeltranslation

Fügt sprachspezifische Spalten direkt zu deinen bestehenden Tabellen hinzu. Ein title-Feld wird zu title_en, title_de, title_fr und so weiter. Abfragen bleiben schnell, da alles in derselben Tabelle liegt. Die Admin-Oberfläche zeigt alle Sprachen nebeneinander an.

Vorteile: Keine JOINs, schnelle Abfragen, transparenter Zugriff über Feld-Deskriptoren, ausgereiftes Ökosystem
Nachteile: Schema-Änderungen für jede neue Sprache, breitere Tabellen

django-parler

Erstellt eine separate Übersetzungstabelle für jedes Model. Die Originaltabelle bleibt sauber, und Übersetzungen werden in einer verknüpften Tabelle über einen Fremdschlüssel gespeichert.

Vorteile: Sauberes Schema, einfach Sprachen ohne Migrationen hinzufügen
Nachteile: JOINs für übersetzte Inhalte erforderlich, etwas komplexere Abfragemuster

django-translations

Verwendet eine einzelne Übersetzungstabelle mit einem generischen Fremdschlüssel, der auf jedes Model zeigen kann. Alle Übersetzungen aller Models landen in einer Tabelle.

Vorteile: Minimale Schema-Änderungen, funktioniert mit jedem Model
Nachteile: Abfragen über generische Fremdschlüssel können langsam sein, weniger transparente API

Manuelles JSON-Feld

Du kannst Übersetzungen in einem JSONField speichern:

class Product(models.Model):
    name_translations = models.JSONField(default=dict)
    # {"en": "Running Shoes", "de": "Laufschuhe", "fr": "Chaussures de course"}

Vorteile: Keine zusätzlichen Abhängigkeiten, flexibel
Nachteile: Keine ORM-Integration, kein Admin-Support, alles manuell

Welches solltest du verwenden?

Für die meisten Projekte ist django-modeltranslation die beste Wahl. Es ist das ausgereifteste Paket, hat die beste Django-Admin-Integration und hält alle Daten in derselben Tabelle für schnelle Abfragen. Der Kompromiss (breitere Tabellen und eine Migration pro neuer Sprache) ist für die überwiegende Mehrheit der Anwendungen handhabbar. Der Rest dieses Leitfadens verwendet django-modeltranslation.

django-modeltranslation Schritt für Schritt einrichten

Schritt 1: Paket installieren

TranslateBot bündelt django-modeltranslation als optionale Abhängigkeit. Installiere beides auf einmal:

pip install translatebot-django[modeltranslation]

Oder wenn du uv verwendest:

uv add --dev translatebot-django[modeltranslation]

Schritt 2: Django-Einstellungen konfigurieren

Zwei Dinge sind in settings.py wichtig: die App-Reihenfolge und die Sprachliste.

# settings.py

INSTALLED_APPS = [
    'modeltranslation',          # Must be BEFORE django.contrib.admin
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Your apps
    'shop',
    'translatebot_django',
]

LANGUAGE_CODE = 'en'

LANGUAGES = [
    ('en', 'English'),
    ('de', 'German'),
    ('fr', 'French'),
    ('nl', 'Dutch'),
]

Die modeltranslation-App muss vor django.contrib.admin stehen, damit sie die Admin-Klassen patchen kann, um Übersetzungsfelder anzuzeigen.

Schritt 3: Models für die Übersetzung registrieren

Erstelle eine translation.py-Datei in jeder App, die übersetzbare Models hat. Für eine E-Commerce-Shop-App:

# shop/translation.py

from modeltranslation.translator import register, TranslationOptions
from .models import Product, Category


@register(Product)
class ProductTranslationOptions(TranslationOptions):
    fields = ('name', 'description', 'short_description')


@register(Category)
class CategoryTranslationOptions(TranslationOptions):
    fields = ('name', 'description')

Nimm nur Felder auf, die menschenlesbaren Text enthalten. Registriere keine Felder wie slug, price oder sku.

Schritt 4: Migrationen erstellen und ausführen

python manage.py makemigrations
python manage.py migrate

Danach hat deine shop_product-Tabelle neue Spalten:

Spalte	Typ
`name`	varchar(200)
`name_en`	varchar(200)
`name_de`	varchar(200)
`name_fr`	varchar(200)
`name_nl`	varchar(200)
`description`	text
`description_en`	text
`description_de`	text
`description_fr`	text
`description_nl`	text
`short_description`	text
`short_description_en`	text
`short_description_de`	text
`short_description_fr`	text
`short_description_nl`	text

Jede Sprache, die du in LANGUAGES definiert hast, bekommt eine eigene Spalte für jedes registrierte Feld.

Das Problem: Leere Übersetzungsfelder

Du hast jetzt das Schema, aber jede _de-, _fr- und _nl-Spalte ist leer. Wenn du 500 Produkte mit 3 übersetzbaren Feldern und 3 Zielsprachen hast, sind das 4.500 leere Felder, die darauf warten, gefüllt zu werden.

Diesen Inhalt manuell zu übersetzen ist unrealistisch. Selbst mit einem professionellen Übersetzungsdienst müsstest du die Daten exportieren, verschicken, auf die Lieferung warten und die Ergebnisse reimportieren. Für ein kleines Team oder einen Solo-Entwickler bedeutet das normalerweise, dass das Feature nie ausgeliefert wird.

Hier kommt TranslateBot ins Spiel.

Übersetzungen mit TranslateBot automatisieren

TranslateBots translate-Management-Befehl kann all diese leeren Felder mit KI füllen. Konfiguriere zuerst deinen API-Schlüssel:

# settings.py

TRANSLATEBOT_API_KEY = os.getenv("OPENAI_API_KEY")
TRANSLATEBOT_MODEL = "gpt-4o-mini"  # Fast and cost-effective

Dann übersetze alle registrierten Models in eine Zielsprache:

python manage.py translate --target-lang de --models

Dieser einzelne Befehl findet jedes bei django-modeltranslation registrierte Model, identifiziert Felder, die für die Zielsprache leer sind, und füllt sie mit KI-generierten Übersetzungen.

Bestimmte Models übersetzen

Wenn du nur Produkte und nicht Kategorien übersetzen willst:

python manage.py translate --target-lang de --models Product

Oder mehrere bestimmte Models:

python manage.py translate --target-lang de --models Product Category

Vorschau mit Dry Run

Schau dir immer eine Vorschau an, bevor du in die Datenbank schreibst:

python manage.py translate --target-lang de --models --dry-run

Das zeigt dir genau, was übersetzt wird, ohne Datensätze zu ändern.

Bestehende Inhalte neu übersetzen

Standardmäßig überspringt TranslateBot Felder, die bereits eine Übersetzung haben. Um bestehende Übersetzungen zu überschreiben (zum Beispiel nach der Verbesserung deines KI-Modells oder dem Hinzufügen von Kontext):

python manage.py translate --target-lang de --models --overwrite

Alle Sprachen auf einmal übersetzen

Wenn du --target-lang weglässt und LANGUAGES in deinen Einstellungen definiert hast, übersetzt TranslateBot in alle konfigurierten Sprachen:

python manage.py translate --models

Wie die Übersetzungs-Pipeline funktioniert

Das passiert, wenn du den Übersetzungsbefehl ausführst.

Erkennung. TranslateBot fragt die Registry von django-modeltranslation ab, um alle registrierten Models und ihre übersetzbaren Felder zu finden.
Quell-Erkennung. Für jeden Datensatz wird der Quellinhalt gelesen. Zuerst wird das Basisfeld geprüft (z.B. name), dann wird auf das erste gefüllte sprachspezifische Feld zurückgegriffen (z.B. name_en). Datensätze ohne Quellinhalt werden übersprungen.
Batchverarbeitung. Datensätze werden in Batches gruppiert und an den KI-Anbieter gesendet. Das hält API-Aufrufe effizient und vermeidet Rate-Limits.
Übersetzung. Jeder Batch wird mit dem konfigurierten KI-Modell übersetzt. Du kannst jeden von LiteLLM unterstützten LLM-Anbieter verwenden (OpenAI, Anthropic, Google, Azure und viele andere) oder DeepL.
Atomare Schreibvorgänge. Alle Datenbankupdates eines Übersetzungslaufs werden in eine einzelne Transaktion gepackt. Wenn etwas schiefgeht, wie ein API-Fehler oder eine Datenbank-Constraint-Verletzung, werden keine teilweisen Daten gespeichert. Alles oder nichts.

Vollständiges Workflow-Beispiel

Hier ist ein vollständiges Beispiel von der Model-Definition bis zum übersetzten Inhalt, unter Verwendung eines E-Commerce-Product-Models.

Model definieren

# shop/models.py

from django.db import models


class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()
    short_description = models.CharField(max_length=500, blank=True)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    sku = models.CharField(max_length=50, unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

Für die Übersetzung registrieren

# shop/translation.py

from modeltranslation.translator import register, TranslationOptions
from .models import Product


@register(Product)
class ProductTranslationOptions(TranslationOptions):
    fields = ('name', 'description', 'short_description')

Migrationen ausführen

python manage.py makemigrations shop
python manage.py migrate

Übersetzungskontext hinzufügen (Optional)

Erstelle eine TRANSLATING.md-Datei in deinem Projektstamm, um der KI Kontext über deine Produktdomäne zu geben:

# Translation Context

## About This Project
E-commerce store for outdoor sports equipment.

## Terminology
- "trail runners" refers to trail running shoes, not people
- Keep brand names (Nike, Salomon, Arc'teryx) untranslated
- "Gore-Tex" is a brand name, do not translate

## Tone
- Use informal "du" form in German
- Product descriptions should sound enthusiastic but not exaggerated

Übersetzen

# Preview first
python manage.py translate --target-lang de --models Product --dry-run

# Apply translations
python manage.py translate --target-lang de --models Product

Ausgabe:

Translating Product model fields to German (de)...
Found 142 products with untranslated fields
Translating batch 1/15...
Translating batch 2/15...
...
Translating batch 15/15...
Successfully translated 142 products

Im Admin überprüfen

Öffne den Django-Admin und gehe zu einem beliebigen Produkt. Du wirst die Übersetzungsfelder gefüllt sehen:

Name [de]: Ultraleichte Trail-Laufschuhe
Description [de]: Diese leichten Trail-Laufschuhe bieten hervorragenden Grip...
Short description [de]: Leicht, schnell und griffig auf jedem Untergrund.

Wiederhole für jede Zielsprache:

python manage.py translate --target-lang fr --models Product
python manage.py translate --target-lang nl --models Product

Oder übersetze alle Sprachen auf einmal:

python manage.py translate --models Product

Best Practices

Sichere deine Datenbank, bevor du Massenübersetzungen in der Produktion ausführst. TranslateBot verwendet atomare Transaktionen, sodass ein fehlgeschlagener Lauf keine teilweisen Daten hinterlässt. Aber ein Backup gibt dir die Möglichkeit, zurückzusetzen, falls die Übersetzungsqualität nicht deinen Erwartungen entspricht.

# PostgreSQL example
pg_dump mydb > backup_before_translation.sql

Verwende zuerst einen Dry Run. Führe immer --dry-run aus, bevor du Übersetzungen auf ein neues Model oder eine neue Sprache anwendest. Überprüfe die Ausgabe, um sicherzustellen, dass der Quellinhalt korrekt erkannt wird und die Übersetzungen vernünftig aussehen.

Übersetze für große Datenbanken jeweils ein Model. Das erleichtert die Überprüfung der Ergebnisse und das erneute Ausführen bestimmter Models bei Bedarf.

python manage.py translate --target-lang de --models Product
python manage.py translate --target-lang de --models Category
python manage.py translate --target-lang de --models Article

Füge Übersetzungskontext hinzu. Eine TRANSLATING.md-Datei mit domänenspezifischer Terminologie und Stilrichtlinien verbessert die Übersetzungsqualität erheblich. Das ist besonders wichtig für spezialisierte Bereiche wie Medizin, Recht oder technische Produkte.

Halte deine Quellsprache gefüllt. TranslateBot liest aus dem Basisfeld oder dem Quellsprachefeld. Stelle sicher, dass dein Dateneingabe-Workflow immer die Quellsprache ausfüllt. Leere Quellfelder bedeuten leere Übersetzungen.

Kombiniere mit PO-Datei-Übersetzung für vollständige Abdeckung. Übersetze sowohl deine Code-Strings als auch Datenbankinhalte:

# Static strings in code and templates
python manage.py makemessages -l de -l fr -l nl
python manage.py translate
python manage.py compilemessages

# Dynamic content in the database
python manage.py translate --models

So wird jeder String, den deine Nutzer sehen, ob aus einem Template oder der Datenbank, übersetzt.

Nächste Schritte

Lies die vollständige Befehlsreferenz für alle verfügbaren Optionen
Richte die CI-Integration ein, um automatisch nach fehlenden Übersetzungen zu suchen
Erkunde die unterstützten KI-Modelle, um die beste Balance zwischen Qualität und Kosten für dein Projekt zu finden