Traducir documentos localmente: la alternativa a DeepL

#¿Por qué no enviar tus documentos a DeepL?

DeepL y Google Translate son excelentes, pero su modelo de negocio se basa en la nube: tu texto pasa por sus servidores y, según la oferta, puede conservarse o utilizarse para mejorar los modelos. Para un correo inofensivo, no importa. Para un contrato sujeto a un NDA, una patente cuya solicitud está en proceso de presentación, un balance contable o datos personales de empleados, supone un riesgo jurídico y competitivo concreto.

La traducción con IA local cambia las reglas del juego: el modelo se descarga en tu disco y se ejecuta en tu CPU o GPU. Sin solicitudes de red, sin cuenta y sin límite de volumen. Puedes traducir una carpeta entera de documentos confidenciales sin que un solo byte salga de tu ordenador, incluso sin conexión, en un avión o en una red aislada.

Confidencialidad

Contratos, patentes, datos médicos o de RRHH permanecen en tu máquina.

Sin coste de uso

Sin suscripción ni facturación por carácter: traduce 10 o 10.000 páginas al mismo precio.

Hors-ligne

Funciona sin conexión, útil en un ordenador aislado o cuando estás de viaje.

Volumen ilimitado

No hay cuotas mensuales ni limitaciones de velocidad como en las API en la nube.

#¿Qué modelos locales traducen realmente bien?

No todos los LLM ofrecen la misma calidad de traducción. Un buen traductor local debe haberse entrenado con un amplio corpus multilingüe y manejar el francés con precisión. En 2026, algunas familias destacan claramente para un uso autoalojado.

Qwen 3.5 9B

Excelente en múltiples idiomas, muy bueno en francés, maneja bien los matices y el vocabulario técnico. ≈6,6 GB en Q4, 256k de contexto, licencia Apache 2.0: el mejor equilibrio calidad/recursos en 2026. Sube a Qwen 3.8 27B (≈18 GB) si la calidad no es suficiente.

Gemma 4 12B

Traducciones fluidas y naturales, puntuación francesa cuidadosa. Multimodal, ahora bajo licencia Apache 2.0 (Gemma pasó a Apache 2.0 en 2026). ≈7,6 GB en Q4, cómodo en un GPU de 12-16 GB o en un Mac con memoria unificada.

Qwen 3.5 4B

El pequeño modelo multilingüe predeterminado en 2026: solo ≈3,4 GB, funciona en cualquier equipo —incluso en CPU— y ya traduce sorprendentemente bien para su tamaño. Apache 2.0.

Mistral Small 24B

Excelente en francés, rápido, ≈14 GB en Q4. Un generalista sólido, una muy buena opción para procesar grandes volúmenes en una GPU de 16 GB.

Qwen 3.6 35B-A3B

Calidad similar a la de los modelos en la nube gracias a su arquitectura MoE, ahora accesible a partir de 32 GB (≈23 GB en Q4, RTX 4090 o Mac con mucha memoria unificada). Reservado para traducciones exigentes.

También existen modelos especializados en traducción, como NLLB u Opus-MT, que son muy ligeros, pero un LLM generalista reciente suele superarlos en textos largos y en el respeto al contexto (registro, terminología profesional, coherencia de un documento completo).

#Prerrequisitos e instalación

La base es clásica: Ollama como motor de inferencia, un modelo multilingüe, y Python para los scripts de procesamiento de archivos. Ollama escucha por defecto en http://localhost:11434.

Ollama instalado

El daemon que descarga y ejecuta los modelos. Consultar la guía de instalación si aún no está instalado.

Una GPU con potencia suficiente

Una RTX 3060 de 12 GB ejecuta sin problemas un Qwen 3.5 9B en Q4 (~6,6 GB). Funciona también en CPU, pero más lentamente.

Python 3.10+

Para manipular DOCX, PDF y Markdown y llamar a la 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

#Primer test de traducción

Antes de automatizar, verifica la calidad en un fragmento representativo. La clave de una buena traducción local está en el prompt de sistema: define el rol, el idioma de destino y, sobre todo, la instrucción de no añadir 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 el formato (DOCX, PDF, Markdown)

Traducir texto plano es fácil; conservar el formato de un documento real lo es menos. El enfoque correcto no es enviar todo el archivo al modelo, sino traducir cada segmento de texto en su lugar, manteniendo la estructura intacta.

#Archivos Word (DOCX)

python-docx expone cada párrafo y cada celda de tabla. Se traduce el texto de cada «run» conservando el estilo y luego se vuelve a escribir el archivo. Se conservan la disposición de la página, los títulos y las tablas.

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

Markdown es el formato más sencillo de traducir correctamente: basta con indicar al modelo que preserve la sintaxis. Los títulos, listas, enlaces y bloques de código permanecen intactos si el prompt lo 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

El PDF es el caso más delicado: es un formato de presentación, no de contenido. Se extrae el texto con pypdf, se traduce y luego se genera un nuevo documento con él (a menudo un DOCX o un PDF generado). Reproducir la maquetación exacta de un PDF rara vez es rentable; busca un documento legible en lugar de una copia idéntica píxel por píxel.

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

#Traducción por lotes con Ollama

La principal ventaja de trabajar en local es el volumen sin factura. Un script que recorre una carpeta y traduce cada archivo convierte tu equipo en un servicio de traducción por lotes. Aquí tienes un script que procesa todos los .docx de un directorio.

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

#Mejorar la calidad de las traducciones

Un LLM local traduce bien por defecto, pero algunos ajustes hacen que el resultado pase de «correcto» a «publicable», especialmente en textos profesionales.

1. 01
   Proporcionar un glosario

   Añade al prompt del sistema un glosario de términos de tu ámbito profesional y sus traducciones obligatorias (razón social, nombres de productos, acrónimos). El modelo respetará tu terminología en lugar de inventarla.
2. 02
   Dividir inteligentemente

   Traduce por párrafos o por secciones, no frase por frase: el modelo necesita contexto para gestionar bien la concordancia, las referencias pronominales y el registro.
3. 03
   Proporcionar el contexto del documento

   Especifica el tipo de texto («contrato comercial», «manual técnico», «email interno») en el prompt. El registro y el vocabulario se ajustan en consecuencia.
4. 04
   Releer los pasajes críticos

   Para un contrato o documento legal, una revisión humana de las cláusulas sensibles sigue siendo indispensable: ejecutar el modelo en local te da confidencialidad, no infalibilidad.
5. 05
   Pasar a un modelo más potente si es necesario

   Si la calidad se estanca, pasa de Qwen 3.5 9B a Qwen 3.8 27B (recuerda ajustar su razonamiento a «low»: por defecto razona en exceso, algo innecesario para la traducción), o incluso a un modelo MoE como Qwen 3.6 35B-A3B. La mejora es clara en las frases largas y en la precisión terminológica.

#Solución de problemas

El modelo añade comentarios

Refuerza la instrucción «devuelve ÚNICAMENTE la traducción» y baja la temperatura. Algunos modelos añaden al principio «Aquí está la traducción:»; elimina ese prefijo en el posprocesamiento si es necesario.

Traduce en el idioma incorrecto

Indica explícitamente el idioma de destino en el prompt y da un ejemplo. En un texto corto, un modelo puede equivocarse de idioma.

Se pierde el formato del DOCX

Es la sustitución de para.text la que aplana los runs. Traduce run a run los documentos con mucho formato.

Traducción lenta en grandes volúmenes

Verifica que el modelo quepa en la VRAM (de lo contrario, la descarga de parte del modelo a la CPU ralentiza la ejecución). Reduce el tamaño del modelo o utiliza OLLAMA_KEEP_ALIVE.

Bloques de código Markdown traducidos

Insiste en el prompt: «no traduzcas el contenido de los bloques de código». Como alternativa, extráelos antes de la traducción y vuelve a insertarlos después.

Contexto demasiado largo recortado

Un documento muy grande supera la ventana de contexto. Divídelo en secciones y traduce cada una por separado.

#Para ir más allá

La traducción con IA local se apoya en una base bien elegida con Ollama. Estas guías del sitio complementan la puesta en marcha:

Instalar Ollama

Para instalar el motor de inferencia si no se ha hecho ya.

Q4, Q5, Q8: ¿qué cuantización elegir?

Para encontrar el equilibrio entre calidad de traducción, velocidad y VRAM según tu GPU.

n8n + Ollama: automatizar con IA local

Para integrar la traducción en un flujo de trabajo sin código (correos entrantes, archivos subidos, etc.).