Traduzir documentos localmente: a alternativa a DeepL

#Por que não enviar seus documentos para o DeepL

DeepL e Google Translate são excelentes, mas seu modelo de negócios se baseia na nuvem: seu texto passa pelos servidores deles e, dependendo da oferta, pode ser armazenado ou usado para melhorar os modelos. Para um e-mail sem conteúdo sensível, pouco importa. Para um contrato sujeito a um NDA, uma patente em processo de depósito, um balanço contábil ou dados pessoais de funcionários, isso representa um risco jurídico e concorrencial concreto.

A tradução com IA local muda o jogo: o modelo é baixado no seu disco e executado na sua CPU ou GPU. Nenhuma requisição de rede, nenhuma conta, nenhum limite de volume. Você pode traduzir uma pasta inteira de documentos confidenciais sem que um único byte saia do seu computador — inclusive offline, em um avião ou em uma rede isolada.

Privacidade

Contratos, patentes, dados médicos ou de RH permanecem na sua máquina.

Sem custo de uso

Sem assinatura nem cobrança por caractere: traduza 10 ou 10.000 páginas pelo mesmo preço.

Offline

Funciona sem conexão, útil em computadores isolados ou em deslocamento.

VOLUME ILIMITADO

Nenhum limite mensal nem throttling como nas APIs de nuvem.

#Quais modelos locais traduzem realmente bem

Nem todos os LLMs têm o mesmo desempenho em tradução. Um bom tradutor local deve ter sido treinado em um amplo corpus multilíngue e lidar com precisão com o francês. Em 2026, algumas famílias se destacam claramente para uso auto-hospedado.

Qwen 3.5 9B

Excelente em múltiplos idiomas, muito bom em francês, trata bem as nuances e o vocabulário técnico. ≈6,6 GB em Q4, 256k de contexto, licença Apache 2.0: o melhor equilíbrio entre qualidade e recursos em 2026. Passe para o Qwen 3.8 27B (≈18 GB) se a qualidade não for suficiente.

Gemma 4 12B

Traduções fluidas e naturais, pontuação francesa bem cuidada. Multimodal, agora sob licença Apache 2.0 (Gemma passou para Apache 2.0 em 2026). ≈7,6 GB em Q4, roda com folga em uma GPU de 12–16 GB ou em um Mac com memória unificada.

Qwen 3.5 4B

O pequeno modelo multilíngue padrão em 2026: apenas ≈3,4 GB, roda em qualquer lugar — até na CPU — e já traduz de forma notável para seu tamanho. Apache 2.0.

Mistral Small 24B

Excelente em francês, rápido, ≈14 GB em Q4. Generalista sólido, uma ótima escolha para processar grandes volumes em uma GPU de 16 GB.

Qwen 3.6 35B-A3B

Qualidade próxima à dos modelos na nuvem graças à sua arquitetura MoE, agora acessível a partir de 32 GB (≈23 GB em Q4, RTX 4090 ou Mac com grande capacidade de memória unificada). Reservado para traduções exigentes.

Modelos especializados em tradução, como NLLB ou Opus-MT, também existem e são muito leves, mas um LLM generalista recente costuma superá-los em textos longos e na preservação do contexto (registro, terminologia profissional, coerência de um documento inteiro).

#Pré-requisitos e instalação

A base é clássica: Ollama como motor de inferência, um modelo multilíngue e Python para os scripts de processamento de arquivos. Ollama escuta por padrão em http://localhost:11434.

Ollama instalado

O daemon que baixa e executa os modelos. Consultar o guia de instalação caso a instalação ainda não tenha sido feita.

Uma GPU com desempenho suficiente para trabalhar com folga

Uma RTX 3060 de 12 GB roda sem problemas um Qwen 3.5 9B em Q4 (~6,6 GB). Funciona também no CPU, mas mais lentamente.

Python 3.10+

Para manipular DOCX, PDF e Markdown e chamar a API do 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

#Primeiro teste de tradução

Antes de automatizar, valide a qualidade em um trecho representativo. A chave de uma boa tradução local está no prompt de sistema: ele define o papel, a língua-alvo e, principalmente, a instrução de não adicionar nada.

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

#Preservar a formatação (DOCX, PDF, Markdown)

Traduzir texto bruto é fácil; manter a formatação de um documento real é mais difícil. A abordagem correta não é enviar todo o arquivo para o modelo, mas traduzir cada trecho de texto no local certo, mantendo a estrutura intacta.

#Arquivos Word (DOCX)

python-docx expõe cada parágrafo e cada célula de tabela. O texto de cada 'run' é traduzido mantendo o estilo, depois o arquivo é reescrito. O layout, os títulos e as tabelas são preservados.

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

O Markdown é o formato mais simples de traduzir corretamente: basta instruir o modelo a preservar a sintaxe. Títulos, listas, links e blocos de código permanecem intactos se o prompt exigir essa preservação.

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

O PDF é o caso mais delicado: é um formato de apresentação, não de conteúdo. O texto é extraído com pypdf, traduzido e depois inserido em um novo documento (geralmente um DOCX ou um PDF gerado). Reproduzir o layout exato de um PDF raramente compensa; busque um documento legível em vez de uma cópia idêntica pixel a pixel.

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

#Tradução por lotes com Ollama

O principal benefício da execução local é poder processar grandes volumes sem receber uma fatura. Um script que percorre uma pasta e traduz cada arquivo transforma seu computador em um serviço de tradução em lote. Aqui está um script que processa todos os arquivos .docx de um diretório.

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

#Melhorar a qualidade das traduções

Um LLM local traduz bem por padrão, mas alguns ajustes fazem o resultado passar de "correto" para "publicável", especialmente em textos profissionais.

1. 01
   Fornecer um glossário

   Adicione ao prompt de sistema um glossário de termos da sua área de atuação e suas traduções obrigatórias (razão social, nomes de produtos, acrônimos). O modelo respeitará sua terminologia em vez de inventar.
2. 02
   Dividir de forma inteligente

   Traduza por parágrafo ou por seção, não frase por frase: o modelo precisa de contexto para lidar bem com a concordância, as retomadas pronominais e o registro.
3. 03
   Fornecer o contexto do documento

   Especifique a natureza do texto (“contrato comercial”, “manual técnico”, “e-mail interno”) no prompt. O registro e o vocabulário se ajustam de acordo com isso.
4. 04
   Reler os trechos críticos

   Para contratos ou documentos legais, uma revisão humana das cláusulas sensíveis permanece indispensável — executar o modelo localmente oferece confidencialidade, mas não infalibilidade.
5. 05
   Passar para um modelo maior, se necessário

   Se a qualidade atingir o teto, mude de Qwen 3.5 9B para Qwen 3.8 27B (lembre-se de ajustar seu raciocínio para « low »: por padrão ele reflete demais, o que é inútil em traduções), ou até para um MoE como Qwen 3.6 35B-A3B. O ganho é significativo em frases longas e na precisão terminológica.

#Solução de problemas

O modelo adiciona comentários

Reforce a instrução "retorne SOMENTE a tradução" e reduza a temperatura. Alguns modelos acrescentam "Aqui está a tradução:" no início — remova esse prefixo no pós-processamento, se necessário.

Ele traduz para o idioma errado

Nomeie explicitamente a língua-alvo no prompt e dê um exemplo. Em um texto curto, um modelo pode errar a língua.

A formatação do DOCX se perde

É a substituição de para.text que elimina a formatação dos runs. Traduza run por run nos documentos com muita formatação.

Tradução lenta em grande volume

Verifique se o modelo cabe na VRAM (caso contrário, o offload para a CPU causa lentidão). Reduza o tamanho do modelo ou use OLLAMA_KEEP_ALIVE.

Blocos de código Markdown traduzidos

Insista no prompt: « não traduza o conteúdo dos blocos de código ». Caso contrário, extraia-os antes da tradução e reinjete-os depois.

Contexto muito longo truncado

Um documento muito grande ultrapassa a janela de contexto. Divida-o em seções e traduza cada uma separadamente.

#Para se aprofundar

A tradução com IA local se apoia em uma base Ollama bem escolhida. Estes guias do site complementam a configuração:

Instalar Ollama

Para instalar o motor de inferência, se ainda não foi feito.

Q4, Q5, Q8: qual quantização escolher

Para equilibrar qualidade da tradução, velocidade e VRAM de acordo com sua GPU.

n8n + Ollama: automatizar com uma IA local

Para integrar a tradução em um workflow sem código (e-mails recebidos, arquivos adicionados, etc.).