Traduire son contenu automatiquement avec l'IA

import json

def detect_language(text, client):
    """Détecte la langue d''un texte via LLM"""
    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Détecte la langue de ce texte.
Réponds UNIQUEMENT avec un JSON: {{"lang": "code_iso", "confidence": 0.0-1.0}}

Texte: {text[:500]}"""
        }],
        temperature=0
    )
    return json.loads(response.choices[0].message.content)

# Exemple
result = detect_language("Bonjour, ceci est un test.")
# → {"lang": "fr", "confidence": 0.99}

import re

def prepare_content(markdown_text):
    """Protège les éléments à ne pas traduire"""
    protected = {}
    counter = 0

    # Protéger les blocs de code
    def protect_code(match):
        nonlocal counter
        key = f"__CODE_BLOCK_{counter}__"
        protected[key] = match.group(0)
        counter += 1
        return key

    text = re.sub(r''''''```[\s\S]*?```'''''', protect_code, markdown_text)

    # Protéger les URLs
    def protect_url(match):
        nonlocal counter
        key = f"__URL_{counter}__"
        protected[key] = match.group(0)
        counter += 1
        return key

    text = re.sub(r''''''https?://[^\s\)]+'''''', protect_url, text)

    # Protéger les liens internes /out?id=X
    text = re.sub(r''''''(/out\?id=\d+)'''''',
                  lambda m: protect_url(m), text)

    return text, protected

def restore_content(translated_text, protected):
    """Restaure les éléments protégés après traduction"""
    for key, value in protected.items():
        translated_text = translated_text.replace(key, value)
    return translated_text

def translate_content(text, source_lang, target_lang, client, context=""):
    """Traduit du contenu avec préservation du ton et du SEO"""

    system_prompt = f"""Tu es un traducteur professionnel spécialisé
dans le contenu tech/IA. Tu traduis de {source_lang} vers {target_lang}.

RÈGLES STRICTES :
1. Préserve EXACTEMENT le formatage markdown (titres, listes, gras, italique, tableaux)
2. Ne traduis PAS les éléments entre __CODE_BLOCK_X__ ou __URL_X__
3. Adapte les expressions idiomatiques naturellement
4. Préserve le ton : si c''est décontracté, reste décontracté
5. Les termes techniques anglais courants restent en anglais :
   API, LLM, token, prompt, pipeline, markdown, SEO, etc.
6. Optimise pour le SEO dans la langue cible :
   - Utilise des mots-clés naturels
   - Garde les phrases lisibles (pas de traduction mot-à-mot)
7. Ne JAMAIS ajouter ou supprimer de contenu
8. Les émojis restent identiques"""

    user_prompt = f"""Traduis ce contenu de {source_lang} vers {target_lang}.
{"Contexte: " + context if context else ""}

---
{text}
---

Traduction :"""

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0.3,
        max_tokens=8000
    )

    return response.choices[0].message.content

def review_translation(original, translated, source_lang, target_lang, client):
    """Review automatique de la qualité de traduction"""

    prompt = f"""Compare cette traduction et note-la.

ORIGINAL ({source_lang}):
{original[:3000]}

TRADUCTION ({target_lang}):
{translated[:3000]}

Évalue sur ces critères (note /10 chacun) :
1. Fidélité au sens original
2. Fluidité dans la langue cible
3. Préservation du formatage
4. Adaptation culturelle
5. Qualité SEO

Réponds en JSON :
{{
  "scores": {{"fidelite": X, "fluidite": X, "formatage": X, "culture": X, "seo": X}},
  "score_global": X,
  "problemes": ["liste des problèmes détectés"],
  "suggestions": ["améliorations suggérées"],
  "approved": true/false
}}

Approuve (true) si score_global >= 7.5"""

    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )

    return json.loads(response.choices[0].message.content)

def translation_pipeline(content, target_lang="en", client=None):
    """Pipeline complet de traduction automatique"""

    # 1. Détection langue
    lang_info = detect_language(content, client)
    source_lang = lang_info["lang"]
    print(f"📝 Langue détectée: {source_lang} ({lang_info[''confidence'']*100:.0f}%)")

    if source_lang == target_lang:
        print("⚠️ Même langue source et cible!")
        return content

    # 2. Préparation
    prepared, protected = prepare_content(content)
    print(f"🔒 {len(protected)} éléments protégés")

    # 3. Traduction
    print(f"🔄 Traduction {source_lang} → {target_lang}...")
    translated = translate_content(prepared, source_lang, target_lang, client)

    # 4. Restauration
    final = restore_content(translated, protected)

    # 5. Review qualité
    print("🔍 Review qualité...")
    review = review_translation(content, final, source_lang, target_lang, client)

    print(f"📊 Score global: {review[''score_global'']}/10")

    if not review["approved"]:
        print("⚠️ Traduction rejetée, nouvelle tentative...")
        # On peut relancer avec les suggestions
        context = "Corrections à appliquer: " + ", ".join(review["suggestions"])
        prepared, protected = prepare_content(content)
        translated = translate_content(prepared, source_lang, target_lang, client, context)
        final = restore_content(translated, protected)

    return final, review

"Tu vas voir, c''est super simple !"
→ ✅ "You''ll see, it''s super easy!"
→ ❌ "You will observe, it is remarkably simple."

"Cette implémentation nécessite une configuration préalable."
→ ✅ "This implementation requires prior configuration."
→ ❌ "You gotta set things up before using this."

Avant de traduire, identifie les 5 mots-clés SEO principaux
du texte source. Trouve leurs équivalents les plus recherchés
dans la langue cible (via ton knowledge). Utilise ces
équivalents naturellement dans la traduction.

# ❌ Erreurs fréquentes après traduction

Pour aller plus loin sur ce sujet, consultez notre guide [Générer du contenu automatiquement avec l'IA](/article/generer-contenu-automatiquement-ia).

## 🚀 Titre sans espace    → le LLM supprime l''espace après l''émoji
**texte en gras**mal fermé → le LLM oublie les **
[lien](url "titre")       → le LLM traduit l''URL
| tableau | cassé          → le LLM change l''alignement

# ✅ Solutions

1. Demander explicitement la préservation dans le system prompt
2. Valider le markdown après traduction avec un parser
3. Comparer la structure (nombre de #, **, [], |) avant/après

import re

def validate_markdown_structure(original, translated):
    """Vérifie que la structure markdown est préservée"""
    checks = {
        "headings": (r''^#{1,6}\s'', re.MULTILINE),
        "bold": (r''\*\*'', 0),
        "links": (r''\[.*?\]\(.*?\)'', 0),
        "code_blocks": (r''''''```'''''', 0),
        "tables": (r''\|'', 0),
        "lists": (r''^\s*[-*]\s'', re.MULTILINE),
    }

    issues = []
    for name, (pattern, flags) in checks.items():
        orig_count = len(re.findall(pattern, original, flags))
        trans_count = len(re.findall(pattern, translated, flags))
        if orig_count != trans_count:
            issues.append(f"{name}: {orig_count} → {trans_count}")

    return issues

# Via OpenRouter (compatible OpenAI)
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."  # Votre clé OpenRouter
)

response = client.chat.completions.create(
    model="google/gemini-2.0-flash-001",
    messages=[{
        "role": "user",
        "content": "Traduis en anglais en préservant le markdown:\n\n## 🚀 Mon titre\nVoici du **texte en gras** et un [lien](/out?id=1)."
    }]
)

print(response.choices[0].message.content)
# → ## 🚀 My title
# → Here is some **bold text** and a [link](/out?id=1).

# Installation avec Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.3:70b

# Test de traduction
ollama run llama3.3:70b "Translate to English, preserve markdown formatting:

## 🔧 Configuration
Voici comment **configurer** votre système.
1. Installez les dépendances
2. Lancez le serveur
"

# Exemple de configuration conceptuelle
pipeline_traduction:
  trigger: "nouveau_article_publié"
  steps:
    - detect_language
    - prepare_content
    - translate (model: gemini-flash)
    - review_quality (model: claude-sonnet)
    - validate_markdown
    - save_translation
  notify: telegram

## 🚀 Pourquoi automatiser sa vie numérique ?

On passe en moyenne **3h par jour** sur des tâches répétitives.
Envoyer des emails, poster sur les réseaux, vérifier ses stats...

Avec l''IA, tu peux **récupérer ce temps** et te concentrer
sur ce qui compte vraiment.

> "L''automatisation n''est pas de la paresse, c''est de l''intelligence."

### Les outils indispensables

| Outil | Usage | Prix |
|-------|-------|------|
| OpenClaw | Agent IA personnel | Gratuit |
| Zapier | Connexion d''apps | Freemium |

## 🚀 Why Automate Your Digital Life?

We spend an average of **3 hours a day** on repetitive tasks.
Sending emails, posting on social media, checking stats...

With AI, you can **reclaim that time** and focus
on what truly matters.

> "Automation isn''t laziness, it''s intelligence."

### Essential Tools

| Tool | Use Case | Price |
|------|----------|-------|
| OpenClaw | Personal AI agent | Free |
| Zapier | App integration | Freemium |

TARGET_LANGUAGES = {
    "en": "English",
    "es": "Spanish",
    "de": "German",
    "pt": "Portuguese",
    "it": "Italian",
}

async def translate_all(content, source_lang="fr"):
    """Traduit un article dans toutes les langues cibles"""
    import asyncio

    tasks = []
    for lang_code, lang_name in TARGET_LANGUAGES.items():
        if lang_code != source_lang:
            tasks.append(translate_single(content, source_lang, lang_code))

    results = await asyncio.gather(*tasks)
    return dict(zip(TARGET_LANGUAGES.keys(), results))