Traduire des documents en local : l'alternative à DeepL qui ne fuit pas

#Pourquoi ne pas envoyer vos documents à DeepL

DeepL et Google Translate sont excellents, mais leur modèle économique repose sur le cloud : votre texte transite par leurs serveurs et, selon l'offre, peut être conservé ou utilisé pour améliorer les modèles. Pour un email anodin, peu importe. Pour un contrat sous NDA, un brevet en cours de dépôt, un bilan comptable ou des données personnelles de salariés, c'est un risque juridique et concurrentiel concret.

La traduction IA locale change la donne : le modèle est téléchargé sur votre disque et s'exécute sur votre CPU ou GPU. Aucune requête réseau, aucun compte, aucune limite de volume. Vous pouvez traduire un dossier entier de documents confidentiels sans qu'un octet ne quitte votre poste — y compris hors-ligne, dans un avion ou sur un réseau isolé.

Confidentialité

Contrats, brevets, données médicales ou RH restent sur votre machine.

Coût nul à l'usage

Pas d'abonnement ni de facturation au caractère : traduisez 10 ou 10 000 pages au même prix.

Hors-ligne

Fonctionne sans connexion, utile sur poste isolé ou en déplacement.

Volume illimité

Aucun quota mensuel ni throttling comme sur les API cloud.

#Quels modèles locaux traduisent vraiment bien

Tous les LLM ne se valent pas en traduction. Un bon traducteur local doit avoir été entraîné sur un large corpus multilingue et gérer finement le français. En 2026, quelques familles se détachent nettement pour un usage auto-hébergé.

Qwen 3.5 9B

Excellent en multilingue, très bon en français, gère bien les nuances et le vocabulaire technique. ≈6,6 Go en Q4, 256k de contexte, licence Apache 2.0 : le meilleur compromis qualité/ressources en 2026. Montez à Qwen 3.8 27B (≈18 Go) si la qualité ne suffit pas.

Gemma 4 12B

Traductions fluides et naturelles, ponctuation française soignée. Multimodal, désormais sous licence Apache 2.0 (Gemma est passé en Apache 2.0 en 2026). ≈7,6 Go en Q4, à l'aise sur un GPU 12-16 Go ou un Mac à mémoire unifiée.

Qwen 3.5 4B

Le petit modèle multilingue par défaut en 2026 : ≈3,4 Go seulement, il tourne partout — même sur CPU — et traduit déjà remarquablement pour sa taille. Apache 2.0.

Mistral Small 24B

Excellent en français, rapide, ≈14 Go en Q4. Généraliste solide, un très bon choix pour traiter du volume sur un GPU 16 Go.

Qwen 3.6 35B-A3B

Qualité proche du cloud grâce à son architecture MoE, désormais accessible dès 32 Go (≈23 Go en Q4, RTX 4090 ou Mac à grosse mémoire unifiée). Réservé aux traductions exigeantes.

Les modèles spécialisés « traduction » type NLLB ou Opus-MT existent aussi et sont très légers, mais un LLM généraliste récent les dépasse souvent sur les textes longs et le respect du contexte (registre, terminologie métier, cohérence d'un document entier).

#Prérequis et installation

Le socle est classique : Ollama comme moteur d'inférence, un modèle multilingue, et Python pour les scripts de traitement de fichiers. Ollama écoute par défaut sur http://localhost:11434.

Ollama installé

Le daemon qui télécharge et exécute les modèles. Voir le guide d'installation si ce n'est pas déjà fait.

Un GPU confortable

Une RTX 3060 12 Go fait tourner sans peine un Qwen 3.5 9B en Q4 (~6,6 Go). Ça marche aussi sur CPU, mais plus lentement.

Python 3.10+

Pour manipuler DOCX, PDF et Markdown et appeler l'API Ollama.

# Récupérer un modèle multilingue adapté à la traduction
ollama pull qwen3.5:9b

# Vérifier qu'il répond
ollama run qwen3.5:9b "Traduis en anglais : Le contrat prend effet à sa signature."

# Dépendances Python pour les formats de documents
pip install ollama python-docx pypdf markdown-it-py

#Premier test de traduction

Avant d'automatiser, validez la qualité sur un extrait représentatif. La clé d'une bonne traduction locale tient dans le prompt système : il fixe le rôle, la langue cible et surtout la consigne de ne rien ajouter.

import ollama

MODELE = "qwen3.5:9b"

SYSTEME = (
    "Tu es un traducteur professionnel. Traduis le texte fourni de "
    "{source} vers {cible}. Conserve le sens, le registre et la "
    "terminologie technique. Ne commente pas, n'ajoute rien : "
    "renvoie uniquement la traduction."
)

def traduire(texte, source="français", cible="anglais"):
    reponse = ollama.chat(
        model=MODELE,
        messages=[
            {"role": "system", "content": SYSTEME.format(source=source, cible=cible)},
            {"role": "user", "content": texte},
        ],
        options={"temperature": 0.2},
    )
    return reponse["message"]["content"].strip()

if __name__ == "__main__":
    extrait = "Le présent contrat prend effet à la date de sa signature par les deux parties."
    print(traduire(extrait))

#Préserver la mise en forme (DOCX, PDF, Markdown)

Traduire du texte brut est facile ; garder la mise en forme d'un document réel l'est moins. La bonne approche n'est pas de balancer le fichier entier au modèle, mais de traduire chaque segment de texte à sa place, en laissant la structure intacte.

#Fichiers Word (DOCX)

python-docx expose chaque paragraphe et chaque cellule de tableau. On traduit le texte de chaque « run » en conservant le style, puis on réécrit le fichier. La mise en page, les titres et les tableaux sont préservés.

from docx import Document
from traduire import traduire

def traduire_docx(entree, sortie, cible="anglais"):
    doc = Document(entree)

    for para in doc.paragraphs:
        if para.text.strip():
            para.text = traduire(para.text, cible=cible)

    for table in doc.tables:
        for ligne in table.rows:
            for cellule in ligne.cells:
                if cellule.text.strip():
                    cellule.text = traduire(cellule.text, cible=cible)

    doc.save(sortie)
    print(f"Traduit : {sortie}")

if __name__ == "__main__":
    traduire_docx("contrat.docx", "contrat_en.docx")

#Markdown

Le Markdown est le format le plus simple à traduire proprement : il suffit d'indiquer au modèle de préserver la syntaxe. Les titres, listes, liens et blocs de code restent intacts si le prompt l'exige.

import ollama

SYSTEME_MD = (
    "Traduis ce document Markdown en {cible}. Conserve EXACTEMENT la "
    "syntaxe Markdown : titres (#), listes, liens, tableaux et blocs "
    "de code. Ne traduis PAS le contenu des blocs de code. Renvoie "
    "uniquement le Markdown traduit."
)

def traduire_markdown(chemin, sortie, cible="anglais"):
    texte = open(chemin, encoding="utf-8").read()
    reponse = ollama.chat(
        model="qwen3.5:9b",
        messages=[
            {"role": "system", "content": SYSTEME_MD.format(cible=cible)},
            {"role": "user", "content": texte},
        ],
        options={"temperature": 0.2},
    )
    open(sortie, "w", encoding="utf-8").write(reponse["message"]["content"])

traduire_markdown("README.md", "README_en.md")

#PDF

Le PDF est le cas le plus délicat : c'est un format de présentation, pas de contenu. On extrait le texte avec pypdf, on le traduit, puis on le réémet dans un nouveau document (souvent un DOCX ou un PDF généré). Reproduire la mise en page exacte d'un PDF est rarement rentable ; visez un document lisible plutôt qu'une copie pixel-perfect.

from pypdf import PdfReader
from docx import Document
from traduire import traduire

def pdf_vers_docx_traduit(entree, sortie, cible="anglais"):
    lecteur = PdfReader(entree)
    doc = Document()

    for page in lecteur.pages:
        texte = page.extract_text() or ""
        for paragraphe in texte.split("\n\n"):
            if paragraphe.strip():
                doc.add_paragraph(traduire(paragraphe, cible=cible))

    doc.save(sortie)

pdf_vers_docx_traduit("rapport.pdf", "rapport_en.docx")

#Traduction par lots avec Ollama

L'intérêt majeur du local, c'est le volume sans facture. Un script qui parcourt un dossier et traduit chaque fichier transforme votre poste en service de traduction par lots. Voici un script qui traite tous les .docx d'un répertoire.

import sys
from pathlib import Path
from traduire_docx import traduire_docx

def traduire_dossier(dossier, cible="anglais", suffixe="_traduit"):
    dossier = Path(dossier)
    fichiers = list(dossier.glob("*.docx"))
    print(f"{len(fichiers)} fichier(s) à traduire\n")

    for i, fichier in enumerate(fichiers, 1):
        if suffixe in fichier.stem:
            continue  # éviter de retraduire une sortie
        sortie = fichier.with_name(f"{fichier.stem}{suffixe}.docx")
        print(f"[{i}/{len(fichiers)}] {fichier.name}")
        traduire_docx(fichier, sortie, cible=cible)

    print("\nTerminé.")

if __name__ == "__main__":
    dossier = sys.argv[1] if len(sys.argv) > 1 else "."
    traduire_dossier(dossier)

# Traduire tous les .docx d'un dossier en anglais
python batch_traduction.py ./documents_a_traduire

#Améliorer la qualité des traductions

Un LLM local traduit bien par défaut, mais quelques réglages font passer le résultat de « correct » à « publiable », surtout sur des textes métier.

1. 01
   Fournir un glossaire

   Ajoutez au prompt système un lexique des termes métier et de leur traduction imposée (raison sociale, noms de produits, acronymes). Le modèle respectera votre terminologie plutôt que d'inventer.
2. 02
   Découper intelligemment

   Traduisez par paragraphe ou par section, pas phrase par phrase : le modèle a besoin de contexte pour bien gérer les accords, les reprises pronominales et le registre.
3. 03
   Donner le contexte du document

   Précisez la nature du texte (« contrat commercial », « notice technique », « email interne ») dans le prompt. Le registre et le vocabulaire s'ajustent en conséquence.
4. 04
   Relire les passages critiques

   Pour un contrat ou un document légal, une relecture humaine des clauses sensibles reste indispensable — le local vous donne la confidentialité, pas l'infaillibilité.
5. 05
   Monter en modèle si besoin

   Si la qualité plafonne, passez de Qwen 3.5 9B à Qwen 3.8 27B (pensez à régler son raisonnement sur « low » : par défaut il sur-réfléchit, inutile en traduction), voire à un MoE comme Qwen 3.6 35B-A3B. Le gain est net sur les phrases longues et la finesse terminologique.

#Dépannage

Le modèle ajoute des commentaires

Renforcez la consigne « renvoie UNIQUEMENT la traduction » et baissez la température. Certains modèles préfixent « Voici la traduction : » — retirez-le en post-traitement si besoin.

Il traduit dans la mauvaise langue

Nommez explicitement la langue cible dans le prompt et donnez un exemple. Sur un texte court, un modèle peut se tromper de langue.

La mise en forme DOCX saute

C'est le remplacement de para.text qui aplatit les runs. Traduisez run par run pour les documents fortement mis en forme.

Traduction lente sur gros volume

Vérifiez que le modèle tient en VRAM (sinon offload CPU = lenteur). Réduisez la taille du modèle ou utilisez OLLAMA_KEEP_ALIVE.

Blocs de code Markdown traduits

Insistez dans le prompt : « ne traduis pas le contenu des blocs de code ». Sinon, extrayez-les avant traduction et réinjectez-les après.

Contexte trop long tronqué

Un très gros document dépasse la fenêtre de contexte. Découpez-le en sections et traduisez chacune séparément.

#Pour aller plus loin

La traduction IA locale s'appuie sur un socle Ollama bien choisi. Ces guides du site complètent la mise en place :

Installer Ollama

Pour poser le moteur d'inférence si ce n'est pas déjà fait.

Q4, Q5, Q8 : quelle quantification choisir

Pour arbitrer entre qualité de traduction, vitesse et VRAM selon votre GPU.

n8n + Ollama : automatiser avec une IA locale

Pour brancher la traduction dans un workflow no-code (emails entrants, fichiers déposés, etc.).