LLM-Based Translation Systems 2025: How Large Language Models Are Revolutionizing Machine Translation#

1
# Traditional NMT Approach
2
class TraditionalNMT:
3
    def translate(self, text, source_lang, target_lang):
4
        # Limited to learned phrase patterns
5
        encoded = self.encoder(text, source_lang)
6
        attention_weights = self.attention(encoded)
7
        decoded = self.decoder(attention_weights, target_lang)
8
        return decoded
9

10
# LLM-Based Approach
11
class LLMTranslator:
12
    def translate(self, text, source_lang, target_lang, context=None):
13
        # Rich contextual understanding
14
        prompt = self.construct_contextual_prompt(
15
            text=text,
16
            source_lang=source_lang,
17
            target_lang=target_lang,
18
            context=context,
19
            cultural_notes=self.get_cultural_context(source_lang, target_lang),
20
            domain=self.detect_domain(text),
21
            tone=self.analyze_tone(text)
22
        )
23

24
        # Leverages full language understanding
25
        translation = self.llm.generate(
26
            prompt,
27
            temperature=0.3,  # Balance creativity and accuracy
28
            max_tokens=len(text.split()) * 2,
29
            stop_sequences=["[END_TRANSLATION]"]
30
        )
31

32
        return self.post_process(translation)

1
// High-performance technical translation in Rust
2
use serde::{Deserialize, Serialize};
3
use tokio::sync::RwLock;
4

5
#[derive(Serialize, Deserialize)]
6
struct TechnicalTranslationRequest {
7
    content: String,
8
    domain: TechnicalDomain,
9
    source_lang: String,
10
    target_lang: String,
11
    precision_level: PrecisionLevel,
12
}
13

14
pub struct DeepSeekR1Translator {
15
    model: String,
16
    technical_glossaries: RwLock<HashMap<TechnicalDomain, Glossary>>,
17
    consistency_cache: RwLock<TranslationCache>,
18
    quality_assurance: QualityAssuranceEngine,
19
}
20

21
impl DeepSeekR1Translator {
22
    pub async fn translate_technical_document(
23
        &self,
24
        request: TechnicalTranslationRequest
25
    ) -> Result<TechnicalTranslationResult, TranslationError> {
26
        // Domain-specific preprocessing
27
        let preprocessed = self.preprocess_technical_content(
28
            &request.content,
29
            &request.domain
30
        ).await?;
31

32
        // Load domain-specific glossary
33
        let glossary = self.technical_glossaries
34
            .read()
35
            .await
36
            .get(&request.domain)
37
            .cloned()
38
            .unwrap_or_default();
39

40
        // Extract technical terminology
41
        let terminology = self.extract_technical_terms(
42
            &preprocessed,
43
            &glossary
44
        );
45

46
        // Generate translation with technical precision
47
        let translation = self.generate_technical_translation(
48
            content=&preprocessed,
49
            terminology=&terminology,
50
            precision=&request.precision_level,
51
            source_lang=&request.source_lang,
52
            target_lang=&request.target_lang
53
        ).await?;
54

55
        // Technical accuracy verification
56
        let accuracy_score = self.verify_technical_accuracy(
57
            &preprocessed,
58
            &translation,
59
            &terminology
60
        ).await?;
61

62
        // Update consistency cache
63
        self.update_consistency_cache(
64
            &terminology,
65
            &translation
66
        ).await;
67

68
        Ok(TechnicalTranslationResult {
69
            translation,
70
            terminology_mappings: terminology,
71
            accuracy_score,
72
            consistency_score: self.calculate_consistency_score(&translation).await,
73
        })
74
    }
75

76
    async fn generate_technical_translation(
77
        &self,
78
        content: &str,
79
        terminology: &TechnicalTerminology,
80
        precision: &PrecisionLevel,
81
        source_lang: &str,
82
        target_lang: &str
83
    ) -> Result<String, TranslationError> {
84
        let prompt = format!(
85
            r#"
86
            You are a technical translator specializing in {domain}.
87

88
            Context:
89
            - Source: {source_lang}
90
            - Target: {target_lang}
91
            - Precision Level: {precision:?}
92
            - Domain: {domain}
93

94
            Terminology Constraints:
95
            {terminology_constraints}
96

97
            Technical Content:
98
            "{content}"
99

100
            Requirements:
101
            1. Maintain exact technical accuracy
102
            2. Use provided terminology consistently
103
            3. Preserve formatting and structure
104
            4. Maintain mathematical/chemical formulas exactly
105
            5. Preserve code snippets without modification
106

107
            Translation:
108
            "#,
109
            domain = terminology.domain,
110
            source_lang = source_lang,
111
            target_lang = target_lang,
112
            precision = precision,
113
            terminology_constraints = self.format_terminology_constraints(terminology),
114
            content = content
115
        );
116

117
        let response = self.model_client.complete(
118
            ModelRequest {
119
                prompt,
120
                temperature: 0.1,  // Low temperature for technical accuracy
121
                max_tokens: content.len() * 2,
122
                stop_sequences: vec!["[END_TRANSLATION]".to_string()],
123
                model_params: ModelParams {
124
                    top_p: 0.9,
125
                    frequency_penalty: 0.0,
126
                    presence_penalty: 0.0,
127
                }
128
            }
129
        ).await?;
130

131
        Ok(response.content)
132
    }
133
}

1
class AdvancedPromptBuilder:
2
    def __init__(self):
3
        self.cultural_knowledge_db = CulturalKnowledgeDB()
4
        self.domain_expertise = DomainExpertiseEngine()
5
        self.style_analyzer = StyleAnalyzer()
6

7
    def build_contextual_prompt(self, translation_request):
8
        # Analyze source content
9
        content_analysis = self.analyze_content(translation_request.text)
10

11
        # Cultural context
12
        cultural_notes = self.cultural_knowledge_db.get_context(
13
            source_culture=translation_request.source_lang,
14
            target_culture=translation_request.target_lang,
15
            content_type=content_analysis.content_type
16
        )
17

18
        # Domain expertise
19
        domain_guidelines = self.domain_expertise.get_guidelines(
20
            content_analysis.domain
21
        )
22

23
        # Style and tone
24
        style_guide = self.style_analyzer.analyze_style(
25
            translation_request.text
26
        )
27

28
        prompt = f"""
29
        ROLE: Expert translator with deep cultural and domain knowledge
30

31
        CONTEXT:
32
        - Source Language: {translation_request.source_lang}
33
        - Target Language: {translation_request.target_lang}
34
        - Content Domain: {content_analysis.domain}
35
        - Formality Level: {style_guide.formality}
36
        - Emotional Tone: {style_guide.tone}
37

38
        CULTURAL CONSIDERATIONS:
39
        {self.format_cultural_notes(cultural_notes)}
40

41
        DOMAIN EXPERTISE:
42
        {self.format_domain_guidelines(domain_guidelines)}
43

44
        STYLE REQUIREMENTS:
45
        - Maintain {style_guide.formality} formality level
46
        - Preserve {style_guide.tone} emotional tone
47
        - Target audience: {content_analysis.target_audience}
48

49
        CONTENT TO TRANSLATE:
50
        "{translation_request.text}"
51

52
        TRANSLATION APPROACH:
53
        1. Understand the source meaning and intent
54
        2. Consider cultural context and adapt references
55
        3. Apply domain-specific terminology
56
        4. Maintain appropriate style and tone
57
        5. Ensure natural flow in target language
58

59
        DELIVERABLES:
60
        1. Primary translation
61
        2. Cultural adaptations made (if any)
62
        3. Confidence level (1-10)
63
        4. Alternative phrasings for key concepts
64

65
        Translation:
66
        """
67

68
        return prompt
69

70
    def format_cultural_notes(self, cultural_notes):
71
        if not cultural_notes:
72
            return "No specific cultural adaptations required."
73

74
        formatted = "Cultural Considerations:\n"
75
        for note in cultural_notes:
76
            formatted += f"- {note.concept}: {note.adaptation_strategy}\n"
77
        return formatted

1
class LLMTranslationQA:
2
    def __init__(self):
3
        self.quality_metrics = [
4
            AccuracyMetric(),
5
            FluencyMetric(),
6
            CulturalAppropriatenessMetric(),
7
            DomainConsistencyMetric(),
8
            StylePreservationMetric()
9
        ]
10

11
        self.reference_evaluator = ReferenceEvaluator()
12
        self.human_evaluation_api = HumanEvaluationAPI()
13

14
    async def comprehensive_evaluation(self, original, translation, config):
15
        evaluations = {}
16

17
        # Automated quality metrics
18
        for metric in self.quality_metrics:
19
            score = await metric.evaluate(original, translation, config)
20
            evaluations[metric.name] = score
21

22
        # Reference-based evaluation
23
        if config.reference_translations:
24
            ref_scores = await self.reference_evaluator.evaluate(
25
                translation=translation,
26
                references=config.reference_translations
27
            )
28
            evaluations.update(ref_scores)
29

30
        # Human evaluation for high-stakes content
31
        if config.human_evaluation_required:
32
            human_scores = await self.request_human_evaluation(
33
                original=original,
34
                translation=translation,
35
                priority=config.priority_level
36
            )
37
            evaluations['human_evaluation'] = human_scores
38

39
        return QualityReport(
40
            overall_score=self.calculate_overall_score(evaluations),
41
            detailed_scores=evaluations,
42
            recommendations=self.generate_recommendations(evaluations),
43
            confidence_level=self.calculate_confidence(evaluations)
44
        )
45

46
    def generate_recommendations(self, evaluations):
47
        recommendations = []
48

49
        if evaluations.get('accuracy', 0) < 0.8:
50
            recommendations.append(
51
                "Consider revising translation for factual accuracy"
52
            )
53

54
        if evaluations.get('cultural_appropriateness', 0) < 0.85:
55
            recommendations.append(
56
                "Review cultural adaptations and local references"
57
            )
58

59
        if evaluations.get('domain_consistency', 0) < 0.9:
60
            recommendations.append(
61
                "Verify domain-specific terminology usage"
62
            )
63

64
        return recommendations

1
# Production deployment for enterprise LLM translation
2
apiVersion: v1
3
kind: ConfigMap
4
metadata:
5
  name: llm-translation-config
6
data:
7
  config.yaml: |
8
    translation_service:
9
      models:
10
        primary: "gpt-4o"
11
        fallback: "claude-3-opus"
12
        specialized:
13
          legal: "claude-3-opus"
14
          medical: "claude-3-opus"
15
          technical: "deepseek-r1"
16
          creative: "gpt-4o"
17

18
      quality_assurance:
19
        enabled: true
20
        minimum_confidence: 0.85
21
        human_review_threshold: 0.7
22
        batch_processing: true
23

24
      caching:
25
        enabled: true
26
        cache_similar_translations: true
27
        similarity_threshold: 0.95
28
        ttl_hours: 168  # 1 week
29

30
      monitoring:
31
        metrics_enabled: true
32
        tracing_enabled: true
33
        cost_tracking: true
34
        performance_alerts: true
35

36
---
37
apiVersion: apps/v1
38
kind: Deployment
39
metadata:
40
  name: llm-translation-service
41
spec:
42
  replicas: 5
43
  template:
44
    spec:
45
      containers:
46
      - name: translation-api
47
        image: llm-translator:v3.2.0
48
        env:
49
        - name: PRIMARY_MODEL
50
          value: "gpt-4o"
51
        - name: ENABLE_PARALLEL_PROCESSING
52
          value: "true"
53
        - name: MAX_CONCURRENT_REQUESTS
54
          value: "100"
55
        resources:
56
          requests:
57
            memory: "8Gi"
58
            cpu: "4"
59
          limits:
60
            memory: "16Gi"
61
            cpu: "8"
62
        livenessProbe:
63
          httpGet:
64
            path: /health
65
            port: 8080
66
          initialDelaySeconds: 60
67
          periodSeconds: 30
68
        readinessProbe:
69
          httpGet:
70
            path: /ready
71
            port: 8080
72
          initialDelaySeconds: 10
73
          periodSeconds: 5

1
import pandas as pd
2
import matplotlib.pyplot as plt
3

4
class TranslationBenchmark:
5
    def run_comprehensive_benchmark(self):
6
        results = {
7
            'Model': [
8
                'Google Translate (NMT)', 'DeepL (NMT)',
9
                'GPT-4o', 'Claude-3-Opus', 'Gemini-2.5-Pro', 'DeepSeek-R1'
10
            ],
11
            'BLEU_Score': [40.2, 42.1, 43.7, 44.1, 44.8, 42.9],
12
            'Cultural_Appropriateness': [72, 78, 91, 93, 88, 85],
13
            'Domain_Accuracy': [85, 87, 94, 96, 92, 97],
14
            'Context_Coherence': [68, 72, 89, 92, 87, 84],
15
            'Cost_Per_1M_Tokens': [0.5, 1.2, 15.0, 18.0, 12.0, 8.0],
16
            'Avg_Response_Time_ms': [120, 150, 180, 200, 150, 170]
17
        }
18

19
        df = pd.DataFrame(results)
20

21
        # Calculate composite quality score
22
        df['Quality_Score'] = (
23
            df['BLEU_Score'] * 0.25 +
24
            df['Cultural_Appropriateness'] * 0.25 +
25
            df['Domain_Accuracy'] * 0.25 +
26
            df['Context_Coherence'] * 0.25
27
        )
28

29
        return df

1
class CostBenefitAnalysis:
2
    def analyze_enterprise_adoption(self, translation_volume_monthly):
3
        traditional_costs = {
4
            'google_translate': translation_volume_monthly * 0.0005,  # $0.5 per 1M tokens
5
            'human_translators': translation_volume_monthly * 0.15,  # $150 per 1M tokens
6
            'quality_assurance': translation_volume_monthly * 0.05   # Additional QA costs
7
        }
8

9
        llm_costs = {
10
            'gpt_4o': translation_volume_monthly * 0.015,  # $15 per 1M tokens
11
            'claude_opus': translation_volume_monthly * 0.018,  # $18 per 1M tokens
12
            'gemini_pro': translation_volume_monthly * 0.012,  # $12 per 1M tokens
13
            'quality_gains': -translation_volume_monthly * 0.02  # Reduced revision costs
14
        }
15

16
        # Calculate quality-adjusted costs
17
        traditional_adjusted = sum(traditional_costs.values()) * 1.3  # 30% quality penalty
18
        llm_adjusted = sum(llm_costs.values())
19

20
        return {
21
            'traditional_total': traditional_adjusted,
22
            'llm_total': llm_adjusted,
23
            'savings': traditional_adjusted - llm_adjusted,
24
            'roi_months': 6 if llm_adjusted < traditional_adjusted else float('inf')
25
        }

1
class MedicalTranslationSystem:
2
    def __init__(self):
3
        self.medical_glossary = MedicalGlossaryDB()
4
        self.drug_interaction_db = DrugInteractionDB()
5
        self.regulatory_compliance = RegulatoryComplianceEngine()
6

7
    async def translate_medical_document(self, document, target_lang):
8
        # Medical terminology extraction
9
        medical_terms = await self.extract_medical_terminology(document)
10

11
        # Drug name standardization
12
        standardized_drugs = await self.standardize_drug_names(
13
            medical_terms.drugs,
14
            target_region=self.get_region_from_lang(target_lang)
15
        )
16

17
        # Clinical context preservation
18
        clinical_context = await self.preserve_clinical_context(document)
19

20
        # Translation with medical precision
21
        translation = await self.llm.translate(
22
            text=document.content,
23
            source_lang=document.language,
24
            target_lang=target_lang,
25
            domain="medical",
26
            terminology=medical_terms,
27
            drug_mappings=standardized_drugs,
28
            clinical_context=clinical_context,
29
            precision_level="maximum"
30
        )
31

32
        # Medical accuracy verification
33
        accuracy_report = await self.verify_medical_accuracy(
34
            original=document,
35
            translation=translation,
36
            medical_terms=medical_terms
37
        )
38

39
        # Regulatory compliance check
40
        compliance_report = await self.regulatory_compliance.verify(
41
            translation,
42
            target_region=self.get_region_from_lang(target_lang)
43
        )
44

45
        return MedicalTranslationResult(
46
            translation=translation,
47
            accuracy_report=accuracy_report,
48
            compliance_report=compliance_report,
49
            medical_terminology=medical_terms
50
        )

1
class LegalTranslationEngine:
2
    def __init__(self):
3
        self.legal_ontology = LegalOntologyDB()
4
        self.jurisdiction_mapper = JurisdictionMapper()
5
        self.contract_analyzer = ContractAnalyzer()
6

7
    async def translate_legal_contract(self, contract, target_jurisdiction):
8
        # Legal concept extraction
9
        legal_concepts = await self.contract_analyzer.extract_concepts(contract)
10

11
        # Jurisdiction-specific mapping
12
        concept_mappings = await self.jurisdiction_mapper.map_concepts(
13
            concepts=legal_concepts,
14
            source_jurisdiction=contract.jurisdiction,
15
            target_jurisdiction=target_jurisdiction
16
        )
17

18
        # Contract structure preservation
19
        contract_structure = await self.analyze_contract_structure(contract)
20

21
        # Legal translation with precision
22
        translation = await self.llm.translate(
23
            text=contract.content,
24
            source_lang=contract.language,
25
            target_lang=target_jurisdiction.language,
26
            domain="legal",
27
            legal_concepts=legal_concepts,
28
            concept_mappings=concept_mappings,
29
            contract_type=contract.contract_type,
30
            preserve_legal_force=True
31
        )
32

33
        # Legal validity verification
34
        validity_report = await self.verify_legal_validity(
35
            original=contract,
36
            translation=translation,
37
            target_jurisdiction=target_jurisdiction
38
        )
39

40
        return LegalTranslationResult(
41
            translation=translation,
42
            validity_report=validity_report,
43
            concept_mappings=concept_mappings,
44
            legal_disclaimer=self.generate_disclaimer()
45
        )

1
class MultiAgentTranslationSystem:
2
    """
3
    Collaborative translation using multiple specialized LLM agents
4
    """
5
    def __init__(self):
6
        self.agents = {
7
            'linguistic_expert': LinguisticExpertAgent(),
8
            'cultural_advisor': CulturalAdvisorAgent(),
9
            'domain_specialist': DomainSpecialistAgent(),
10
            'quality_reviewer': QualityReviewerAgent(),
11
            'style_editor': StyleEditorAgent()
12
        }
13

14
        self.coordinator = AgentCoordinator()
15

16
    async def collaborative_translation(self, content, config):
17
        # Phase 1: Parallel analysis
18
        analysis_tasks = [
19
            self.agents['linguistic_expert'].analyze(content),
20
            self.agents['cultural_advisor'].analyze_cultural_elements(content),
21
            self.agents['domain_specialist'].analyze_domain(content, config.domain),
22
        ]
23

24
        analyses = await asyncio.gather(*analysis_tasks)
25

26
        # Phase 2: Collaborative translation
27
        translation_plan = self.coordinator.create_translation_plan(analyses)
28

29
        initial_translation = await self.agents['linguistic_expert'].translate(
30
            content,
31
            plan=translation_plan
32
        )
33

34
        # Phase 3: Specialized refinements
35
        refinement_tasks = [
36
            self.agents['cultural_advisor'].refine_cultural_aspects(
37
                initial_translation, analyses[1]
38
            ),
39
            self.agents['domain_specialist'].refine_terminology(
40
                initial_translation, analyses[2]
41
            ),
42
            self.agents['style_editor'].refine_style(
43
                initial_translation, config.style_requirements
44
            )
45
        ]
46

47
        refinements = await asyncio.gather(*refinement_tasks)
48

49
        # Phase 4: Quality review and synthesis
50
        final_translation = await self.agents['quality_reviewer'].synthesize(
51
            initial_translation=initial_translation,
52
            refinements=refinements,
53
            quality_requirements=config.quality_requirements
54
        )
55

56
        return CollaborativeTranslationResult(
57
            translation=final_translation,
58
            agent_contributions=self.coordinator.get_contribution_report(),
59
            quality_assurance=await self.comprehensive_qa(final_translation)
60
        )

1
class AdaptiveLLMTranslator:
2
    """
3
    LLM translator that learns and adapts from user feedback
4
    """
5
    def __init__(self):
6
        self.base_model = "gpt-4o"
7
        self.fine_tuning_engine = FineTuningEngine()
8
        self.feedback_processor = FeedbackProcessor()
9
        self.knowledge_updater = KnowledgeUpdater()
10

11
    async def translate_with_learning(self, content, config):
12
        # Standard translation
13
        translation = await self.translate(content, config)
14

15
        # Collect implicit feedback
16
        implicit_feedback = await self.collect_implicit_feedback(
17
            translation,
18
            user_behavior=config.user_behavior_tracking
19
        )
20

21
        # Process feedback for learning
22
        learning_data = self.feedback_processor.process(
23
            original=content,
24
            translation=translation,
25
            implicit_feedback=implicit_feedback,
26
            explicit_feedback=config.explicit_feedback
27
        )
28

29
        # Update knowledge base
30
        if learning_data.confidence > 0.8:
31
            await self.knowledge_updater.update(learning_data)
32

33
        # Trigger fine-tuning if sufficient data accumulated
34
        if self.should_fine_tune():
35
            await self.fine_tuning_engine.trigger_training(
36
                data_source=self.get_accumulated_learning_data(),
37
                training_config=self.get_fine_tuning_config()
38
            )
39

40
        return AdaptiveTranslationResult(
41
            translation=translation,
42
            learning_applied=learning_data,
43
            model_version=self.get_current_model_version()
44
        )

1
class PromptOptimizer:
2
    def __init__(self):
3
        self.prompt_templates = PromptTemplateDB()
4
        self.a_b_tester = ABTester()
5
        self.performance_tracker = PerformanceTracker()
6

7
    async def optimize_translation_prompt(self, base_prompt, test_data):
8
        # Generate prompt variations
9
        variations = self.generate_prompt_variations(base_prompt)
10

11
        # A/B test variations
12
        test_results = []
13
        for variation in variations:
14
            result = await self.a_b_tester.test_prompt(
15
                prompt=variation,
16
                test_data=test_data,
17
                metrics=['accuracy', 'fluency', 'cultural_appropriateness']
18
            )
19
            test_results.append(result)
20

21
        # Select best performing prompt
22
        best_prompt = self.select_best_prompt(test_results)
23

24
        # Monitor performance over time
25
        await self.performance_tracker.monitor(
26
            prompt=best_prompt,
27
            continuous_improvement=True
28
        )
29

30
        return OptimizedPrompt(
31
            prompt=best_prompt,
32
            performance_metrics=test_results,
33
            optimization_history=self.get_optimization_history()
34
        )
35

36
    def generate_prompt_variations(self, base_prompt):
37
        variations = []
38

39
        # Structural variations
40
        variations.extend([
41
            self.add_step_by_step_reasoning(base_prompt),
42
            self.add_cultural_context_emphasis(base_prompt),
43
            self.add_quality_checkpoints(base_prompt),
44
            self.add_alternative_generation(base_prompt)
45
        ])
46

47
        # Tone variations
48
        variations.extend([
49
            self.adjust_formality_level(base_prompt, 'formal'),
50
            self.adjust_formality_level(base_prompt, 'conversational'),
51
            self.adjust_expertise_level(base_prompt, 'expert'),
52
            self.adjust_expertise_level(base_prompt, 'general')
53
        ])
54

55
        return variations

1
class RobustTranslationPipeline:
2
    def __init__(self):
3
        self.primary_models = ['gpt-4o', 'claude-3-opus']
4
        self.fallback_models = ['gemini-2.5-pro', 'deepseek-r1']
5
        self.traditional_fallback = 'deepl'
6

7
        self.circuit_breaker = CircuitBreaker()
8
        self.retry_handler = RetryHandler()
9
        self.quality_validator = QualityValidator()
10

11
    async def robust_translate(self, content, config):
12
        translation_attempts = []
13

14
        # Primary model attempts
15
        for model in self.primary_models:
16
            if self.circuit_breaker.is_closed(model):
17
                try:
18
                    translation = await self.translate_with_model(
19
                        content, config, model
20
                    )
21

22
                    # Validate quality
23
                    quality_score = await self.quality_validator.validate(
24
                        content, translation
25
                    )
26

27
                    if quality_score.overall >= config.minimum_quality:
28
                        return translation
29

30
                    translation_attempts.append({
31
                        'model': model,
32
                        'translation': translation,
33
                        'quality': quality_score
34
                    })
35

36
                except Exception as e:
37
                    await self.circuit_breaker.record_failure(model, e)
38
                    continue
39

40
        # Fallback model attempts
41
        for model in self.fallback_models:
42
            try:
43
                translation = await self.translate_with_model(
44
                    content, config, model
45
                )
46

47
                quality_score = await self.quality_validator.validate(
48
                    content, translation
49
                )
50

51
                if quality_score.overall >= config.fallback_minimum_quality:
52
                    return translation
53

54
                translation_attempts.append({
55
                    'model': model,
56
                    'translation': translation,
57
                    'quality': quality_score
58
                })
59

60
            except Exception as e:
61
                continue
62

63
        # Traditional NMT fallback
64
        if config.allow_traditional_fallback:
65
            try:
66
                return await self.traditional_translate(content, config)
67
            except Exception:
68
                pass
69

70
        # Return best attempt if all else fails
71
        if translation_attempts:
72
            best_attempt = max(
73
                translation_attempts,
74
                key=lambda x: x['quality'].overall
75
            )
76
            return best_attempt['translation']
77

78
        raise TranslationFailedException("All translation methods failed")