Build a quality-controlled translation workflow

Three-stage translation workflow with quality control

This implements translate → review → comprehension check pipeline. Adapt the glossary and tone rules to your organisation. Note: Uses JSON mode with gpt-4o-mini, which requires the prompt to explicitly include the word 'JSON' (each prompt says 'Return JSON with:').

from openai import OpenAI
import json

client = OpenAI()

# Your terminology glossary - maintain this
GLOSSARY = {
    "en-fr": {
        "support worker": "travailleur de soutien",
        "service user": "usager du service",
        "safeguarding": "protection"
    },
    "en-es": {
        "support worker": "trabajador de apoyo",
        "service user": "usuario del servicio",
        "safeguarding": "salvaguardia"
    }
}

# Your tone of voice rules
TONE_RULES = {
    "formality": "approachable but professional",
    "register": "use tu form in French/Spanish (we speak directly to our community)",
    "complexity": "plain language, aim for B1 level",
    "avoid": "jargon, complex sentences, passive voice"
}

def stage_1_translate(text, target_lang):
    """Stage 1: Initial translation with terminology control"""

    glossary_for_lang = GLOSSARY.get(f"en-{target_lang}", {})

    prompt = f"""Translate this to {target_lang.upper()}.

Mandatory terminology (always use these translations):
{json.dumps(glossary_for_lang, indent=2)}

Tone of voice rules:
- {TONE_RULES['formality']}
- {TONE_RULES['register']}
- Keep language simple and accessible ({TONE_RULES['complexity']})

Source text:
{text}

Return JSON with:
- translation: the translated text
- terminology_used: which glossary terms you used
- uncertain_terms: any terms you weren't sure about
- confidence: overall confidence (0-100)"""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

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

def stage_2_review(original, translation, target_lang):
    """Stage 2: Quality review by fresh AI instance"""

    glossary_for_lang = GLOSSARY.get(f"en-{target_lang}", {})

    prompt = f"""Review this {target_lang.upper()} translation for quality.

Original English:
{original}

Translation:
{translation}

Check against these criteria:
1. Mandatory terminology used correctly: {json.dumps(glossary_for_lang, indent=2)}
2. Tone is {TONE_RULES['formality']}
3. Uses {TONE_RULES['register']}
4. Language complexity matches original (both are {TONE_RULES['complexity']})
5. No cultural references that don't translate

Return JSON with:
- issues_found: list of any problems
- suggested_changes: specific improvements
- terminology_compliance: did it use the glossary correctly?
- tone_assessment: does it match our tone rules?
- overall_quality: score (0-100)"""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

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

def stage_3_comprehension_check(original, translation, target_lang):
    """Stage 3: Check meaning is preserved"""

    prompt = f"""Check if this translation preserves the original meaning.

Original English:
{original}

Translation ({target_lang.upper()}):
{translation}

Tasks:
1. Back-translate the {target_lang.upper()} to English
2. Compare to the original:
   - Are all key messages preserved?
   - Is the language level similar?
   - Is anything added or lost?

Return JSON with:
- back_translation: your English version of the translation
- meaning_preserved: yes/no
- key_differences: any important changes in meaning
- complexity_comparison: is the translation simpler/harder than original?
- recommendation: approve/revise/flag-for-review"""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

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

# Full workflow
def translate_with_quality_control(text, target_lang):
    """Run complete three-stage workflow"""

    print(f"\nTranslating to {target_lang}...")

    # Stage 1: Translate
    print("Stage 1: Translating...")
    stage1 = stage_1_translate(text, target_lang)
    translation = stage1['translation']

    # Stage 2: Review
    print("Stage 2: Reviewing...")
    stage2 = stage_2_review(text, translation, target_lang)

    # Apply suggested changes if any
    if stage2.get('suggested_changes'):
        print(f"  - Found {len(stage2['suggested_changes'])} suggestions")
        # In practice, you might want to auto-apply these or flag for human review

    # Stage 3: Comprehension check
    print("Stage 3: Comprehension check...")
    stage3 = stage_3_comprehension_check(text, translation, target_lang)

    # Compile quality report
    report = {
        'target_language': target_lang,
        'translation': translation,
        'stage1_confidence': stage1.get('confidence'),
        'stage2_quality': stage2.get('overall_quality'),
        'stage3_recommendation': stage3.get('recommendation'),
        'issues_flagged': {
            'uncertain_terms': stage1.get('uncertain_terms', []),
            'review_issues': stage2.get('issues_found', []),
            'meaning_differences': stage3.get('key_differences', [])
        },
        'needs_human_review': stage3.get('recommendation') != 'approve'
    }

    return report

# Example usage
source_text = """
We're here to support you. Our support workers can help with housing,
benefits advice, and safeguarding concerns. All service users are welcome.
"""

for lang in ['fr', 'es']:
    result = translate_with_quality_control(source_text, lang)

    print(f"\n{'='*50}")
    print(f"Language: {result['target_language']}")
    print(f"Translation: {result['translation']}")
    print(f"Quality scores: Stage1={result['stage1_confidence']}%, Stage2={result['stage2_quality']}%")
    print(f"Recommendation: {result['stage3_recommendation']}")
    print(f"Needs human review: {result['needs_human_review']}")

    if result['issues_flagged']['uncertain_terms']:
        print(f"Uncertain terms: {result['issues_flagged']['uncertain_terms']}")