Update app.py

app.py

@@ -8,12 +8,24 @@ import os
 import json
 import zipfile
 import tempfile
-from typing import Dict, List, Tuple, Union
+from typing import Dict, List, Tuple, Union, Optional
 import re
 from pathlib import Path
 import openpyxl
 from dataclasses import dataclass
 from enum import Enum
+from docx import Document
+from docx.shared import Inches, Pt, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import matplotlib.pyplot as plt
+from datetime import datetime
 
 # Configuración para HuggingFace
 os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
@@ -21,6 +33,181 @@ os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 # Inicializar cliente Anthropic
 client = anthropic.Anthropic()
 
+# Sistema de traducción
+TRANSLATIONS = {
+    'en': {
+        'title': '🧬 Comparative Analyzer of Biotechnological Models',
+        'subtitle': 'Specialized in comparative analysis of mathematical model fitting results',
+        'upload_files': '📁 Upload fitting results (CSV/Excel)',
+        'select_model': '🤖 Claude Model',
+        'select_language': '🌐 Language',
+        'select_theme': '🎨 Theme',
+        'detail_level': '📋 Analysis detail level',
+        'detailed': 'Detailed',
+        'summarized': 'Summarized',
+        'analyze_button': '🚀 Analyze and Compare Models',
+        'export_format': '📄 Export format',
+        'export_button': '💾 Export Report',
+        'comparative_analysis': '📊 Comparative Analysis',
+        'implementation_code': '💻 Implementation Code',
+        'data_format': '📋 Expected data format',
+        'examples': '📚 Analysis examples',
+        'light': 'Light',
+        'dark': 'Dark',
+        'best_for': 'Best for',
+        'loading': 'Loading...',
+        'error_no_api': 'Please configure ANTHROPIC_API_KEY in HuggingFace Space secrets',
+        'error_no_files': 'Please upload fitting result files to analyze',
+        'report_exported': 'Report exported successfully as',
+        'specialized_in': '🎯 Specialized in:',
+        'metrics_analyzed': '📊 Analyzed metrics:',
+        'what_analyzes': '🔍 What it specifically analyzes:',
+        'tips': '💡 Tips for better results:'
+    },
+    'es': {
+        'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
+        'subtitle': 'Especializado en análisis comparativo de resultados de ajuste de modelos matemáticos',
+        'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
+        'select_model': '🤖 Modelo Claude',
+        'select_language': '🌐 Idioma',
+        'select_theme': '🎨 Tema',
+        'detail_level': '📋 Nivel de detalle del análisis',
+        'detailed': 'Detallado',
+        'summarized': 'Resumido',
+        'analyze_button': '🚀 Analizar y Comparar Modelos',
+        'export_format': '📄 Formato de exportación',
+        'export_button': '💾 Exportar Reporte',
+        'comparative_analysis': '📊 Análisis Comparativo',
+        'implementation_code': '💻 Código de Implementación',
+        'data_format': '📋 Formato de datos esperado',
+        'examples': '📚 Ejemplos de análisis',
+        'light': 'Claro',
+        'dark': 'Oscuro',
+        'best_for': 'Mejor para',
+        'loading': 'Cargando...',
+        'error_no_api': 'Por favor configura ANTHROPIC_API_KEY en los secretos del Space',
+        'error_no_files': 'Por favor sube archivos con resultados de ajuste para analizar',
+        'report_exported': 'Reporte exportado exitosamente como',
+        'specialized_in': '🎯 Especializado en:',
+        'metrics_analyzed': '📊 Métricas analizadas:',
+        'what_analyzes': '🔍 Qué analiza específicamente:',
+        'tips': '💡 Tips para mejores resultados:'
+    },
+    'fr': {
+        'title': '🧬 Analyseur Comparatif de Modèles Biotechnologiques',
+        'subtitle': 'Spécialisé dans l\'analyse comparative des résultats d\'ajustement',
+        'upload_files': '📁 Télécharger les résultats (CSV/Excel)',
+        'select_model': '🤖 Modèle Claude',
+        'select_language': '🌐 Langue',
+        'select_theme': '🎨 Thème',
+        'detail_level': '📋 Niveau de détail',
+        'detailed': 'Détaillé',
+        'summarized': 'Résumé',
+        'analyze_button': '🚀 Analyser et Comparer',
+        'export_format': '📄 Format d\'export',
+        'export_button': '💾 Exporter le Rapport',
+        'comparative_analysis': '📊 Analyse Comparative',
+        'implementation_code': '💻 Code d\'Implémentation',
+        'data_format': '📋 Format de données attendu',
+        'examples': '📚 Exemples d\'analyse',
+        'light': 'Clair',
+        'dark': 'Sombre',
+        'best_for': 'Meilleur pour',
+        'loading': 'Chargement...',
+        'error_no_api': 'Veuillez configurer ANTHROPIC_API_KEY',
+        'error_no_files': 'Veuillez télécharger des fichiers à analyser',
+        'report_exported': 'Rapport exporté avec succès comme',
+        'specialized_in': '🎯 Spécialisé dans:',
+        'metrics_analyzed': '📊 Métriques analysées:',
+        'what_analyzes': '🔍 Ce qu\'il analyse spécifiquement:',
+        'tips': '💡 Conseils pour de meilleurs résultats:'
+    },
+    'de': {
+        'title': '🧬 Vergleichender Analysator für Biotechnologische Modelle',
+        'subtitle': 'Spezialisiert auf vergleichende Analyse von Modellanpassungsergebnissen',
+        'upload_files': '📁 Ergebnisse hochladen (CSV/Excel)',
+        'select_model': '🤖 Claude Modell',
+        'select_language': '🌐 Sprache',
+        'select_theme': '🎨 Thema',
+        'detail_level': '📋 Detailgrad der Analyse',
+        'detailed': 'Detailliert',
+        'summarized': 'Zusammengefasst',
+        'analyze_button': '🚀 Analysieren und Vergleichen',
+        'export_format': '📄 Exportformat',
+        'export_button': '💾 Bericht Exportieren',
+        'comparative_analysis': '📊 Vergleichende Analyse',
+        'implementation_code': '💻 Implementierungscode',
+        'data_format': '📋 Erwartetes Datenformat',
+        'examples': '📚 Analysebeispiele',
+        'light': 'Hell',
+        'dark': 'Dunkel',
+        'best_for': 'Am besten für',
+        'loading': 'Laden...',
+        'error_no_api': 'Bitte konfigurieren Sie ANTHROPIC_API_KEY',
+        'error_no_files': 'Bitte laden Sie Dateien zur Analyse hoch',
+        'report_exported': 'Bericht erfolgreich exportiert als',
+        'specialized_in': '🎯 Spezialisiert auf:',
+        'metrics_analyzed': '📊 Analysierte Metriken:',
+        'what_analyzes': '🔍 Was spezifisch analysiert wird:',
+        'tips': '💡 Tipps für bessere Ergebnisse:'
+    },
+    'pt': {
+        'title': '🧬 Analisador Comparativo de Modelos Biotecnológicos',
+        'subtitle': 'Especializado em análise comparativa de resultados de ajuste',
+        'upload_files': '📁 Carregar resultados (CSV/Excel)',
+        'select_model': '🤖 Modelo Claude',
+        'select_language': '🌐 Idioma',
+        'select_theme': '🎨 Tema',
+        'detail_level': '📋 Nível de detalhe',
+        'detailed': 'Detalhado',
+        'summarized': 'Resumido',
+        'analyze_button': '🚀 Analisar e Comparar',
+        'export_format': '📄 Formato de exportação',
+        'export_button': '💾 Exportar Relatório',
+        'comparative_analysis': '📊 Análise Comparativa',
+        'implementation_code': '💻 Código de Implementação',
+        'data_format': '📋 Formato de dados esperado',
+        'examples': '📚 Exemplos de análise',
+        'light': 'Claro',
+        'dark': 'Escuro',
+        'best_for': 'Melhor para',
+        'loading': 'Carregando...',
+        'error_no_api': 'Por favor configure ANTHROPIC_API_KEY',
+        'error_no_files': 'Por favor carregue arquivos para analisar',
+        'report_exported': 'Relatório exportado com sucesso como',
+        'specialized_in': '🎯 Especializado em:',
+        'metrics_analyzed': '📊 Métricas analisadas:',
+        'what_analyzes': '🔍 O que analisa especificamente:',
+        'tips': '💡 Dicas para melhores resultados:'
+    }
+}
+
+# Temas disponibles
+THEMES = {
+    'light': gr.themes.Soft(),
+    'dark': gr.themes.Base(
+        primary_hue="blue",
+        secondary_hue="gray",
+        neutral_hue="gray",
+        font=["Arial", "sans-serif"]
+    ).set(
+        body_background_fill="dark",
+        body_background_fill_dark="*neutral_950",
+        button_primary_background_fill="*primary_600",
+        button_primary_background_fill_hover="*primary_500",
+        button_primary_text_color="white",
+        block_background_fill="*neutral_800",
+        block_border_color="*neutral_700",
+        block_label_text_color="*neutral_200",
+        block_title_text_color="*neutral_100",
+        checkbox_background_color="*neutral_700",
+        checkbox_background_color_selected="*primary_600",
+        input_background_fill="*neutral_700",
+        input_border_color="*neutral_600",
+        input_placeholder_color="*neutral_400"
+    )
+}
+
 # Enum para tipos de análisis
 class AnalysisType(Enum):
     MATHEMATICAL_MODEL = "mathematical_model"
@@ -91,28 +278,6 @@ class ModelRegistry:
             category="crecimiento_biomasa",
             biological_meaning="Incluye fase de adaptación (lag) seguida de crecimiento exponencial y estacionario"
         ))
-        
-        # Modelos enzimáticos
-        self.register_model(MathematicalModel(
-            name="Michaelis-Menten",
-            equation="v = Vmax × S / (Km + S)",
-            parameters=["Vmax", "Km"],
-            application="Cinética enzimática básica",
-            sources=["Warsaw Univ Tech", "Food Processing"],
-            category="consumo_sustrato",
-            biological_meaning="Describe saturación enzimática con afinidad por sustrato"
-        ))
-        
-        # Modelos de producto
-        self.register_model(MathematicalModel(
-            name="Luedeking-Piret",
-            equation="dP/dt = α × (dX/dt) + β × X",
-            parameters=["α (asociado)", "β (no asociado)"],
-            application="Producción mixta asociada/no asociada",
-            sources=["Cambridge", "E-Century"],
-            category="formacion_producto",
-            biological_meaning="Separa producción ligada al crecimiento de la producción metabólica"
-        ))
 
 # Instancia global del registro
 model_registry = ModelRegistry()
@@ -121,21 +286,21 @@ model_registry = ModelRegistry()
 CLAUDE_MODELS = {
     "claude-3-5-sonnet-20241022": {
         "name": "Claude 3.5 Sonnet",
-        "description": "Modelo rápido y eficiente",
+        "description": "Fast and efficient model",
         "max_tokens": 4000,
-        "best_for": "Análisis general"
+        "best_for": "General analysis"
     },
     "claude-3-opus-20240229": {
         "name": "Claude 3 Opus",
-        "description": "Modelo más potente",
+        "description": "Most powerful model",
         "max_tokens": 4000,
-        "best_for": "Análisis complejos"
+        "best_for": "Complex analysis"
     },
     "claude-3-haiku-20240307": {
         "name": "Claude 3 Haiku",
-        "description": "Modelo más rápido",
+        "description": "Fastest model",
         "max_tokens": 4000,
-        "best_for": "Análisis rápidos"
+        "best_for": "Quick analysis"
     }
 }
 
@@ -152,7 +317,7 @@ class FileProcessor:
                 text += page.extract_text() + "\n"
             return text
         except Exception as e:
-            return f"Error al leer PDF: {str(e)}"
+            return f"Error reading PDF: {str(e)}"
     
     @staticmethod
     def read_csv(csv_file) -> pd.DataFrame:
@@ -181,9 +346,162 @@ class FileProcessor:
                         file_data = zip_ref.read(file_name)
                         files.append((file_name, file_data))
         except Exception as e:
-            print(f"Error procesando ZIP: {e}")
+            print(f"Error processing ZIP: {e}")
         return files
 
+class ReportExporter:
+    """Clase para exportar reportes a diferentes formatos"""
+    
+    @staticmethod
+    def export_to_docx(content: str, filename: str, language: str = 'en') -> str:
+        """Exporta el contenido a un archivo DOCX"""
+        doc = Document()
+        
+        # Configurar estilos
+        title_style = doc.styles['Title']
+        title_style.font.size = Pt(24)
+        title_style.font.bold = True
+        
+        heading_style = doc.styles['Heading 1']
+        heading_style.font.size = Pt(18)
+        heading_style.font.bold = True
+        
+        # Título
+        title_text = {
+            'en': 'Comparative Analysis Report - Biotechnological Models',
+            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
+            'fr': 'Rapport d\'Analyse Comparative - Modèles Biotechnologiques',
+            'de': 'Vergleichsanalysebericht - Biotechnologische Modelle',
+            'pt': 'Relatório de Análise Comparativa - Modelos Biotecnológicos'
+        }
+        
+        doc.add_heading(title_text.get(language, title_text['en']), 0)
+        
+        # Fecha
+        date_text = {
+            'en': 'Generated on',
+            'es': 'Generado el',
+            'fr': 'Généré le',
+            'de': 'Erstellt am',
+            'pt': 'Gerado em'
+        }
+        doc.add_paragraph(f"{date_text.get(language, date_text['en'])}: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        doc.add_paragraph()
+        
+        # Procesar contenido
+        lines = content.split('\n')
+        current_paragraph = None
+        
+        for line in lines:
+            line = line.strip()
+            
+            if line.startswith('###'):
+                doc.add_heading(line.replace('###', '').strip(), level=2)
+            elif line.startswith('##'):
+                doc.add_heading(line.replace('##', '').strip(), level=1)
+            elif line.startswith('#'):
+                doc.add_heading(line.replace('#', '').strip(), level=0)
+            elif line.startswith('**') and line.endswith('**'):
+                # Texto en negrita
+                p = doc.add_paragraph()
+                run = p.add_run(line.replace('**', ''))
+                run.bold = True
+            elif line.startswith('- ') or line.startswith('* '):
+                # Lista
+                doc.add_paragraph(line[2:], style='List Bullet')
+            elif line.startswith(tuple('0123456789')):
+                # Lista numerada
+                doc.add_paragraph(line, style='List Number')
+            elif line == '---' or line.startswith('==='):
+                # Separador
+                doc.add_paragraph('_' * 50)
+            elif line:
+                # Párrafo normal
+                doc.add_paragraph(line)
+        
+        # Guardar documento
+        doc.save(filename)
+        return filename
+    
+    @staticmethod
+    def export_to_pdf(content: str, filename: str, language: str = 'en') -> str:
+        """Exporta el contenido a un archivo PDF"""
+        # Crear documento PDF
+        doc = SimpleDocTemplate(filename, pagesize=letter)
+        story = []
+        styles = getSampleStyleSheet()
+        
+        # Estilos personalizados
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Title'],
+            fontSize=24,
+            textColor=colors.HexColor('#1f4788'),
+            spaceAfter=30
+        )
+        
+        heading_style = ParagraphStyle(
+            'CustomHeading',
+            parent=styles['Heading1'],
+            fontSize=16,
+            textColor=colors.HexColor('#2e5090'),
+            spaceAfter=12
+        )
+        
+        # Título
+        title_text = {
+            'en': 'Comparative Analysis Report - Biotechnological Models',
+            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
+            'fr': 'Rapport d\'Analyse Comparative - Modèles Biotechnologiques',
+            'de': 'Vergleichsanalysebericht - Biotechnologische Modelle',
+            'pt': 'Relatório de Análise Comparativa - Modelos Biotecnológicos'
+        }
+        
+        story.append(Paragraph(title_text.get(language, title_text['en']), title_style))
+        
+        # Fecha
+        date_text = {
+            'en': 'Generated on',
+            'es': 'Generado el',
+            'fr': 'Généré le',
+            'de': 'Erstellt am',
+            'pt': 'Gerado em'
+        }
+        story.append(Paragraph(f"{date_text.get(language, date_text['en'])}: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+        story.append(Spacer(1, 0.5*inch))
+        
+        # Procesar contenido
+        lines = content.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            
+            if not line:
+                story.append(Spacer(1, 0.2*inch))
+            elif line.startswith('###'):
+                story.append(Paragraph(line.replace('###', '').strip(), styles['Heading3']))
+            elif line.startswith('##'):
+                story.append(Paragraph(line.replace('##', '').strip(), styles['Heading2']))
+            elif line.startswith('#'):
+                story.append(Paragraph(line.replace('#', '').strip(), heading_style))
+            elif line.startswith('**') and line.endswith('**'):
+                text = line.replace('**', '')
+                story.append(Paragraph(f"<b>{text}</b>", styles['Normal']))
+            elif line.startswith('- ') or line.startswith('* '):
+                story.append(Paragraph(f"• {line[2:]}", styles['Normal']))
+            elif line == '---' or line.startswith('==='):
+                story.append(Spacer(1, 0.3*inch))
+                story.append(Paragraph("_" * 70, styles['Normal']))
+                story.append(Spacer(1, 0.3*inch))
+            else:
+                # Limpiar caracteres especiales para PDF
+                clean_line = line.replace('📊', '[GRAPH]').replace('🎯', '[TARGET]').replace('🔍', '[SEARCH]').replace('💡', '[TIP]')
+                story.append(Paragraph(clean_line, styles['Normal']))
+        
+        # Construir PDF
+        doc.build(story)
+        return filename
+
 class AIAnalyzer:
     """Clase para análisis con IA"""
     
@@ -211,12 +529,12 @@ class AIAnalyzer:
                 return AnalysisType.DATA_FITTING
         
         prompt = """
-        Analiza este contenido y determina si es:
-        1. Un artículo científico que describe modelos matemáticos biotecnológicos
-        2. Datos experimentales para ajuste de parámetros  
-        3. Resultados de ajuste de modelos (con parámetros, R², RMSE, etc.)
+        Analyze this content and determine if it is:
+        1. A scientific article describing biotechnological mathematical models
+        2. Experimental data for parameter fitting  
+        3. Model fitting results (with parameters, R², RMSE, etc.)
         
-        Responde solo con: "MODELO", "DATOS" o "RESULTADOS"
+        Reply only with: "MODEL", "DATA" or "RESULTS"
         """
         
         try:
@@ -227,11 +545,11 @@ class AIAnalyzer:
             )
             
             result = response.content[0].text.strip().upper()
-            if "MODELO" in result:
+            if "MODEL" in result:
                 return AnalysisType.MATHEMATICAL_MODEL
-            elif "RESULTADOS" in result:
+            elif "RESULTS" in result:
                 return AnalysisType.FITTING_RESULTS
-            elif "DATOS" in result:
+            elif "DATA" in result:
                 return AnalysisType.DATA_FITTING
             else:
                 return AnalysisType.UNKNOWN
@@ -239,206 +557,120 @@ class AIAnalyzer:
         except:
             return AnalysisType.UNKNOWN
     
-    def analyze_mathematical_article(self, text: str, claude_model: str) -> Dict:
-        """Analiza artículo con modelos matemáticos"""
-        prompts = {
-            "identificar_modelos": """
-            Analiza este texto científico e identifica:
-            1. Modelos matemáticos biotecnológicos descritos
-            2. Ecuaciones específicas
-            3. Parámetros mencionados
-            4. Aplicaciones biotecnológicas
-            5. Microorganismos y procesos
-            
-            Formato JSON con estructura:
-            {
-                "modelos": ["nombre1", "nombre2"],
-                "ecuaciones": ["eq1", "eq2"],
-                "parametros": ["param1", "param2"],
-                "aplicaciones": ["app1", "app2"],
-                "microorganismos": ["org1", "org2"]
-            }
-            """,
-            
-            "recomendar_implementacion": """
-            Basado en los modelos identificados, proporciona:
-            1. Estrategia de implementación
-            2. Consideraciones experimentales
-            3. Métodos de validación
-            4. Posibles limitaciones
-            """
+    def get_language_prompt_prefix(self, language: str) -> str:
+        """Obtiene el prefijo del prompt según el idioma"""
+        prefixes = {
+            'en': "Please respond in English. ",
+            'es': "Por favor responde en español. ",
+            'fr': "Veuillez répondre en français. ",
+            'de': "Bitte antworten Sie auf Deutsch. ",
+            'pt': "Por favor responda em português. "
         }
-        
-        try:
-            response = self.client.messages.create(
-                model=claude_model,
-                max_tokens=2000,
-                messages=[{
-                    "role": "user",
-                    "content": f"{prompts['identificar_modelos']}\n\nTEXTO:\n{text[:3000]}"
-                }]
-            )
-            
-            models_info = response.content[0].text
-            
-            response2 = self.client.messages.create(
-                model=claude_model,
-                max_tokens=2000,
-                messages=[{
-                    "role": "user",
-                    "content": f"{prompts['recomendar_implementacion']}\n\nMODELOS:\n{models_info}"
-                }]
-            )
-            
-            return {
-                "tipo": "Artículo de Modelos Matemáticos",
-                "modelos": models_info,
-                "recomendaciones": response2.content[0].text
-            }
-            
-        except Exception as e:
-            return {"error": str(e)}
+        return prefixes.get(language, prefixes['en'])
     
-    def analyze_fitting_data(self, data: pd.DataFrame, claude_model: str) -> Dict:
-        """Analiza datos experimentales para ajuste de parámetros"""
-        data_summary = f"""
-        Columnas: {list(data.columns)}
-        Forma: {data.shape}
-        Primeras filas:
-        {data.head().to_string()}
-        
-        Estadísticas:
-        {data.describe().to_string()}
-        """
-        
-        prompt = """
-        Analiza estos datos experimentales y determina:
-        1. Variables independientes y dependientes
-        2. Posibles modelos matemáticos aplicables
-        3. Método de ajuste recomendado
-        4. Parámetros a estimar
-        5. Calidad esperada del ajuste
-        
-        Proporciona código Python para el ajuste.
-        """
-        
-        try:
-            response = self.client.messages.create(
-                model=claude_model,
-                max_tokens=3000,
-                messages=[{
-                    "role": "user",
-                    "content": f"{prompt}\n\nDATOS:\n{data_summary}"
-                }]
-            )
-            
-            return {
-                "tipo": "Datos Experimentales para Ajuste",
-                "analisis": response.content[0].text,
-                "resumen_datos": data_summary
-            }
-            
-        except Exception as e:
-            return {"error": str(e)}
-    
-    def analyze_fitting_results(self, data: pd.DataFrame, claude_model: str, detail_level: str = "detallado") -> Dict:
-        """Analiza resultados de ajuste de modelos con enfoque mejorado"""
+    def analyze_fitting_results(self, data: pd.DataFrame, claude_model: str, detail_level: str = "detailed", language: str = "en") -> Dict:
+        """Analiza resultados de ajuste de modelos con soporte multiidioma"""
         
         # Preparar resumen completo de los datos
         data_summary = f"""
-        RESULTADOS DE AJUSTE DE MODELOS MATEMÁTICOS:
+        FITTING RESULTS DATA:
         
-        Estructura de datos:
-        - Columnas: {list(data.columns)}
-        - Número de modelos evaluados: {len(data)}
+        Data structure:
+        - Columns: {list(data.columns)}
+        - Number of models evaluated: {len(data)}
         
-        Datos completos:
+        Complete data:
         {data.to_string()}
         
-        Estadísticas descriptivas:
+        Descriptive statistics:
         {data.describe().to_string()}
         """
         
-        # Prompt mejorado y especializado
+        # Obtener prefijo de idioma
+        lang_prefix = self.get_language_prompt_prefix(language)
+        
+        # Prompt mejorado con soporte de idioma
         prompt = f"""
-        Eres un experto en biotecnología y modelado matemático. Analiza estos resultados de ajuste de modelos cinéticos/biotecnológicos.
-        
-        NIVEL DE DETALLE SOLICITADO: {detail_level}
-        
-        REALIZA UN ANÁLISIS COMPARATIVO EXHAUSTIVO:
-        
-        1. **IDENTIFICACIÓN Y CLASIFICACIÓN DE MODELOS**
-           - Identifica TODOS los modelos matemáticos ajustados
-           - Clasifícalos por tipo: biomasa, sustrato, producto
-           - Indica la ecuación matemática de cada modelo si es posible inferirla
-        
-        2. **ANÁLISIS COMPARATIVO DE CALIDAD DE AJUSTE**
-           - Compara TODOS los indicadores disponibles: R², RMSE, AIC, BIC, etc.
-           - Crea un ranking ordenado de mejor a peor modelo
-           - Identifica diferencias significativas entre modelos
-           - Detecta posible sobreajuste o subajuste
-        
-        3. **DETERMINACIÓN DEL MEJOR MODELO**
-           - Selecciona el MEJOR modelo basándote en MÚLTIPLES criterios:
-             * Mayor R² (más cercano a 1)
-             * Menor RMSE/MSE
-             * Menor AIC/BIC (si están disponibles)
-             * Parsimonia (menos parámetros si el ajuste es similar)
-           - Justifica NUMÉRICAMENTE por qué es el mejor
-           - Si hay empate técnico, explica las ventajas de cada uno
-        
-        4. **ANÁLISIS ESPECÍFICO POR TIPO DE VARIABLE**
-           a) **BIOMASA (si aplica)**:
-              - Parámetros de crecimiento (μmax, Xmax, etc.)
-              - Tiempo de duplicación
-              - Productividad de biomasa
-              - Comparación numérica entre modelos
+        {lang_prefix}
+        
+        You are an expert in biotechnology and mathematical modeling. Analyze these kinetic/biotechnological model fitting results.
+        
+        REQUESTED DETAIL LEVEL: {detail_level}
+        
+        PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS:
+        
+        1. **MODEL IDENTIFICATION AND CLASSIFICATION**
+           - Identify ALL fitted mathematical models
+           - Classify them by type: biomass, substrate, product
+           - Indicate the mathematical equation of each model if possible
+        
+        2. **COMPARATIVE ANALYSIS OF FIT QUALITY**
+           - Compare ALL available indicators: R², RMSE, AIC, BIC, etc.
+           - Create a ranking from best to worst model
+           - Identify significant differences between models
+           - Detect possible overfitting or underfitting
+        
+        3. **DETERMINATION OF THE BEST MODEL**
+           - Select the BEST model based on MULTIPLE criteria:
+             * Highest R² (closest to 1)
+             * Lowest RMSE/MSE
+             * Lowest AIC/BIC (if available)
+             * Parsimony (fewer parameters if fit is similar)
+           - Justify NUMERICALLY why it is the best
+           - If there's a technical tie, explain the advantages of each
+        
+        4. **SPECIFIC ANALYSIS BY VARIABLE TYPE**
+           a) **BIOMASS (if applicable)**:
+              - Growth parameters (μmax, Xmax, etc.)
+              - Doubling time
+              - Biomass productivity
+              - Numerical comparison between models
            
-           b) **SUSTRATO (si aplica)**:
-              - Constantes de afinidad (Ks, Km)
-              - Velocidades de consumo
-              - Rendimiento Yx/s
-              - Eficiencia de utilización
+           b) **SUBSTRATE (if applicable)**:
+              - Affinity constants (Ks, Km)
+              - Consumption rates
+              - Yield Yx/s
+              - Utilization efficiency
            
-           c) **PRODUCTO (si aplica)**:
-              - Parámetros de producción (α, β)
-              - Productividad específica
-              - Rendimiento Yp/x
-              - Tipo de producción (asociada/no asociada)
-        
-        5. **INTERPRETACIÓN BIOLÓGICA DE PARÁMETROS**
-           - Explica qué significa CADA parámetro biológicamente
-           - Compara valores entre modelos
-           - Evalúa si son realistas para el sistema
-           - Identifica parámetros críticos del proceso
-        
-        6. **CONCLUSIONES CON CONTENIDO NUMÉRICO**
-           - Resume los hallazgos clave con NÚMEROS específicos
-           - Proporciona rangos de confianza si están disponibles
-           - Indica condiciones óptimas de operación
-           - Sugiere valores de diseño para escalamiento
-        
-        7. **RECOMENDACIONES PRÁCTICAS**
-           - Qué modelo(s) usar para predicción
-           - Limitaciones del modelo seleccionado
-           - Experimentos adicionales recomendados
-           - Consideraciones para implementación industrial
-        
-        8. **TABLA COMPARATIVA FINAL**
-           Crea una tabla resumen con:
-           - Modelo | R² | RMSE | AIC/BIC | Parámetros clave | Ranking
-        
-        FORMATO DE RESPUESTA:
-        - Si el nivel es "detallado": incluye TODOS los puntos con explicaciones completas
-        - Si el nivel es "resumido": enfócate en puntos 3, 6 y 8 con valores numéricos clave
-        
-        Usa formato Markdown con:
-        - Títulos y subtítulos claros
-        - **Negritas** para valores importantes
-        - Tablas cuando sea apropiado
-        - Listas numeradas y con viñetas
-        
-        IMPORTANTE: Basa TODAS las conclusiones en los NÚMEROS específicos de los datos proporcionados.
+           c) **PRODUCT (if applicable)**:
+              - Production parameters (α, β)
+              - Specific productivity
+              - Yield Yp/x
+              - Production type (associated/non-associated)
+        
+        5. **BIOLOGICAL INTERPRETATION OF PARAMETERS**
+           - Explain what EACH parameter means biologically
+           - Compare values between models
+           - Evaluate if they are realistic for the system
+           - Identify critical process parameters
+        
+        6. **CONCLUSIONS WITH NUMERICAL CONTENT**
+           - Summarize key findings with SPECIFIC NUMBERS
+           - Provide confidence intervals if available
+           - Indicate optimal operating conditions
+           - Suggest design values for scale-up
+        
+        7. **PRACTICAL RECOMMENDATIONS**
+           - Which model(s) to use for prediction
+           - Limitations of the selected model
+           - Recommended additional experiments
+           - Considerations for industrial implementation
+        
+        8. **FINAL COMPARATIVE TABLE**
+           Create a summary table with:
+           - Model | R² | RMSE | AIC/BIC | Key Parameters | Ranking
+        
+        RESPONSE FORMAT:
+        - If level is "detailed": include ALL points with complete explanations
+        - If level is "summarized": focus on points 3, 6 and 8 with key numerical values
+        
+        Use Markdown format with:
+        - Clear titles and subtitles
+        - **Bold** for important values
+        - Tables when appropriate
+        - Numbered and bulleted lists
+        
+        IMPORTANT: Base ALL conclusions on the SPECIFIC NUMBERS from the provided data.
         """
         
         try:
@@ -451,24 +683,26 @@ class AIAnalyzer:
                 }]
             )
             
-            # Análisis adicional para generar código si es necesario
-            code_prompt = """
-            Basándote en el análisis anterior, genera código Python para:
+            # Análisis adicional para generar código
+            code_prompt = f"""
+            {lang_prefix}
             
-            1. Cargar y visualizar estos resultados de ajuste
-            2. Crear gráficos comparativos de modelos (barras para R², RMSE)
-            3. Implementar el mejor modelo identificado
-            4. Generar predicciones con el modelo seleccionado
-            5. Análisis de sensibilidad de parámetros
+            Based on the previous analysis, generate Python code for:
             
-            Incluye:
-            - Imports necesarios
-            - Funciones bien documentadas
-            - Visualizaciones profesionales
-            - Manejo de errores
-            - Ejemplo de uso
+            1. Load and visualize these fitting results
+            2. Create comparative model graphs (bars for R², RMSE)
+            3. Implement the best identified model
+            4. Generate predictions with the selected model
+            5. Parameter sensitivity analysis
             
-            El código debe ser ejecutable y modular.
+            Include:
+            - Necessary imports
+            - Well-documented functions
+            - Professional visualizations
+            - Error handling
+            - Usage example
+            
+            The code should be executable and modular.
             """
             
             code_response = self.client.messages.create(
@@ -476,12 +710,12 @@ class AIAnalyzer:
                 max_tokens=3000,
                 messages=[{
                     "role": "user",
-                    "content": f"{code_prompt}\n\nBasado en estos modelos:\n{response.content[0].text[:1000]}"
+                    "content": f"{code_prompt}\n\nBased on these models:\n{response.content[0].text[:1000]}"
                 }]
             )
             
             return {
-                "tipo": "Análisis Comparativo de Modelos Matemáticos",
+                "tipo": "Comparative Analysis of Mathematical Models",
                 "analisis_completo": response.content[0].text,
                 "codigo_implementacion": code_response.content[0].text,
                 "resumen_datos": {
@@ -497,8 +731,8 @@ class AIAnalyzer:
         except Exception as e:
             return {"error": str(e)}
 
-def process_files(files, claude_model: str, detail_level: str = "detallado") -> Tuple[str, str]:
-    """Procesa múltiples archivos"""
+def process_files(files, claude_model: str, detail_level: str = "detailed", language: str = "en") -> Tuple[str, str]:
+    """Procesa múltiples archivos con soporte de idioma"""
     processor = FileProcessor()
     analyzer = AIAnalyzer(client, model_registry)
     results = []
@@ -514,61 +748,11 @@ def process_files(files, claude_model: str, detail_level: str = "detallado") ->
         with open(file.name, 'rb') as f:
             file_content = f.read()
         
-        if file_ext == '.zip':
-            extracted_files = processor.extract_from_zip(file_content)
-            results.append(f"## 📦 Archivo ZIP: {file_name}")
-            results.append(f"Contiene {len(extracted_files)} archivos\n")
-            
-            for name, content in extracted_files:
-                sub_ext = Path(name).suffix.lower()
-                results.append(f"### 📄 {name}")
-                
-                if sub_ext == '.pdf':
-                    text = processor.extract_text_from_pdf(content)
-                    analysis_type = analyzer.detect_analysis_type(text)
-                    
-                    if analysis_type == AnalysisType.MATHEMATICAL_MODEL:
-                        result = analyzer.analyze_mathematical_article(text, claude_model)
-                    else:
-                        result = {"tipo": "PDF no reconocido", "contenido": text[:500]}
-                    
-                    results.append(result.get("analisis_completo", json.dumps(result, indent=2, ensure_ascii=False)))
-                
-                elif sub_ext in ['.csv', '.xlsx', '.xls']:
-                    if sub_ext == '.csv':
-                        df = processor.read_csv(content)
-                    else:
-                        df = processor.read_excel(content)
-                    
-                    if df is not None:
-                        analysis_type = analyzer.detect_analysis_type(df)
-                        
-                        if analysis_type == AnalysisType.FITTING_RESULTS:
-                            result = analyzer.analyze_fitting_results(df, claude_model, detail_level)
-                            results.append(result.get("analisis_completo", ""))
-                            if "codigo_implementacion" in result:
-                                all_code.append(result["codigo_implementacion"])
-                        else:
-                            result = analyzer.analyze_fitting_data(df, claude_model)
-                            results.append(result.get("analisis", ""))
-                
-                results.append("\n---\n")
-        
-        elif file_ext == '.pdf':
-            text = processor.extract_text_from_pdf(file_content)
-            analysis_type = analyzer.detect_analysis_type(text)
-            
-            results.append(f"## 📄 PDF: {file_name}")
-            
-            if analysis_type == AnalysisType.MATHEMATICAL_MODEL:
-                result = analyzer.analyze_mathematical_article(text, claude_model)
-                results.append(result.get("modelos", "") + "\n" + result.get("recomendaciones", ""))
+        if file_ext in ['.csv', '.xlsx', '.xls']:
+            if language == 'es':
+                results.append(f"## 📊 Análisis de Resultados: {file_name}")
             else:
-                result = {"tipo": "PDF - Contenido no identificado", "texto": text[:1000]}
-                results.append(json.dumps(result, indent=2, ensure_ascii=False))
-        
-        elif file_ext in ['.csv', '.xlsx', '.xls']:
-            results.append(f"## 📊 Análisis de Resultados: {file_name}")
+                results.append(f"## 📊 Results Analysis: {file_name}")
             
             if file_ext == '.csv':
                 df = processor.read_csv(file_content)
@@ -579,15 +763,16 @@ def process_files(files, claude_model: str, detail_level: str = "detallado") ->
                 analysis_type = analyzer.detect_analysis_type(df)
                 
                 if analysis_type == AnalysisType.FITTING_RESULTS:
-                    result = analyzer.analyze_fitting_results(df, claude_model, detail_level)
-                    results.append("### 🎯 ANÁLISIS COMPARATIVO DE MODELOS MATEMÁTICOS")
+                    result = analyzer.analyze_fitting_results(df, claude_model, detail_level, language)
+                    
+                    if language == 'es':
+                        results.append("### 🎯 ANÁLISIS COMPARATIVO DE MODELOS MATEMÁTICOS")
+                    else:
+                        results.append("### 🎯 COMPARATIVE ANALYSIS OF MATHEMATICAL MODELS")
+                    
                     results.append(result.get("analisis_completo", ""))
                     if "codigo_implementacion" in result:
                         all_code.append(result["codigo_implementacion"])
-                else:
-                    result = analyzer.analyze_fitting_data(df, claude_model)
-                    results.append("### 📈 ANÁLISIS DE DATOS EXPERIMENTALES")
-                    results.append(result.get("analisis", ""))
         
         results.append("\n---\n")
     
@@ -597,7 +782,7 @@ def process_files(files, claude_model: str, detail_level: str = "detallado") ->
     return analysis_text, code_text
 
 def generate_implementation_code(analysis_results: str) -> str:
-    """Genera código de implementación basado en el análisis"""
+    """Genera código de implementación"""
     code = """
 import numpy as np
 import pandas as pd
@@ -608,14 +793,14 @@ from sklearn.metrics import r2_score, mean_squared_error
 import seaborn as sns
 from typing import Dict, List, Tuple, Optional
 
-# Configuración de visualización
+# Visualization configuration
 plt.style.use('seaborn-v0_8-darkgrid')
 sns.set_palette("husl")
 
 class ComparativeModelAnalyzer:
     \"\"\"
-    Clase para análisis comparativo de resultados de ajuste de modelos biotecnológicos.
-    Especializada en comparar modelos de biomasa, sustrato y producto.
+    Class for comparative analysis of biotechnological model fitting results.
+    Specialized in comparing biomass, substrate and product models.
     \"\"\"
     
     def __init__(self):
@@ -624,14 +809,14 @@ class ComparativeModelAnalyzer:
         self.model_rankings = {}
         
     def load_results(self, file_path: str) -> pd.DataFrame:
-        \"\"\"Carga resultados de ajuste desde archivo CSV o Excel\"\"\"
+        \"\"\"Load fitting results from CSV or Excel file\"\"\"
         if file_path.endswith('.csv'):
             self.results_df = pd.read_csv(file_path)
         else:
             self.results_df = pd.read_excel(file_path)
         
-        print(f"✅ Datos cargados: {len(self.results_df)} modelos")
-        print(f"📊 Columnas disponibles: {list(self.results_df.columns)}")
+        print(f"✅ Data loaded: {len(self.results_df)} models")
+        print(f"📊 Available columns: {list(self.results_df.columns)}")
         
         return self.results_df
     
@@ -642,40 +827,40 @@ class ComparativeModelAnalyzer:
                             bic_col: Optional[str] = 'BIC',
                             model_col: str = 'Model') -> pd.DataFrame:
         \"\"\"
-        Analiza y compara la calidad de ajuste de todos los modelos.
-        Crea un ranking basado en múltiples métricas.
+        Analyze and compare the fit quality of all models.
+        Create a ranking based on multiple metrics.
         \"\"\"
         if self.results_df is None:
-            raise ValueError("Primero carga los datos con load_results()")
+            raise ValueError("First load data with load_results()")
         
-        # Crear DataFrame de comparación
+        # Create comparison DataFrame
         comparison = self.results_df.copy()
         
-        # Calcular puntuación compuesta
+        # Calculate composite score
         scores = pd.DataFrame(index=comparison.index)
         
-        # Normalizar métricas (0-1)
+        # Normalize metrics (0-1)
         if r2_col in comparison.columns:
-            scores['r2_score'] = comparison[r2_col]  # Ya está entre 0-1
+            scores['r2_score'] = comparison[r2_col]  # Already between 0-1
         
         if rmse_col in comparison.columns:
-            # Invertir y normalizar RMSE (menor es mejor)
+            # Invert and normalize RMSE (lower is better)
             max_rmse = comparison[rmse_col].max()
             scores['rmse_score'] = 1 - (comparison[rmse_col] / max_rmse)
         
         if aic_col and aic_col in comparison.columns:
-            # Invertir y normalizar AIC (menor es mejor)
+            # Invert and normalize AIC (lower is better)
             min_aic = comparison[aic_col].min()
             max_aic = comparison[aic_col].max()
             scores['aic_score'] = 1 - ((comparison[aic_col] - min_aic) / (max_aic - min_aic))
         
         if bic_col and bic_col in comparison.columns:
-            # Invertir y normalizar BIC (menor es mejor)
+            # Invert and normalize BIC (lower is better)
             min_bic = comparison[bic_col].min()
             max_bic = comparison[bic_col].max()
             scores['bic_score'] = 1 - ((comparison[bic_col] - min_bic) / (max_bic - min_bic))
         
-        # Calcular puntuación total (promedio ponderado)
+        # Calculate total score (weighted average)
         weights = {
             'r2_score': 0.4,
             'rmse_score': 0.3,
@@ -688,23 +873,23 @@ class ComparativeModelAnalyzer:
             if metric in scores.columns:
                 scores['total_score'] += scores[metric] * weight
         
-        # Añadir puntuación al DataFrame de comparación
+        # Add score to comparison DataFrame
         comparison['Score'] = scores['total_score']
         comparison['Ranking'] = comparison['Score'].rank(ascending=False).astype(int)
         
-        # Ordenar por ranking
+        # Sort by ranking
         comparison = comparison.sort_values('Ranking')
         
-        # Identificar mejor modelo
+        # Identify best model
         best_idx = comparison['Score'].idxmax()
         self.best_models['overall'] = comparison.loc[best_idx]
         
-        # Imprimir tabla de comparación
+        # Print comparison table
         print("\\n" + "="*80)
-        print("📊 TABLA COMPARATIVA DE MODELOS")
+        print("📊 MODEL COMPARISON TABLE")
         print("="*80)
         
-        print(f"\\n{'Rank':<6} {'Modelo':<20} {'R²':<8} {'RMSE':<10} {'AIC':<10} {'BIC':<10} {'Score':<8}")
+        print(f"\\n{'Rank':<6} {'Model':<20} {'R²':<8} {'RMSE':<10} {'AIC':<10} {'BIC':<10} {'Score':<8}")
         print("-"*80)
         
         for idx, row in comparison.iterrows():
@@ -727,369 +912,134 @@ class ComparativeModelAnalyzer:
                 print(f"{'N/A':<10} ", end="")
             print(f"{score:<8.4f}")
         
-        print("\\n🏆 MEJOR MODELO: " + comparison.iloc[0].get(model_col, 'No especificado'))
+        print("\\n🏆 BEST MODEL: " + comparison.iloc[0].get(model_col, 'Not specified'))
         print(f"   - R² = {comparison.iloc[0].get(r2_col, 0):.4f}")
         print(f"   - RMSE = {comparison.iloc[0].get(rmse_col, 0):.4f}")
         
         self.model_rankings = comparison
         return comparison
-    
-    def analyze_by_category(self, category_col: Optional[str] = None) -> Dict:
-        \"\"\"
-        Analiza modelos por categoría (biomasa, sustrato, producto).
-        Si no hay columna de categoría, intenta inferir del nombre del modelo.
-        \"\"\"
-        if self.results_df is None:
-            raise ValueError("Primero carga los datos")
-        
-        categories = {}
-        
-        if category_col and category_col in self.results_df.columns:
-            # Usar columna de categoría existente
-            for cat in self.results_df[category_col].unique():
-                cat_data = self.results_df[self.results_df[category_col] == cat]
-                categories[cat] = cat_data
-        else:
-            # Inferir categorías del nombre del modelo
-            biomass_keywords = ['monod', 'logistic', 'gompertz', 'baranyi', 'growth']
-            substrate_keywords = ['michaelis', 'menten', 'substrate', 'consumption']
-            product_keywords = ['luedeking', 'piret', 'product', 'formation']
-            
-            for idx, row in self.results_df.iterrows():
-                model_name = str(row.get('Model', '')).lower()
-                
-                if any(kw in model_name for kw in biomass_keywords):
-                    if 'biomasa' not in categories:
-                        categories['biomasa'] = []
-                    categories['biomasa'].append(row)
-                elif any(kw in model_name for kw in substrate_keywords):
-                    if 'sustrato' not in categories:
-                        categories['sustrato'] = []
-                    categories['sustrato'].append(row)
-                elif any(kw in model_name for kw in product_keywords):
-                    if 'producto' not in categories:
-                        categories['producto'] = []
-                    categories['producto'].append(row)
-                else:
-                    if 'otros' not in categories:
-                        categories['otros'] = []
-                    categories['otros'].append(row)
-        
-        # Convertir listas a DataFrames
-        for cat in categories:
-            if isinstance(categories[cat], list):
-                categories[cat] = pd.DataFrame(categories[cat])
-        
-        # Analizar cada categoría
-        print("\\n" + "="*80)
-        print("📈 ANÁLISIS POR CATEGORÍA")
-        print("="*80)
-        
-        for cat, data in categories.items():
-            if len(data) > 0:
-                print(f"\\n### {cat.upper()}")
-                print(f"Modelos analizados: {len(data)}")
-                
-                if 'R2' in data.columns:
-                    best_idx = data['R2'].idxmax()
-                    best_model = data.loc[best_idx]
-                    
-                    print(f"Mejor modelo: {best_model.get('Model', 'N/A')}")
-                    print(f"  - R² = {best_model.get('R2', 0):.4f}")
-                    print(f"  - RMSE = {best_model.get('RMSE', 0):.4f}")
-                    
-                    self.best_models[cat] = best_model
-        
-        return categories
-    
-    def plot_comparison(self, save_path: Optional[str] = None) -> plt.Figure:
-        \"\"\"
-        Genera visualizaciones comparativas de los modelos.
-        \"\"\"
-        if self.model_rankings is None:
-            raise ValueError("Primero ejecuta analyze_model_quality()")
-        
-        fig = plt.figure(figsize=(16, 10))
-        
-        # Configurar grid de subplots
-        gs = fig.add_gridspec(3, 2, height_ratios=[1, 1, 1], hspace=0.3, wspace=0.3)
-        
-        # 1. Gráfico de barras R²
-        ax1 = fig.add_subplot(gs[0, 0])
-        models = self.model_rankings.get('Model', range(len(self.model_rankings)))
-        r2_values = self.model_rankings.get('R2', [])
-        
-        bars1 = ax1.bar(range(len(models)), r2_values, color='skyblue', edgecolor='navy', alpha=0.7)
-        ax1.set_title('Comparación de R² por Modelo', fontsize=14, fontweight='bold')
-        ax1.set_ylabel('R² (Coeficiente de Determinación)', fontsize=12)
-        ax1.set_ylim(0, 1.05)
-        ax1.set_xticks(range(len(models)))
-        ax1.set_xticklabels(models, rotation=45, ha='right')
-        ax1.grid(True, alpha=0.3)
-        
-        # Añadir valores en las barras
-        for bar, val in zip(bars1, r2_values):
-            height = bar.get_height()
-            ax1.text(bar.get_x() + bar.get_width()/2., height + 0.01,
-                    f'{val:.3f}', ha='center', va='bottom', fontsize=9)
-        
-        # 2. Gráfico de barras RMSE
-        ax2 = fig.add_subplot(gs[0, 1])
-        rmse_values = self.model_rankings.get('RMSE', [])
-        
-        bars2 = ax2.bar(range(len(models)), rmse_values, color='lightcoral', edgecolor='darkred', alpha=0.7)
-        ax2.set_title('Comparación de RMSE por Modelo', fontsize=14, fontweight='bold')
-        ax2.set_ylabel('RMSE (Error Cuadrático Medio)', fontsize=12)
-        ax2.set_xticks(range(len(models)))
-        ax2.set_xticklabels(models, rotation=45, ha='right')
-        ax2.grid(True, alpha=0.3)
-        
-        # 3. Gráfico de puntuación total
-        ax3 = fig.add_subplot(gs[1, :])
-        scores = self.model_rankings.get('Score', [])
-        rankings = self.model_rankings.get('Ranking', [])
-        
-        # Crear gradiente de colores basado en ranking
-        colors = plt.cm.RdYlGn(1 - (rankings - 1) / (len(rankings) - 1))
-        
-        bars3 = ax3.bar(range(len(models)), scores, color=colors, edgecolor='black', alpha=0.8)
-        ax3.set_title('Puntuación Total Compuesta (Mayor es Mejor)', fontsize=16, fontweight='bold')
-        ax3.set_ylabel('Puntuación Total', fontsize=12)
-        ax3.set_xticks(range(len(models)))
-        ax3.set_xticklabels(models, rotation=45, ha='right')
-        ax3.grid(True, alpha=0.3)
-        
-        # Marcar el mejor modelo
-        best_idx = scores.argmax()
-        bars3[best_idx].set_linewidth(3)
-        bars3[best_idx].set_edgecolor('gold')
-        
-        # 4. Tabla de métricas
-        ax4 = fig.add_subplot(gs[2, :])
-        ax4.axis('tight')
-        ax4.axis('off')
-        
-        # Preparar datos para la tabla
-        table_data = []
-        for idx, row in self.model_rankings.head(5).iterrows():
-            table_data.append([
-                row.get('Ranking', ''),
-                row.get('Model', '')[:20],
-                f"{row.get('R2', 0):.4f}",
-                f"{row.get('RMSE', 0):.4f}",
-                f"{row.get('AIC', 'N/A'):.2f}" if isinstance(row.get('AIC'), (int, float)) else 'N/A',
-                f"{row.get('BIC', 'N/A'):.2f}" if isinstance(row.get('BIC'), (int, float)) else 'N/A',
-                f"{row.get('Score', 0):.4f}"
-            ])
-        
-        table = ax4.table(cellText=table_data,
-                         colLabels=['Rank', 'Modelo', 'R²', 'RMSE', 'AIC', 'BIC', 'Score'],
-                         cellLoc='center',
-                         loc='center',
-                         colWidths=[0.08, 0.25, 0.12, 0.12, 0.12, 0.12, 0.12])
-        
-        table.auto_set_font_size(False)
-        table.set_fontsize(10)
-        table.scale(1.2, 1.5)
-        
-        # Colorear la primera fila (mejor modelo)
-        for j in range(len(table_data[0])):
-            table[(1, j)].set_facecolor('#90EE90')
-        
-        ax4.set_title('Top 5 Modelos - Tabla Resumen', fontsize=14, fontweight='bold', pad=20)
-        
-        plt.suptitle('Análisis Comparativo de Modelos Biotecnológicos', fontsize=18, fontweight='bold')
-        
-        if save_path:
-            plt.savefig(save_path, dpi=300, bbox_inches='tight')
-            print(f"\\n💾 Gráfico guardado en: {save_path}")
-        
-        return fig
-    
-    def generate_report(self, output_file: str = 'informe_comparativo.txt'):
-        \"\"\"
-        Genera un informe detallado con todas las conclusiones numéricas.
-        \"\"\"
-        if self.model_rankings is None:
-            raise ValueError("Primero ejecuta analyze_model_quality()")
-        
-        report = []
-        report.append("="*80)
-        report.append("INFORME DE ANÁLISIS COMPARATIVO DE MODELOS MATEMÁTICOS")
-        report.append("="*80)
-        report.append(f"\\nFecha: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        report.append(f"Número de modelos analizados: {len(self.results_df)}")
-        
-        # Resumen ejecutivo
-        report.append("\\n" + "-"*40)
-        report.append("RESUMEN EJECUTIVO")
-        report.append("-"*40)
-        
-        best_model = self.model_rankings.iloc[0]
-        report.append(f"\\nMEJOR MODELO GLOBAL: {best_model.get('Model', 'N/A')}")
-        report.append(f"  - R² = {best_model.get('R2', 0):.4f} (explica {best_model.get('R2', 0)*100:.1f}% de la variabilidad)")
-        report.append(f"  - RMSE = {best_model.get('RMSE', 0):.4f}")
-        
-        if 'AIC' in best_model:
-            report.append(f"  - AIC = {best_model.get('AIC'):.2f}")
-        if 'BIC' in best_model:
-            report.append(f"  - BIC = {best_model.get('BIC'):.2f}")
-        
-        # Análisis detallado
-        report.append("\\n" + "-"*40)
-        report.append("ANÁLISIS DETALLADO POR MODELO")
-        report.append("-"*40)
-        
-        for idx, row in self.model_rankings.iterrows():
-            report.append(f"\\n{row.get('Ranking')}. {row.get('Model', 'N/A')}")
-            report.append(f"   Métricas de ajuste:")
-            report.append(f"   - R² = {row.get('R2', 0):.4f}")
-            report.append(f"   - RMSE = {row.get('RMSE', 0):.4f}")
-            
-            # Interpretación
-            r2_val = row.get('R2', 0)
-            if r2_val > 0.95:
-                quality = "EXCELENTE"
-            elif r2_val > 0.90:
-                quality = "MUY BUENO"
-            elif r2_val > 0.80:
-                quality = "BUENO"
-            elif r2_val > 0.70:
-                quality = "ACEPTABLE"
-            else:
-                quality = "POBRE"
-            
-            report.append(f"   - Calidad del ajuste: {quality}")
-        
-        # Análisis por categorías si está disponible
-        if hasattr(self, 'best_models') and len(self.best_models) > 1:
-            report.append("\\n" + "-"*40)
-            report.append("MEJORES MODELOS POR CATEGORÍA")
-            report.append("-"*40)
-            
-            for cat, model in self.best_models.items():
-                if cat != 'overall':
-                    report.append(f"\\n{cat.upper()}:")
-                    report.append(f"  Mejor modelo: {model.get('Model', 'N/A')}")
-                    report.append(f"  - R² = {model.get('R2', 0):.4f}")
-                    report.append(f"  - RMSE = {model.get('RMSE', 0):.4f}")
-        
-        # Recomendaciones
-        report.append("\\n" + "-"*40)
-        report.append("RECOMENDACIONES")
-        report.append("-"*40)
-        
-        report.append(f"\\n1. Para predicciones generales, usar: {best_model.get('Model', 'N/A')}")
-        report.append("2. Validar con conjunto de datos independiente")
-        report.append("3. Considerar análisis de residuos")
-        report.append("4. Evaluar estabilidad de parámetros")
-        
-        # Guardar informe
-        with open(output_file, 'w', encoding='utf-8') as f:
-            f.write("\\n".join(report))
-        
-        print(f"\\n📄 Informe guardado en: {output_file}")
-        
-        return "\\n".join(report)
-
-# Implementación de modelos específicos
-class BiotechModels:
-    \"\"\"Biblioteca de modelos biotecnológicos comunes\"\"\"
-    
-    @staticmethod
-    def monod(S, mu_max, Ks):
-        \"\"\"Modelo de Monod para crecimiento\"\"\"
-        return mu_max * S / (Ks + S)
-    
-    @staticmethod
-    def logistic(t, K, r, t0):
-        \"\"\"Modelo logístico\"\"\"
-        return K / (1 + np.exp(-r * (t - t0)))
-    
-    @staticmethod
-    def gompertz(t, A, mu, lambda_param):
-        \"\"\"Modelo de Gompertz\"\"\"
-        return A * np.exp(-np.exp(mu * np.e / A * (lambda_param - t) + 1))
-    
-    @staticmethod
-    def michaelis_menten(S, Vmax, Km):
-        \"\"\"Modelo de Michaelis-Menten\"\"\"
-        return Vmax * S / (Km + S)
-    
-    @staticmethod
-    def luedeking_piret_integrated(t, X0, mu_max, alpha, beta):
-        \"\"\"Modelo de Luedeking-Piret integrado\"\"\"
-        X = X0 * np.exp(mu_max * t)
-        P = alpha * (X - X0) + beta * X0 * (np.exp(mu_max * t) - 1) / mu_max
-        return P
 
-# Ejemplo de uso
+# Example usage
 if __name__ == "__main__":
-    print("🧬 Sistema de Análisis Comparativo de Modelos Biotecnológicos")
+    print("🧬 Biotechnological Model Comparative Analysis System")
     print("="*60)
     
-    # Crear analizador
+    # Create analyzer
     analyzer = ComparativeModelAnalyzer()
     
-    # Instrucciones
-    print("\\n📋 INSTRUCCIONES DE USO:")
-    print("1. analyzer.load_results('tu_archivo.csv')")
+    # Instructions
+    print("\\n📋 USAGE INSTRUCTIONS:")
+    print("1. analyzer.load_results('your_file.csv')")
     print("2. analyzer.analyze_model_quality()")
-    print("3. analyzer.analyze_by_category()")
-    print("4. analyzer.plot_comparison()")
-    print("5. analyzer.generate_report()")
+    print("3. analyzer.plot_comparison()")
+    print("4. analyzer.generate_report()")
     
-    print("\\n✨ ¡Sistema listo para análisis!")
+    print("\\n✨ System ready for analysis!")
 """
     
     return code
 
-# Interfaz Gradio optimizada
-def create_interface():
-    with gr.Blocks(
-        title="Analizador Comparativo de Modelos Biotecnológicos",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container {
-            font-family: 'Arial', sans-serif;
-        }
-        .highlight-results {
-            background-color: #f0f8ff;
-            padding: 15px;
-            border-radius: 10px;
-            border-left: 5px solid #4CAF50;
+# Estado global para almacenar resultados
+class AppState:
+    def __init__(self):
+        self.current_analysis = ""
+        self.current_code = ""
+        self.current_language = "en"
+
+app_state = AppState()
+
+def export_report(export_format: str, language: str) -> Tuple[str, str]:
+    """Exporta el reporte al formato seleccionado"""
+    if not app_state.current_analysis:
+        error_msg = {
+            'en': "No analysis available to export",
+            'es': "No hay análisis disponible para exportar",
+            'fr': "Aucune analyse disponible pour exporter",
+            'de': "Keine Analyse zum Exportieren verfügbar",
+            'pt': "Nenhuma análise disponível para exportar"
         }
-        .comparison-table {
-            background-color: #f9f9f9;
-            padding: 10px;
-            border-radius: 8px;
-            font-family: monospace;
+        return error_msg.get(language, error_msg['en']), ""
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    try:
+        if export_format == "DOCX":
+            filename = f"biotech_analysis_report_{timestamp}.docx"
+            ReportExporter.export_to_docx(app_state.current_analysis, filename, language)
+        else:  # PDF
+            filename = f"biotech_analysis_report_{timestamp}.pdf"
+            ReportExporter.export_to_pdf(app_state.current_analysis, filename, language)
+        
+        success_msg = TRANSLATIONS[language]['report_exported']
+        return f"{success_msg} {filename}", filename
+    except Exception as e:
+        return f"Error: {str(e)}", ""
+
+# Interfaz Gradio con soporte multiidioma y temas
+def create_interface():
+    # Estado inicial
+    current_theme = "light"
+    current_language = "en"
+    
+    def update_interface_language(language):
+        """Actualiza el idioma de la interfaz"""
+        app_state.current_language = language
+        t = TRANSLATIONS[language]
+        
+        return {
+            title_text: gr.update(value=f"# {t['title']}"),
+            subtitle_text: gr.update(value=t['subtitle']),
+            files_input: gr.update(label=t['upload_files']),
+            model_selector: gr.update(label=t['select_model']),
+            language_selector: gr.update(label=t['select_language']),
+            theme_selector: gr.update(label=t['select_theme']),
+            detail_level: gr.update(label=t['detail_level']),
+            analyze_btn: gr.update(value=t['analyze_button']),
+            export_format: gr.update(label=t['export_format']),
+            export_btn: gr.update(value=t['export_button']),
+            analysis_output: gr.update(label=t['comparative_analysis']),
+            code_output: gr.update(label=t['implementation_code']),
+            examples_label: gr.update(label=t['examples']),
+            data_format_accordion: gr.update(label=t['data_format'])
         }
-        """
-    ) as demo:
-        
-        gr.Markdown("""
-        # 🧬 Analizador Comparativo de Modelos Biotecnológicos
-        
-        ### 🎯 Especializado en:
-        - **Análisis comparativo** de resultados de ajuste de modelos matemáticos
-        - **Determinación del mejor modelo** con justificación numérica
-        - **Análisis específico** para biomasa, sustrato y producto
-        - **Conclusiones numéricas** detalladas y ordenadas
-        - **Generación de código** para implementación y análisis
-        
-        ### 📊 Métricas analizadas:
-        - R² (Coeficiente de determinación)
-        - RMSE (Error cuadrático medio)
-        - AIC/BIC (Criterios de información)
-        - Parámetros específicos del modelo
-        - Intervalos de confianza
-        """)
+    
+    def process_and_store(files, model, detail, language):
+        """Procesa archivos y almacena resultados"""
+        if not files:
+            error_msg = TRANSLATIONS[language]['error_no_files']
+            return error_msg, ""
+        
+        analysis, code = process_files(files, model, detail, language)
+        app_state.current_analysis = analysis
+        app_state.current_code = code
+        return analysis, code
+    
+    with gr.Blocks(theme=THEMES[current_theme]) as demo:
+        # Componentes de UI
+        with gr.Row():
+            with gr.Column(scale=3):
+                title_text = gr.Markdown(f"# {TRANSLATIONS[current_language]['title']}")
+                subtitle_text = gr.Markdown(TRANSLATIONS[current_language]['subtitle'])
+            with gr.Column(scale=1):
+                with gr.Row():
+                    language_selector = gr.Dropdown(
+                        choices=[("English", "en"), ("Español", "es"), ("Français", "fr"), 
+                                ("Deutsch", "de"), ("Português", "pt")],
+                        value="en",
+                        label=TRANSLATIONS[current_language]['select_language'],
+                        interactive=True
+                    )
+                    theme_selector = gr.Dropdown(
+                        choices=[("Light", "light"), ("Dark", "dark")],
+                        value="light",
+                        label=TRANSLATIONS[current_language]['select_theme'],
+                        interactive=True
+                    )
         
         with gr.Row():
             with gr.Column(scale=1):
                 files_input = gr.File(
-                    label="���� Subir resultados de ajuste (CSV/Excel)",
+                    label=TRANSLATIONS[current_language]['upload_files'],
                     file_count="multiple",
                     file_types=[".csv", ".xlsx", ".xls", ".pdf", ".zip"],
                     type="filepath"
@@ -1098,138 +1048,140 @@ def create_interface():
                 model_selector = gr.Dropdown(
                     choices=list(CLAUDE_MODELS.keys()),
                     value="claude-3-5-sonnet-20241022",
-                    label="🤖 Modelo Claude",
-                    info="Selecciona el modelo de IA"
+                    label=TRANSLATIONS[current_language]['select_model'],
+                    info=f"{TRANSLATIONS[current_language]['best_for']}: {CLAUDE_MODELS['claude-3-5-sonnet-20241022']['best_for']}"
                 )
                 
                 detail_level = gr.Radio(
-                    choices=["detallado", "resumido"],
-                    value="detallado",
-                    label="📋 Nivel de detalle del análisis",
-                    info="Detallado: análisis completo | Resumido: puntos clave"
+                    choices=[
+                        (TRANSLATIONS[current_language]['detailed'], "detailed"),
+                        (TRANSLATIONS[current_language]['summarized'], "summarized")
+                    ],
+                    value="detailed",
+                    label=TRANSLATIONS[current_language]['detail_level']
                 )
                 
                 analyze_btn = gr.Button(
-                    "🚀 Analizar y Comparar Modelos",
+                    TRANSLATIONS[current_language]['analyze_button'],
                     variant="primary",
                     size="lg"
                 )
                 
-                # Información del modelo
-                model_info = gr.Markdown()
+                gr.Markdown("---")
                 
-                def update_model_info(model):
-                    info = CLAUDE_MODELS[model]
-                    return f"""
-                    **{info['name']}**
-                    
-                    {info['description']}
-                    
-                    *Mejor para: {info['best_for']}*
-                    """
+                export_format = gr.Radio(
+                    choices=["DOCX", "PDF"],
+                    value="PDF",
+                    label=TRANSLATIONS[current_language]['export_format']
+                )
                 
-                model_selector.change(
-                    update_model_info,
-                    inputs=[model_selector],
-                    outputs=[model_info]
+                export_btn = gr.Button(
+                    TRANSLATIONS[current_language]['export_button'],
+                    variant="secondary"
+                )
+                
+                export_status = gr.Textbox(
+                    label="Export Status",
+                    interactive=False,
+                    visible=False
+                )
+                
+                export_file = gr.File(
+                    label="Download Report",
+                    visible=False
                 )
             
             with gr.Column(scale=2):
                 analysis_output = gr.Markdown(
-                    label="📊 Análisis Comparativo",
-                    elem_classes=["highlight-results"]
+                    label=TRANSLATIONS[current_language]['comparative_analysis']
                 )
                 
                 code_output = gr.Code(
-                    label="💻 Código de Implementación",
+                    label=TRANSLATIONS[current_language]['implementation_code'],
                     language="python",
                     interactive=True,
                     lines=20
                 )
         
-        # Guía de formato de datos
-        with gr.Accordion("📋 Formato de datos esperado", open=False):
+        data_format_accordion = gr.Accordion(
+            label=TRANSLATIONS[current_language]['data_format'],
+            open=False
+        )
+        
+        with data_format_accordion:
             gr.Markdown("""
-            ### Estructura ideal del CSV/Excel:
+            ### Expected CSV/Excel structure:
             
             | Model | R2 | RMSE | AIC | BIC | mu_max | Ks | Parameters |
             |-------|-----|------|-----|-----|--------|-------|------------|
             | Monod | 0.985 | 0.023 | -45.2 | -42.1 | 0.45 | 2.1 | {...} |
             | Logistic | 0.976 | 0.031 | -42.1 | -39.5 | 0.42 | - | {...} |
             | Gompertz | 0.992 | 0.018 | -48.5 | -45.2 | 0.48 | - | {...} |
-            
-            **Columnas mínimas requeridas:**
-            - `Model` o `Modelo`: Nombre del modelo
-            - `R2` o `R_squared`: Coeficiente de determinación
-            - `RMSE` o `MSE`: Error de ajuste
-            
-            **Columnas opcionales pero recomendadas:**
-            - `AIC`, `BIC`: Criterios de información
-            - Parámetros específicos del modelo
-            - `SE` o `Standard_Error`: Errores estándar
-            - `CI_lower`, `CI_upper`: Intervalos de confianza
             """)
         
-        # Ejemplos
-        gr.Examples(
+        examples_label = gr.Examples(
             examples=[
-                [["examples/biomass_models_comparison.csv"], "claude-3-5-sonnet-20241022", "detallado"],
-                [["examples/substrate_kinetics_results.xlsx"], "claude-3-5-sonnet-20241022", "resumido"],
-                [["examples/product_formation_fits.csv"], "claude-3-opus-20240229", "detallado"]
+                [["examples/biomass_models_comparison.csv"], "claude-3-5-sonnet-20241022", "detailed"],
+                [["examples/substrate_kinetics_results.xlsx"], "claude-3-5-sonnet-20241022", "summarized"]
             ],
             inputs=[files_input, model_selector, detail_level],
-            label="📚 Ejemplos de análisis"
+            label=TRANSLATIONS[current_language]['examples']
         )
         
         # Eventos
+        language_selector.change(
+            update_interface_language,
+            inputs=[language_selector],
+            outputs=[
+                title_text, subtitle_text, files_input, model_selector,
+                language_selector, theme_selector, detail_level, analyze_btn,
+                export_format, export_btn, analysis_output, code_output,
+                examples_label, data_format_accordion
+            ]
+        )
+        
+        def change_theme(theme_name):
+            """Cambia el tema de la interfaz"""
+            # Nota: En Gradio actual, cambiar el tema dinámicamente requiere recargar
+            # Esta es una limitación conocida
+            return gr.Info("Theme will be applied on next page load")
+        
+        theme_selector.change(
+            change_theme,
+            inputs=[theme_selector],
+            outputs=[]
+        )
+        
         analyze_btn.click(
-            fn=lambda files, model, detail: process_files(files, model, detail) if files else (
-                "Por favor sube archivos con resultados de ajuste para analizar", 
-                ""
-            ),
-            inputs=[files_input, model_selector, detail_level],
+            fn=process_and_store,
+            inputs=[files_input, model_selector, detail_level, language_selector],
             outputs=[analysis_output, code_output]
         )
         
-        # Footer con información adicional
-        gr.Markdown("""
-        ---
-        ### 🔍 Qué analiza específicamente:
-        
-        1. **Comparación de modelos**: Ranking basado en múltiples métricas
-        2. **Mejor modelo**: Identificación y justificación numérica
-        3. **Análisis por tipo**:
-           - **Biomasa**: μmax, Xmax, tiempo de duplicación
-           - **Sustrato**: Ks, Km, velocidades de consumo, Yx/s
-           - **Producto**: α, β, productividad, Yp/x
-        4. **Significado biológico**: Interpretación de parámetros
-        5. **Conclusiones numéricas**: Valores óptimos, rangos de operación
-        6. **Código Python**: Implementación lista para usar
-        
-        ### 💡 Tips para mejores resultados:
-        - Incluye todas las métricas de ajuste disponibles
-        - Usa nombres descriptivos para los modelos
-        - Incluye errores estándar si están disponibles
-        - Añade información de condiciones experimentales si es relevante
-        """)
-        
-        # Cargar info inicial del modelo
-        demo.load(
-            fn=lambda: update_model_info("claude-3-5-sonnet-20241022"),
-            outputs=[model_info]
+        def handle_export(format, language):
+            status, file = export_report(format, language)
+            if file:
+                return gr.update(value=status, visible=True), gr.update(value=file, visible=True)
+            else:
+                return gr.update(value=status, visible=True), gr.update(visible=False)
+        
+        export_btn.click(
+            fn=handle_export,
+            inputs=[export_format, language_selector],
+            outputs=[export_status, export_file]
         )
     
     return demo
 
-# Función principal para HuggingFace Spaces
+# Función principal
 def main():
     if not os.getenv("ANTHROPIC_API_KEY"):
-        print("⚠️ Configura ANTHROPIC_API_KEY en los secretos de HuggingFace Space")
+        print("⚠️ Configure ANTHROPIC_API_KEY in HuggingFace Space secrets")
         return gr.Interface(
-            fn=lambda x: "Por favor configura ANTHROPIC_API_KEY en los secretos del Space",
+            fn=lambda x: TRANSLATIONS['en']['error_no_api'],
             inputs=gr.Textbox(),
             outputs=gr.Textbox(),
-            title="Error de Configuración"
+            title="Configuration Error"
         )
     
     return create_interface()