Update app.py

app.py

@@ -1,4 +1,5 @@
 import gradio as gr
+import anthropic
 import PyPDF2
 import pandas as pd
 import numpy as np
@@ -25,24 +26,20 @@ from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
 import matplotlib.pyplot as plt
 from datetime import datetime
-from openai import OpenAI
 
 # Configuración para HuggingFace
 os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 
-# Inicializar cliente Qwen
-client = OpenAI(
-    base_url="https://api.studio.nebius.com/v1/",
-    api_key=os.environ.get("NEBIUS_API_KEY")
-)
+# Inicializar cliente Anthropic
+client = anthropic.Anthropic()
 
-# Sistema de traducción
+# Sistema de traducción - Actualizado con nuevas entradas
 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': '🤖 Qwen Model',
+        'select_model': '🤖 Claude Model',
         'select_language': '🌐 Language',
         'select_theme': '🎨 Theme',
         'detail_level': '📋 Analysis detail level',
@@ -59,7 +56,7 @@ TRANSLATIONS = {
         'dark': 'Dark',
         'best_for': 'Best for',
         'loading': 'Loading...',
-        'error_no_api': 'Please configure NEBIUS_API_KEY in HuggingFace Space secrets',
+        '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:',
@@ -67,24 +64,13 @@ TRANSLATIONS = {
         'what_analyzes': '🔍 What it specifically analyzes:',
         'tips': '💡 Tips for better results:',
         'additional_specs': '📝 Additional specifications for analysis',
-        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...',
-        'input_tokens': '🔢 Input tokens (0-1M)',
-        'output_tokens': '🔢 Output tokens (0-1M)',
-        'token_info': 'ℹ️ Token usage information',
-        'input_token_count': 'Input tokens used',
-        'output_token_count': 'Output tokens used',
-        'total_token_count': 'Total tokens used',
-        'token_cost': 'Estimated cost',
-        'thinking_process': '🧠 Thinking Process',
-        'analysis_report': '📊 Analysis Report',
-        'code_output': '💻 Implementation Code',
-        'token_usage': '💰 Token Usage'
+        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...'
     },
     '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 Qwen',
+        'select_model': '🤖 Modelo Claude',
         'select_language': '🌐 Idioma',
         'select_theme': '🎨 Tema',
         'detail_level': '📋 Nivel de detalle del análisis',
@@ -101,7 +87,7 @@ TRANSLATIONS = {
         'dark': 'Oscuro',
         'best_for': 'Mejor para',
         'loading': 'Cargando...',
-        'error_no_api': 'Por favor configura NEBIUS_API_KEY en los secretos del Space',
+        '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:',
@@ -109,18 +95,100 @@ TRANSLATIONS = {
         'what_analyzes': '🔍 Qué analiza específicamente:',
         'tips': '💡 Tips para mejores resultados:',
         'additional_specs': '📝 Especificaciones adicionales para el análisis',
-        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...',
-        'input_tokens': '🔢 Tokens de entrada (0-1M)',
-        'output_tokens': '🔢 Tokens de salida (0-1M)',
-        'token_info': 'ℹ️ Información de uso de tokens',
-        'input_token_count': 'Tokens de entrada usados',
-        'output_token_count': 'Tokens de salida usados',
-        'total_token_count': 'Total de tokens usados',
-        'token_cost': 'Costo estimado',
-        'thinking_process': '🧠 Proceso de Pensamiento',
-        'analysis_report': '📊 Reporte de Análisis',
-        'code_output': '💻 Código de Implementación',
-        'token_usage': '💰 Uso de Tokens'
+        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...'
+    },
+    '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:',
+        'additional_specs': '📝 Spécifications supplémentaires pour l\'analyse',
+        'additional_specs_placeholder': 'Ajoutez des exigences spécifiques ou des domaines d\'intérêt pour l\'analyse...'
+    },
+    '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:',
+        'additional_specs': '📝 Zusätzliche Spezifikationen für die Analyse',
+        'additional_specs_placeholder': 'Fügen Sie spezifische Anforderungen oder Schwerpunktbereiche für die Analyse hinzu...'
+    },
+    '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:',
+        'additional_specs': '📝 Especificações adicionais para a análise',
+        'additional_specs_placeholder': 'Adicione requisitos específicos ou áreas de foco para a análise...'
     }
 }
 
@@ -224,31 +292,37 @@ class ModelRegistry:
 # Instancia global del registro
 model_registry = ModelRegistry()
 
-# Modelos de Qwen disponibles
-QWEN_MODELS = {
-    "Qwen/Qwen3-14B": {
-        "name": "Qwen 3 14B",
-        "description": "Modelo potente multilingüe de Alibaba",
-        "max_tokens": 1000000,
-        "best_for": "Análisis complejos y detallados",
-        "input_cost": 0.0000007,
-        "output_cost": 0.0000021
+# Modelos de Claude disponibles
+CLAUDE_MODELS = {
+    "claude-opus-4-20250514": {
+        "name": "Claude Opus 4 (Latest)",
+        "description": "Modelo más potente para desafíos complejos",
+        "max_tokens": 4000,
+        "best_for": "Análisis muy detallados y complejos"
     },
-    "Qwen/Qwen3-7B": {
-        "name": "Qwen 3 7B",
-        "description": "Modelo equilibrado para uso general",
-        "max_tokens": 1000000,
-        "best_for": "Análisis rápidos y precisos",
-        "input_cost": 0.00000035,
-        "output_cost": 0.00000105
+    "claude-sonnet-4-20250514": {
+        "name": "Claude Sonnet 4 (Latest)",
+        "description": "Modelo inteligente y eficiente para uso cotidiano",
+        "max_tokens": 4000,
+        "best_for": "Análisis general, recomendado para la mayoría de casos"
     },
-    "Qwen/Qwen1.5-14B": {
-        "name": "Qwen 1.5 14B",
-        "description": "Modelo avanzado para tareas complejas",
-        "max_tokens": 1000000,
-        "best_for": "Análisis técnicos detallados",
-        "input_cost": 0.0000007,
-        "output_cost": 0.0000021
+    "claude-3-5-haiku-20241022": {
+        "name": "Claude 3.5 Haiku (Latest)",
+        "description": "Modelo más rápido para tareas diarias",
+        "max_tokens": 4000,
+        "best_for": "Análisis rápidos y económicos"
+    },
+    "claude-3-7-sonnet-20250219": {
+        "name": "Claude 3.7 Sonnet",
+        "description": "Modelo avanzado de la serie 3.7",
+        "max_tokens": 4000,
+        "best_for": "Análisis equilibrados con alta calidad"
+    },
+    "claude-3-5-sonnet-20241022": {
+        "name": "Claude 3.5 Sonnet (Oct 2024)",
+        "description": "Excelente balance entre velocidad y capacidad",
+        "max_tokens": 4000,
+        "best_for": "Análisis rápidos y precisos"
     }
 }
 
@@ -318,6 +392,9 @@ class ReportExporter:
         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)
@@ -326,6 +403,9 @@ class ReportExporter:
         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()
@@ -394,6 +474,9 @@ class ReportExporter:
         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))
@@ -402,6 +485,9 @@ class ReportExporter:
         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))
@@ -439,28 +525,13 @@ class ReportExporter:
         return filename
 
 class AIAnalyzer:
-    """Clase para análisis con IA usando Qwen"""
+    """Clase para análisis con IA"""
     
     def __init__(self, client, model_registry):
         self.client = client
         self.model_registry = model_registry
-        self.token_usage = {
-            'input_tokens': 0,
-            'output_tokens': 0,
-            'total_tokens': 0,
-            'estimated_cost': 0.0
-        }
     
-    def reset_token_usage(self):
-        """Reinicia el contador de tokens"""
-        self.token_usage = {
-            'input_tokens': 0,
-            'output_tokens': 0,
-            'total_tokens': 0,
-            'estimated_cost': 0.0
-        }
-    
-    def detect_analysis_type(self, content: Union[str, pd.DataFrame], max_tokens: int = 1000) -> AnalysisType:
+    def detect_analysis_type(self, content: Union[str, pd.DataFrame]) -> AnalysisType:
         """Detecta el tipo de análisis necesario"""
         if isinstance(content, pd.DataFrame):
             columns = [col.lower() for col in content.columns]
@@ -489,20 +560,13 @@ class AIAnalyzer:
         """
         
         try:
-            response = self.client.chat.completions.create(
-                model="Qwen/Qwen3-14B",
-                max_tokens=min(max_tokens, 10000),
-                temperature=0.0,
-                messages=[{"role": "user", "content": f"{prompt}\n\n{content[:10000]}"}]
+            response = self.client.messages.create(
+                model="claude-3-haiku-20240307",
+                max_tokens=10,
+                messages=[{"role": "user", "content": f"{prompt}\n\n{content[:1000]}"}]
             )
             
-            # Registrar uso de tokens
-            if response.usage:
-                self.token_usage['input_tokens'] += response.usage.prompt_tokens
-                self.token_usage['output_tokens'] += response.usage.completion_tokens
-                self.token_usage['total_tokens'] += response.usage.total_tokens
-            
-            result = response.choices[0].message.content.strip().upper()
+            result = response.content[0].text.strip().upper()
             if "MODEL" in result:
                 return AnalysisType.MATHEMATICAL_MODEL
             elif "RESULTS" in result:
@@ -512,8 +576,7 @@ class AIAnalyzer:
             else:
                 return AnalysisType.UNKNOWN
                 
-        except Exception as e:
-            print(f"Error en detección de tipo: {str(e)}")
+        except:
             return AnalysisType.UNKNOWN
     
     def get_language_prompt_prefix(self, language: str) -> str:
@@ -521,13 +584,15 @@ class AIAnalyzer:
         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. "
         }
         return prefixes.get(language, prefixes['en'])
     
-    def analyze_fitting_results(self, data: pd.DataFrame, qwen_model: str, detail_level: str = "detailed", 
-                              language: str = "en", additional_specs: str = "", 
-                              max_input_tokens: int = 100000, max_output_tokens: int = 100000) -> Dict:
-        """Analiza resultados de ajuste de modelos usando Qwen"""
+    def analyze_fitting_results(self, data: pd.DataFrame, claude_model: str, detail_level: str = "detailed", 
+                              language: str = "en", additional_specs: str = "") -> Dict:
+        """Analiza resultados de ajuste de modelos con soporte multiidioma y especificaciones adicionales"""
         
         # Preparar resumen completo de los datos
         data_summary = f"""
@@ -537,10 +602,16 @@ class AIAnalyzer:
         - Columns: {list(data.columns)}
         - Number of models evaluated: {len(data)}
         
-        Complete data (first 5 rows):
-        {data.head().to_string()}
+        Complete data:
+        {data.to_string()}
+        
+        Descriptive statistics:
+        {data.describe().to_string()}
         """
         
+        # Extraer valores para usar en el código
+        data_dict = data.to_dict('records')
+        
         # Obtener prefijo de idioma
         lang_prefix = self.get_language_prompt_prefix(language)
         
@@ -700,32 +771,21 @@ class AIAnalyzer:
             """
         
         try:
-            # Análisis principal
-            response = self.client.chat.completions.create(
-                model=qwen_model,
-                max_tokens=min(max_output_tokens, 100000),
-                temperature=0.3,
+            response = self.client.messages.create(
+                model=claude_model,
+                max_tokens=4000,
                 messages=[{
                     "role": "user",
                     "content": f"{prompt}\n\n{data_summary}"
                 }]
             )
             
-            # Registrar uso de tokens
-            if response.usage:
-                self.token_usage['input_tokens'] += response.usage.prompt_tokens
-                self.token_usage['output_tokens'] += response.usage.completion_tokens
-                self.token_usage['total_tokens'] += response.usage.total_tokens
-                self.token_usage['estimated_cost'] = self.calculate_cost(qwen_model, response.usage)
-            
-            analysis_result = response.choices[0].message.content
-            
-            # Generación de código
+            # Análisis adicional para generar código con valores numéricos reales
             code_prompt = f"""
             {lang_prefix}
             
             Based on the analysis and this actual data:
-            {data.head().to_string()}
+            {data.to_string()}
             
             Generate Python code that:
             
@@ -752,29 +812,19 @@ class AIAnalyzer:
             Format: Complete, executable Python code with actual data values embedded.
             """
             
-            code_response = self.client.chat.completions.create(
-                model=qwen_model,
-                max_tokens=min(max_output_tokens, 100000),
-                temperature=0.1,
+            code_response = self.client.messages.create(
+                model=claude_model,
+                max_tokens=3000,
                 messages=[{
                     "role": "user",
                     "content": code_prompt
                 }]
             )
             
-            # Registrar uso de tokens
-            if code_response.usage:
-                self.token_usage['input_tokens'] += code_response.usage.prompt_tokens
-                self.token_usage['output_tokens'] += code_response.usage.completion_tokens
-                self.token_usage['total_tokens'] += code_response.usage.total_tokens
-                self.token_usage['estimated_cost'] += self.calculate_cost(qwen_model, code_response.usage)
-            
-            code_result = code_response.choices[0].message.content
-            
             return {
                 "tipo": "Comparative Analysis of Mathematical Models",
-                "analisis_completo": analysis_result,
-                "codigo_implementacion": code_result,
+                "analisis_completo": response.content[0].text,
+                "codigo_implementacion": code_response.content[0].text,
                 "resumen_datos": {
                     "n_modelos": len(data),
                     "columnas": list(data.columns),
@@ -782,35 +832,20 @@ class AIAnalyzer:
                                            for metric in ['r2', 'rmse', 'aic', 'bic', 'mse'])],
                     "mejor_r2": data['R2'].max() if 'R2' in data.columns else None,
                     "mejor_modelo_r2": data.loc[data['R2'].idxmax()]['Model'] if 'R2' in data.columns and 'Model' in data.columns else None,
+                    "datos_completos": data_dict  # Incluir todos los datos para el código
                 }
             }
             
         except Exception as e:
-            print(f"Error en análisis: {str(e)}")
             return {"error": str(e)}
-    
-    def calculate_cost(self, model_name: str, usage) -> float:
-        """Calcula el costo estimado en dólares"""
-        if model_name not in QWEN_MODELS:
-            return 0.0
-        
-        model_info = QWEN_MODELS[model_name]
-        input_cost = model_info.get('input_cost', 0.0)
-        output_cost = model_info.get('output_cost', 0.0)
-        
-        return (usage.prompt_tokens * input_cost) + (usage.completion_tokens * output_cost)
 
-def process_files(files, qwen_model: str, detail_level: str = "detailed", 
-                 language: str = "en", additional_specs: str = "",
-                 max_input_tokens: int = 10000, max_output_tokens: int = 10000) -> Tuple[str, str, str, Dict]:
-    """Procesa múltiples archivos usando Qwen"""
+def process_files(files, claude_model: str, detail_level: str = "detailed", 
+                 language: str = "en", additional_specs: str = "") -> Tuple[str, str]:
+    """Procesa múltiples archivos con soporte de idioma y especificaciones adicionales"""
     processor = FileProcessor()
     analyzer = AIAnalyzer(client, model_registry)
-    analyzer.reset_token_usage()
-    
     results = []
     all_code = []
-    thinking_process = []
     
     for file in files:
         if file is None:
@@ -825,26 +860,20 @@ def process_files(files, qwen_model: str, detail_level: str = "detailed",
         if file_ext in ['.csv', '.xlsx', '.xls']:
             if language == 'es':
                 results.append(f"## 📊 Análisis de Resultados: {file_name}")
-                thinking_process.append(f"### 🔍 Procesando archivo: {file_name}")
             else:
                 results.append(f"## 📊 Results Analysis: {file_name}")
-                thinking_process.append(f"### 🔍 Processing file: {file_name}")
             
             if file_ext == '.csv':
                 df = processor.read_csv(file_content)
-                thinking_process.append("✅ Archivo CSV leído correctamente" if language == 'es' else "✅ CSV file read successfully")
             else:
                 df = processor.read_excel(file_content)
-                thinking_process.append("✅ Archivo Excel leído correctamente" if language == 'es' else "✅ Excel file read successfully")
             
             if df is not None:
-                analysis_type = analyzer.detect_analysis_type(df, max_input_tokens)
-                thinking_process.append(f"🔎 Tipo de análisis detectado: {analysis_type.value}" if language == 'es' else f"🔎 Analysis type detected: {analysis_type.value}")
+                analysis_type = analyzer.detect_analysis_type(df)
                 
                 if analysis_type == AnalysisType.FITTING_RESULTS:
                     result = analyzer.analyze_fitting_results(
-                        df, qwen_model, detail_level, language, additional_specs,
-                        max_input_tokens, max_output_tokens
+                        df, claude_model, detail_level, language, additional_specs
                     )
                     
                     if language == 'es':
@@ -857,56 +886,367 @@ def process_files(files, qwen_model: str, detail_level: str = "detailed",
                         all_code.append(result["codigo_implementacion"])
         
         results.append("\n---\n")
-        thinking_process.append("\n---\n")
     
     analysis_text = "\n".join(results)
     code_text = "\n\n# " + "="*50 + "\n\n".join(all_code) if all_code else generate_implementation_code(analysis_text)
-    thinking_text = "\n".join(thinking_process)
     
-    # Agregar información de tokens al proceso de pensamiento
-    token_info = analyzer.token_usage
-    if language == 'es':
-        thinking_text += f"""
-        
-        ### 💰 USO DE TOKENS
-        - Tokens de entrada usados: {token_info['input_tokens']}
-        - Tokens de salida usados: {token_info['output_tokens']}
-        - Total de tokens: {token_info['total_tokens']}
-        - Costo estimado: ${token_info['estimated_cost']:.6f}
-        """
-    else:
-        thinking_text += f"""
-        
-        ### 💰 TOKEN USAGE
-        - Input tokens used: {token_info['input_tokens']}
-        - Output tokens used: {token_info['output_tokens']}
-        - Total tokens: {token_info['total_tokens']}
-        - Estimated cost: ${token_info['estimated_cost']:.6f}
-        """
-    
-    return thinking_text, analysis_text, code_text, token_info
+    return analysis_text, code_text
 
 def generate_implementation_code(analysis_results: str) -> str:
     """Genera código de implementación con análisis por experimento"""
-    # (El código de implementación se mantiene igual que en la versión anterior)
-    return ""
+    code = """
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.integrate import odeint
+from scipy.optimize import curve_fit, differential_evolution
+from sklearn.metrics import r2_score, mean_squared_error
+import seaborn as sns
+from typing import Dict, List, Tuple, Optional
+
+# Visualization configuration
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+class ExperimentalModelAnalyzer:
+    \"\"\"
+    Class for comparative analysis of biotechnological models across multiple experiments.
+    Analyzes biomass, substrate and product models separately for each experimental condition.
+    \"\"\"
+    
+    def __init__(self):
+        self.results_df = None
+        self.experiments = {}
+        self.best_models_by_experiment = {}
+        self.overall_best_models = {
+            'biomass': None,
+            'substrate': None,
+            'product': None
+        }
+        
+    def load_results(self, file_path: str = None, data_dict: dict = None) -> pd.DataFrame:
+        \"\"\"Load fitting results from CSV/Excel file or dictionary\"\"\"
+        if data_dict:
+            self.results_df = pd.DataFrame(data_dict)
+        elif file_path:
+            if file_path.endswith('.csv'):
+                self.results_df = pd.read_csv(file_path)
+            else:
+                self.results_df = pd.read_excel(file_path)
+        
+        print(f"✅ Data loaded: {len(self.results_df)} models")
+        print(f"📊 Available columns: {list(self.results_df.columns)}")
+        
+        # Identify experiments
+        if 'Experiment' in self.results_df.columns:
+            self.experiments = self.results_df.groupby('Experiment').groups
+            print(f"🧪 Experiments found: {list(self.experiments.keys())}")
+        
+        return self.results_df
+    
+    def analyze_by_experiment(self, 
+                            experiment_col: str = 'Experiment',
+                            model_col: str = 'Model',
+                            type_col: str = 'Type',
+                            r2_col: str = 'R2',
+                            rmse_col: str = 'RMSE') -> Dict:
+        \"\"\"
+        Analyze models by experiment and variable type.
+        Identifies best models for biomass, substrate, and product in each experiment.
+        \"\"\"
+        if self.results_df is None:
+            raise ValueError("First load data with load_results()")
+        
+        results_by_exp = {}
+        
+        # Get unique experiments
+        if experiment_col in self.results_df.columns:
+            experiments = self.results_df[experiment_col].unique()
+        else:
+            experiments = ['All_Data']
+            self.results_df[experiment_col] = 'All_Data'
+        
+        print("\\n" + "="*80)
+        print("📊 ANALYSIS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        
+        for exp in experiments:
+            print(f"\\n🧪 EXPERIMENT: {exp}")
+            print("-"*50)
+            
+            exp_data = self.results_df[self.results_df[experiment_col] == exp]
+            results_by_exp[exp] = {}
+            
+            # Analyze by variable type if available
+            if type_col in exp_data.columns:
+                var_types = exp_data[type_col].unique()
+                
+                for var_type in var_types:
+                    var_data = exp_data[exp_data[type_col] == var_type]
+                    
+                    if not var_data.empty:
+                        # Find best model for this variable type
+                        best_idx = var_data[r2_col].idxmax()
+                        best_model = var_data.loc[best_idx]
+                        
+                        results_by_exp[exp][var_type] = {
+                            'best_model': best_model[model_col],
+                            'r2': best_model[r2_col],
+                            'rmse': best_model[rmse_col],
+                            'all_models': var_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                        }
+                        
+                        print(f"\\n  📈 {var_type.upper()}:")
+                        print(f"    Best Model: {best_model[model_col]}")
+                        print(f"    R² = {best_model[r2_col]:.4f}")
+                        print(f"    RMSE = {best_model[rmse_col]:.4f}")
+                        
+                        # Show all models for this variable
+                        print(f"\\n    All {var_type} models tested:")
+                        for _, row in var_data.iterrows():
+                            print(f"      - {row[model_col]}: R²={row[r2_col]:.4f}, RMSE={row[rmse_col]:.4f}")
+            else:
+                # If no type column, analyze all models together
+                best_idx = exp_data[r2_col].idxmax()
+                best_model = exp_data.loc[best_idx]
+                
+                results_by_exp[exp]['all'] = {
+                    'best_model': best_model[model_col],
+                    'r2': best_model[r2_col],
+                    'rmse': best_model[rmse_col],
+                    'all_models': exp_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                }
+        
+        self.best_models_by_experiment = results_by_exp
+        
+        # Determine overall best models
+        self._determine_overall_best_models()
+        
+        return results_by_exp
+    
+    def _determine_overall_best_models(self):
+        \"\"\"Determine the best models across all experiments\"\"\"
+        print("\\n" + "="*80)
+        print("🏆 OVERALL BEST MODELS ACROSS ALL EXPERIMENTS")
+        print("="*80)
+        
+        # Aggregate performance by model and type
+        model_performance = {}
+        
+        for exp, exp_results in self.best_models_by_experiment.items():
+            for var_type, var_results in exp_results.items():
+                if var_type not in model_performance:
+                    model_performance[var_type] = {}
+                
+                for model_data in var_results['all_models']:
+                    model_name = model_data['Model']
+                    if model_name not in model_performance[var_type]:
+                        model_performance[var_type][model_name] = {
+                            'r2_values': [],
+                            'rmse_values': [],
+                            'experiments': []
+                        }
+                    
+                    model_performance[var_type][model_name]['r2_values'].append(model_data['R2'])
+                    model_performance[var_type][model_name]['rmse_values'].append(model_data['RMSE'])
+                    model_performance[var_type][model_name]['experiments'].append(exp)
+        
+        # Calculate average performance and select best
+        for var_type, models in model_performance.items():
+            best_avg_r2 = -1
+            best_model = None
+            
+            print(f"\\n📊 {var_type.upper()} MODELS:")
+            for model_name, perf_data in models.items():
+                avg_r2 = np.mean(perf_data['r2_values'])
+                avg_rmse = np.mean(perf_data['rmse_values'])
+                n_exp = len(perf_data['experiments'])
+                
+                print(f"  {model_name}:")
+                print(f"    Average R² = {avg_r2:.4f}")
+                print(f"    Average RMSE = {avg_rmse:.4f}")
+                print(f"    Tested in {n_exp} experiments")
+                
+                if avg_r2 > best_avg_r2:
+                    best_avg_r2 = avg_r2
+                    best_model = {
+                        'name': model_name,
+                        'avg_r2': avg_r2,
+                        'avg_rmse': avg_rmse,
+                        'n_experiments': n_exp
+                    }
+            
+            if var_type.lower() in ['biomass', 'substrate', 'product']:
+                self.overall_best_models[var_type.lower()] = best_model
+                print(f"\\n  🏆 BEST {var_type.upper()} MODEL: {best_model['name']} (Avg R²={best_model['avg_r2']:.4f})")
+    
+    def create_comparison_visualizations(self):
+        \"\"\"Create visualizations comparing models across experiments\"\"\"
+        if not self.best_models_by_experiment:
+            raise ValueError("First run analyze_by_experiment()")
+        
+        # Prepare data for visualization
+        experiments = []
+        biomass_r2 = []
+        substrate_r2 = []
+        product_r2 = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            experiments.append(exp)
+            biomass_r2.append(results.get('Biomass', {}).get('r2', 0))
+            substrate_r2.append(results.get('Substrate', {}).get('r2', 0))
+            product_r2.append(results.get('Product', {}).get('r2', 0))
+        
+        # Create figure with subplots
+        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+        fig.suptitle('Model Performance Comparison Across Experiments', fontsize=16)
+        
+        # 1. R² comparison by experiment and variable type
+        ax1 = axes[0, 0]
+        x = np.arange(len(experiments))
+        width = 0.25
+        
+        ax1.bar(x - width, biomass_r2, width, label='Biomass', color='green', alpha=0.8)
+        ax1.bar(x, substrate_r2, width, label='Substrate', color='blue', alpha=0.8)
+        ax1.bar(x + width, product_r2, width, label='Product', color='red', alpha=0.8)
+        
+        ax1.set_xlabel('Experiment')
+        ax1.set_ylabel('R²')
+        ax1.set_title('Best Model R² by Experiment and Variable Type')
+        ax1.set_xticks(x)
+        ax1.set_xticklabels(experiments, rotation=45, ha='right')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # Add value labels
+        for i, (b, s, p) in enumerate(zip(biomass_r2, substrate_r2, product_r2)):
+            if b > 0: ax1.text(i - width, b + 0.01, f'{b:.3f}', ha='center', va='bottom', fontsize=8)
+            if s > 0: ax1.text(i, s + 0.01, f'{s:.3f}', ha='center', va='bottom', fontsize=8)
+            if p > 0: ax1.text(i + width, p + 0.01, f'{p:.3f}', ha='center', va='bottom', fontsize=8)
+        
+        # 2. Model frequency heatmap
+        ax2 = axes[0, 1]
+        # This would show which models appear most frequently as best
+        # Implementation depends on actual data structure
+        ax2.text(0.5, 0.5, 'Model Frequency Analysis\\n(Most Used Models)', 
+                ha='center', va='center', transform=ax2.transAxes)
+        ax2.set_title('Most Frequently Selected Models')
+        
+        # 3. Parameter evolution across experiments
+        ax3 = axes[1, 0]
+        ax3.text(0.5, 0.5, 'Parameter Evolution\\nAcross Experiments', 
+                ha='center', va='center', transform=ax3.transAxes)
+        ax3.set_title('Parameter Trends')
+        
+        # 4. Overall best models summary
+        ax4 = axes[1, 1]
+        ax4.axis('off')
+        
+        summary_text = "🏆 OVERALL BEST MODELS\\n\\n"
+        for var_type, model_info in self.overall_best_models.items():
+            if model_info:
+                summary_text += f"{var_type.upper()}:\\n"
+                summary_text += f"  Model: {model_info['name']}\\n"
+                summary_text += f"  Avg R²: {model_info['avg_r2']:.4f}\\n"
+                summary_text += f"  Tested in: {model_info['n_experiments']} experiments\\n\\n"
+        
+        ax4.text(0.1, 0.9, summary_text, transform=ax4.transAxes, 
+                fontsize=12, verticalalignment='top', fontfamily='monospace')
+        ax4.set_title('Overall Best Models Summary')
+        
+        plt.tight_layout()
+        plt.show()
+    
+    def generate_summary_table(self) -> pd.DataFrame:
+        \"\"\"Generate a summary table of best models by experiment and type\"\"\"
+        summary_data = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            for var_type, var_results in results.items():
+                summary_data.append({
+                    'Experiment': exp,
+                    'Variable_Type': var_type,
+                    'Best_Model': var_results['best_model'],
+                    'R2': var_results['r2'],
+                    'RMSE': var_results['rmse']
+                })
+        
+        summary_df = pd.DataFrame(summary_data)
+        
+        print("\\n📋 SUMMARY TABLE: BEST MODELS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        print(summary_df.to_string(index=False))
+        
+        return summary_df
+
+# Example usage
+if __name__ == "__main__":
+    print("🧬 Experimental Model Comparison System")
+    print("="*60)
+    
+    # Example data structure with experiments
+    example_data = {
+        'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5'],
+        'Model': ['Monod', 'Logistic', 'Gompertz', 'Monod', 'Logistic', 'Gompertz',
+                 'First_Order', 'Monod_Substrate', 'First_Order', 'Monod_Substrate',
+                 'Luedeking_Piret', 'Linear', 'Luedeking_Piret', 'Linear'],
+        'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass',
+                'Substrate', 'Substrate', 'Substrate', 'Substrate',
+                'Product', 'Product', 'Product', 'Product'],
+        'R2': [0.9845, 0.9912, 0.9956, 0.9789, 0.9834, 0.9901,
+              0.9723, 0.9856, 0.9698, 0.9812,
+              0.9634, 0.9512, 0.9687, 0.9423],
+        'RMSE': [0.0234, 0.0189, 0.0145, 0.0267, 0.0223, 0.0178,
+                0.0312, 0.0245, 0.0334, 0.0289,
+                0.0412, 0.0523, 0.0389, 0.0567],
+        'mu_max': [0.45, 0.48, 0.52, 0.42, 0.44, 0.49,
+                  None, None, None, None, None, None, None, None],
+        'Ks': [None, None, None, None, None, None,
+              2.1, 1.8, 2.3, 1.9, None, None, None, None]
+    }
+    
+    # Create analyzer
+    analyzer = ExperimentalModelAnalyzer()
+    
+    # Load data
+    analyzer.load_results(data_dict=example_data)
+    
+    # Analyze by experiment
+    results = analyzer.analyze_by_experiment()
+    
+    # Create visualizations
+    analyzer.create_comparison_visualizations()
+    
+    # Generate summary table
+    summary = analyzer.generate_summary_table()
+    
+    print("\\n✨ Analysis complete! Best models identified for each experiment and variable type.")
+"""
+    
+    return code
 
 # Estado global para almacenar resultados
 class AppState:
     def __init__(self):
-        self.current_thinking = ""
         self.current_analysis = ""
         self.current_code = ""
         self.current_language = "en"
-        self.token_usage = {}
 
 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 = TRANSLATIONS[language]['error_no_files']
-        return error_msg, ""
+        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"
+        }
+        return error_msg.get(language, error_msg['en']), ""
     
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     
@@ -943,47 +1283,26 @@ def create_interface():
             gr.update(label=t['select_theme']),   # theme_selector
             gr.update(label=t['detail_level']),   # detail_level
             gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']), # additional_specs
-            gr.update(label=t['input_tokens']),   # input_tokens_slider
-            gr.update(label=t['output_tokens']),  # output_tokens_slider
             gr.update(value=t['analyze_button']), # analyze_btn
             gr.update(label=t['export_format']),  # export_format
             gr.update(value=t['export_button']),  # export_btn
-            gr.update(label=t['thinking_process']), # thinking_output
-            gr.update(label=t['analysis_report']), # analysis_output
-            gr.update(label=t['code_output']),    # code_output
-            gr.update(label=t['token_usage']),    # token_usage_output
+            gr.update(label=t['comparative_analysis']), # analysis_output
+            gr.update(label=t['implementation_code']),  # code_output
             gr.update(label=t['data_format'])    # data_format_accordion
         ]
     
-    def process_and_store(files, model, detail, language, additional_specs, input_tokens, output_tokens):
+    def process_and_store(files, model, detail, language, additional_specs):
         """Procesa archivos y almacena resultados"""
         if not files:
             error_msg = TRANSLATIONS[language]['error_no_files']
-            return error_msg, "", "", {"input_tokens": 0, "output_tokens": 0, "total_tokens": 0, "estimated_cost": 0.0}
-        
-        thinking, analysis, code, token_usage = process_files(
-            files, model, detail, language, additional_specs, 
-            input_tokens, output_tokens
-        )
+            return error_msg, ""
         
-        app_state.current_thinking = thinking
+        analysis, code = process_files(files, model, detail, language, additional_specs)
         app_state.current_analysis = analysis
         app_state.current_code = code
-        app_state.token_usage = token_usage
-        
-        # Formatear información de tokens
-        t = TRANSLATIONS[language]
-        token_info = f"""
-        ### {t['token_info']}
-        - **{t['input_token_count']}:** {token_usage['input_tokens']}
-        - **{t['output_token_count']}:** {token_usage['output_tokens']}
-        - **{t['total_token_count']}:** {token_usage['total_tokens']}
-        - **{t['token_cost']}:** ${token_usage['estimated_cost']:.6f}
-        """
-        
-        return thinking, analysis, code, token_info
+        return analysis, code
     
-    with gr.Blocks(theme=THEMES[current_theme], title="Biotech Model Analyzer") as demo:
+    with gr.Blocks(theme=THEMES[current_theme]) as demo:
         # Componentes de UI
         with gr.Row():
             with gr.Column(scale=3):
@@ -992,7 +1311,8 @@ def create_interface():
             with gr.Column(scale=1):
                 with gr.Row():
                     language_selector = gr.Dropdown(
-                        choices=[("English", "en"), ("Español", "es")],
+                        choices=[("English", "en"), ("Español", "es"), ("Français", "fr"), 
+                                ("Deutsch", "de"), ("Português", "pt")],
                         value="en",
                         label=TRANSLATIONS[current_language]['select_language'],
                         interactive=True
@@ -1014,10 +1334,10 @@ def create_interface():
                 )
                 
                 model_selector = gr.Dropdown(
-                    choices=list(QWEN_MODELS.keys()),
-                    value="Qwen/Qwen3-14B",
+                    choices=list(CLAUDE_MODELS.keys()),
+                    value="claude-3-5-sonnet-20241022",
                     label=TRANSLATIONS[current_language]['select_model'],
-                    info=f"{TRANSLATIONS[current_language]['best_for']}: {QWEN_MODELS['Qwen/Qwen3-14B']['best_for']}"
+                    info=f"{TRANSLATIONS[current_language]['best_for']}: {CLAUDE_MODELS['claude-3-5-sonnet-20241022']['best_for']}"
                 )
                 
                 detail_level = gr.Radio(
@@ -1029,6 +1349,7 @@ def create_interface():
                     label=TRANSLATIONS[current_language]['detail_level']
                 )
                 
+                # Nueva entrada para especificaciones adicionales
                 additional_specs = gr.Textbox(
                     label=TRANSLATIONS[current_language]['additional_specs'],
                     placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'],
@@ -1037,25 +1358,6 @@ def create_interface():
                     interactive=True
                 )
                 
-                # Nuevos sliders para tokens
-                input_tokens_slider = gr.Slider(
-                    minimum=1000,
-                    maximum=1000000,
-                    value=10000,
-                    step=1000,
-                    label=TRANSLATIONS[current_language]['input_tokens'],
-                    info="Máximo tokens para entrada (0-1 millón)"
-                )
-                
-                output_tokens_slider = gr.Slider(
-                    minimum=1000,
-                    maximum=1000000,
-                    value=30000,
-                    step=1000,
-                    label=TRANSLATIONS[current_language]['output_tokens'],
-                    info="Máximo tokens para salida (0-1 millón)"
-                )
-                
                 analyze_btn = gr.Button(
                     TRANSLATIONS[current_language]['analyze_button'],
                     variant="primary",
@@ -1087,24 +1389,15 @@ def create_interface():
                 )
             
             with gr.Column(scale=2):
-                # Nuevos outputs separados
-                thinking_output = gr.Markdown(
-                    label=TRANSLATIONS[current_language]['thinking_process']
-                )
-                
                 analysis_output = gr.Markdown(
-                    label=TRANSLATIONS[current_language]['analysis_report']
+                    label=TRANSLATIONS[current_language]['comparative_analysis']
                 )
                 
                 code_output = gr.Code(
-                    label=TRANSLATIONS[current_language]['code_output'],
+                    label=TRANSLATIONS[current_language]['implementation_code'],
                     language="python",
                     interactive=True,
-                    lines=15
-                )
-                
-                token_usage_output = gr.Markdown(
-                    label=TRANSLATIONS[current_language]['token_usage']
+                    lines=20
                 )
         
         data_format_accordion = gr.Accordion(
@@ -1131,21 +1424,32 @@ def create_interface():
             - **Parameters**: Model-specific parameters
             """)
         
-        # Eventos
+        # Definir ejemplos
+        examples = gr.Examples(
+            examples=[
+                [["examples/biomass_models_comparison.csv"], "claude-3-5-sonnet-20241022", "detailed", ""],
+                [["examples/substrate_kinetics_results.xlsx"], "claude-3-5-sonnet-20241022", "summarized", "Focus on temperature effects"]
+            ],
+            inputs=[files_input, model_selector, detail_level, additional_specs],
+            label=TRANSLATIONS[current_language]['examples']
+        )
+        
+        # Eventos - Actualizado para incluir additional_specs
         language_selector.change(
             update_interface_language,
             inputs=[language_selector],
             outputs=[
                 title_text, subtitle_text, files_input, model_selector,
                 language_selector, theme_selector, detail_level, additional_specs,
-                input_tokens_slider, output_tokens_slider, analyze_btn, export_format, 
-                export_btn, thinking_output, analysis_output, code_output,
-                token_usage_output, data_format_accordion
+                analyze_btn, export_format, export_btn, analysis_output, 
+                code_output, 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(
@@ -1156,9 +1460,8 @@ def create_interface():
         
         analyze_btn.click(
             fn=process_and_store,
-            inputs=[files_input, model_selector, detail_level, language_selector, 
-                   additional_specs, input_tokens_slider, output_tokens_slider],
-            outputs=[thinking_output, analysis_output, code_output, token_usage_output]
+            inputs=[files_input, model_selector, detail_level, language_selector, additional_specs],
+            outputs=[analysis_output, code_output]
         )
         
         def handle_export(format, language):
@@ -1178,8 +1481,8 @@ def create_interface():
 
 # Función principal
 def main():
-    if not os.getenv("NEBIUS_API_KEY"):
-        print("⚠️ Configure NEBIUS_API_KEY in HuggingFace Space secrets")
+    if not os.getenv("ANTHROPIC_API_KEY"):
+        print("⚠️ Configure ANTHROPIC_API_KEY in HuggingFace Space secrets")
         return gr.Interface(
             fn=lambda x: TRANSLATIONS['en']['error_no_api'],
             inputs=gr.Textbox(),