Update app.py

app.py

@@ -1,4 +1,5 @@
 import gradio as gr
+from openai import OpenAI
 import PyPDF2
 import pandas as pd
 import numpy as np
@@ -7,1507 +8,352 @@ import os
 import json
 import zipfile
 import tempfile
-from typing import Dict, List, Tuple, Union, Optional
-import re
+from typing import Dict, List, Tuple, Union
 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 docx.shared import Pt
 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.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 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
-from openai import OpenAI # CAMBIO: Importación de la nueva librería
 
 # Configuración para HuggingFace
 os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 
-# CAMBIO: Inicializar cliente OpenAI para Nebius
+# Inicializar cliente OpenAI para Nebius
 client = OpenAI(
     base_url="https://api.studio.nebius.com/v1/",
     api_key=os.environ.get("NEBIUS_API_KEY")
 )
 
-# Sistema de traducción - Actualizado con nuevas entradas
+# Sistema de traducción
 TRANSLATIONS = {
     'en': {
-        'title': '🧬 Comparative Analyzer of Biotechnological Models',
-        'subtitle': 'Specialized in comparative analysis of mathematical model fitting results',
+        'title': '🧬 API-Powered Biotechnological Model Analyzer',
+        'subtitle': 'Upload your model fitting results and let the AI perform a complete comparative analysis.',
         'upload_files': '📁 Upload fitting results (CSV/Excel)',
-        'select_model': '🤖 AI Model', # CAMBIO
+        'select_model': '🤖 AI Model',
         'select_language': '🌐 Language',
-        'select_theme': '🎨 Theme',
-        'detail_level': '📋 Analysis detail level',
+        '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 NEBIUS_API_KEY in HuggingFace Space secrets', # CAMBIO
+        'analyze_button': '🚀 Analyze with AI',
+        'export_format': '📄 Export Format',
+        'export_button': '💾 Export Analysis',
+        'comparative_analysis': '📊 AI-Generated Analysis',
+        'implementation_code': '💻 AI-Generated Implementation Code',
+        'data_format': '📋 Expected Data Format',
+        'error_no_api': 'Please configure NEBIUS_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:',
-        'additional_specs': '📝 Additional specifications for analysis',
-        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...'
+        'additional_specs': '📝 Additional Specifications for Analysis',
+        'additional_specs_placeholder': 'e.g., "Focus on the effect of temperature" or "Provide scale-up recommendations"...'
     },
     'es': {
-        'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
-        'subtitle': 'Especializado en análisis comparativo de resultados de ajuste de modelos matemáticos',
+        'title': '🧬 Analizador Biotecnológico Impulsado por API',
+        'subtitle': 'Sube los resultados de ajuste de tus modelos y deja que la IA realice un análisis comparativo completo.',
         'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
-        'select_model': '🤖 Modelo de IA', # CAMBIO
+        'select_model': '🤖 Modelo de IA',
         'select_language': '🌐 Idioma',
-        'select_theme': '🎨 Tema',
-        'detail_level': '📋 Nivel de detalle del análisis',
+        '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 NEBIUS_API_KEY en los secretos del Space', # CAMBIO
+        'analyze_button': '🚀 Analizar con IA',
+        'export_format': '📄 Formato de Exportación',
+        'export_button': '💾 Exportar Análisis',
+        'comparative_analysis': '📊 Análisis Generado por IA',
+        'implementation_code': '💻 Código de Implementación Generado por IA',
+        'data_format': '📋 Formato de Datos Esperado',
+        'error_no_api': 'Por favor configura NEBIUS_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:',
-        'additional_specs': '📝 Especificaciones adicionales para el análisis',
-        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...'
+        'additional_specs': '📝 Especificaciones Adicionales para el Análisis',
+        'additional_specs_placeholder': 'Ej: "Enfócate en el efecto de la temperatura" o "Provee recomendaciones de escalado"...'
     },
-    '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 d\'IA', # CAMBIO
-        '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 NEBIUS_API_KEY', # CAMBIO
-        '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': '🤖 KI-Modell', # CAMBIO
-        '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 NEBIUS_API_KEY', # CAMBIO
-        '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 de IA', # CAMBIO
-        '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 NEBIUS_API_KEY', # CAMBIO
-        '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...'
-    }
 }
 
-# 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"
-    DATA_FITTING = "data_fitting"
-    FITTING_RESULTS = "fitting_results"
-    UNKNOWN = "unknown"
-
-# Estructura modular para modelos
-@dataclass
-class MathematicalModel:
-    name: str
-    equation: str
-    parameters: List[str]
-    application: str
-    sources: List[str]
-    category: str
-    biological_meaning: str
-
-# Sistema de registro de modelos escalable
-class ModelRegistry:
-    def __init__(self):
-        self.models = {}
-        self._initialize_default_models()
-    
-    def register_model(self, model: MathematicalModel):
-        """Registra un nuevo modelo matemático"""
-        if model.category not in self.models:
-            self.models[model.category] = {}
-        self.models[model.category][model.name] = model
-    
-    def get_model(self, category: str, name: str) -> MathematicalModel:
-        """Obtiene un modelo específico"""
-        return self.models.get(category, {}).get(name)
-    
-    def get_all_models(self) -> Dict:
-        """Retorna todos los modelos registrados"""
-        return self.models
-    
-    def _initialize_default_models(self):
-        """Inicializa los modelos por defecto"""
-        # Modelos de crecimiento
-        self.register_model(MathematicalModel(
-            name="Monod",
-            equation="μ = μmax × (S / (Ks + S))",
-            parameters=["μmax (h⁻¹)", "Ks (g/L)"],
-            application="Crecimiento limitado por sustrato único",
-            sources=["Cambridge", "MIT", "DTU"],
-            category="crecimiento_biomasa",
-            biological_meaning="Describe cómo la velocidad de crecimiento depende de la concentración de sustrato limitante"
-        ))
-        
-        self.register_model(MathematicalModel(
-            name="Logístico",
-            equation="dX/dt = μmax × X × (1 - X/Xmax)",
-            parameters=["μmax (h⁻¹)", "Xmax (g/L)"],
-            application="Sistemas cerrados batch",
-            sources=["Cranfield", "Swansea", "HAL Theses"],
-            category="crecimiento_biomasa",
-            biological_meaning="Modela crecimiento limitado por capacidad de carga del sistema"
-        ))
-        
-        self.register_model(MathematicalModel(
-            name="Gompertz",
-            equation="X(t) = Xmax × exp(-exp((μmax × e / Xmax) × (λ - t) + 1))",
-            parameters=["λ (h)", "μmax (h⁻¹)", "Xmax (g/L)"],
-            application="Crecimiento con fase lag pronunciada",
-            sources=["Lund University", "NC State"],
-            category="crecimiento_biomasa",
-            biological_meaning="Incluye fase de adaptación (lag) seguida de crecimiento exponencial y estacionario"
-        ))
-
-# Instancia global del registro
-model_registry = ModelRegistry()
-
-# CAMBIO: Modelos de Nebius en lugar de Claude
+# Modelos de Nebius disponibles
 NEBIUS_MODELS = {
     "Qwen/Qwen3-14B": {
         "name": "Qwen 3 (14B)",
         "description": "Modelo potente y versátil de la familia Qwen.",
-        "max_tokens": 4096,
-        "best_for": "Análisis detallados y generación de código complejo."
     },
-    # Puedes añadir más modelos de Nebius aquí si están disponibles
 }
 
 class FileProcessor:
-    """Clase para procesar diferentes tipos de archivos"""
-    
-    @staticmethod
-    def extract_text_from_pdf(pdf_file) -> str:
-        """Extrae texto de un archivo PDF"""
-        try:
-            pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
-            text = ""
-            for page in pdf_reader.pages:
-                text += page.extract_text() + "\n"
-            return text
-        except Exception as e:
-            return f"Error reading PDF: {str(e)}"
-    
-    @staticmethod
-    def read_csv(csv_file) -> pd.DataFrame:
-        """Lee archivo CSV"""
-        try:
-            return pd.read_csv(io.BytesIO(csv_file))
-        except Exception as e:
-            return None
-    
     @staticmethod
-    def read_excel(excel_file) -> pd.DataFrame:
-        """Lee archivo Excel"""
-        try:
-            return pd.read_excel(io.BytesIO(excel_file))
-        except Exception as e:
-            return None
+    def read_csv(csv_file: bytes) -> pd.DataFrame:
+        try: return pd.read_csv(io.BytesIO(csv_file))
+        except Exception: return None
     
     @staticmethod
-    def extract_from_zip(zip_file) -> List[Tuple[str, bytes]]:
-        """Extrae archivos de un ZIP"""
-        files = []
-        try:
-            with zipfile.ZipFile(io.BytesIO(zip_file), 'r') as zip_ref:
-                for file_name in zip_ref.namelist():
-                    if not file_name.startswith('__MACOSX'):
-                        file_data = zip_ref.read(file_name)
-                        files.append((file_name, file_data))
-        except Exception as e:
-            print(f"Error processing ZIP: {e}")
-        return files
+    def read_excel(excel_file: bytes) -> pd.DataFrame:
+        try: return pd.read_excel(io.BytesIO(excel_file))
+        except Exception: return None
 
 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"""
+    def export_to_docx(content: str, filename: str, language: str = 'en'):
         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_heading(TRANSLATIONS[language]['title'], 0)
+        doc.add_paragraph(f"{TRANSLATIONS[language]['report_exported'].split(' as')[0]}: {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
+        for line in content.split('\n'):
+            if line.startswith('### '): doc.add_heading(line[4:], level=3)
+            elif line.startswith('## '): doc.add_heading(line[3:], level=2)
+            elif line.startswith('# '): doc.add_heading(line[2:], level=1)
+            else: doc.add_paragraph(line)
         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
+    def export_to_pdf(content: str, filename: str, language: str = 'en'):
         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
+        story = [Paragraph(TRANSLATIONS[language]['title'], styles['h1'])]
+        for line in content.split('\n'):
+            if line.startswith('### '): story.append(Paragraph(line[4:], styles['h3']))
+            elif line.startswith('## '): story.append(Paragraph(line[3:], styles['h2']))
+            elif line.startswith('# '): story.append(Paragraph(line[2:], styles['h1']))
+            else: story.append(Paragraph(line, styles['BodyText']))
         doc.build(story)
         return filename
 
 class AIAnalyzer:
-    """Clase para análisis con IA"""
-    
-    def __init__(self, client, model_registry):
+    """
+    Clase que interactúa exclusivamente con la API para obtener análisis y código.
+    No contiene lógica de análisis predefinida.
+    """
+    def __init__(self, client):
         self.client = client
-        self.model_registry = model_registry
-    
-    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]
-            
-            fitting_indicators = [
-                'r2', 'r_squared', 'rmse', 'mse', 'aic', 'bic', 
-                'parameter', 'param', 'coefficient', 'fit',
-                'model', 'equation', 'goodness', 'chi_square',
-                'p_value', 'confidence', 'standard_error', 'se'
-            ]
-            
-            has_fitting_results = any(indicator in ' '.join(columns) for indicator in fitting_indicators)
-            
-            if has_fitting_results:
-                return AnalysisType.FITTING_RESULTS
-            else:
-                return AnalysisType.DATA_FITTING
-        
-        prompt = """
-        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.)
-        
-        Reply only with: "MODEL", "DATA" or "RESULTS"
+
+    def get_analysis_and_code(self, data: pd.DataFrame, model: str, detail_level: str, language: str, additional_specs: str) -> Dict[str, str]:
         """
+        Realiza una única llamada a la API para obtener tanto el análisis
+        como el código de implementación en un formato JSON.
+        """
+        lang_instruction = TRANSLATIONS[language]['additional_specs_placeholder'] # Reutilizamos un texto traducido
         
-        try:
-            # CAMBIO: Llamada a la API y acceso a la respuesta
-            response = self.client.chat.completions.create(
-                model="Qwen/Qwen3-14B", # Usar un modelo rápido disponible en Nebius
-                temperature=0.1,
-                max_tokens=10,
-                messages=[{"role": "user", "content": f"{prompt}\n\n{content[:1000]}"}]
-            )
-            
-            result = response.choices[0].message.content.strip().upper()
-            if "MODEL" in result:
-                return AnalysisType.MATHEMATICAL_MODEL
-            elif "RESULTS" in result:
-                return AnalysisType.FITTING_RESULTS
-            elif "DATA" in result:
-                return AnalysisType.DATA_FITTING
-            else:
-                return AnalysisType.UNKNOWN
-                
-        except Exception as e:
-            print(f"Error in detect_analysis_type: {e}")
-            return AnalysisType.UNKNOWN
-    
-    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. "
-        }
-        return prefixes.get(language, prefixes['en'])
-    
-    def analyze_fitting_results(self, data: pd.DataFrame, nebius_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"""
-        FITTING RESULTS DATA:
-        
-        Data structure:
-        - Columns: {list(data.columns)}
-        - Number of models evaluated: {len(data)}
-        
-        Complete data:
+        # Prompt unificado que solicita una respuesta JSON con dos claves
+        prompt = f"""
+        Act as an expert in biotechnology and data science. Your task is to analyze the provided model fitting results and generate both a textual analysis and a Python implementation script.
+
+        The user has provided the following data from a CSV/Excel file:
+        --- DATA ---
         {data.to_string()}
-        
-        Descriptive statistics:
-        {data.describe().to_string()}
+        --- END DATA ---
+
+        User requirements:
+        - Language for the analysis: {language}
+        - Detail level: {detail_level}
+        - Additional specifications: "{additional_specs if additional_specs else 'None'}"
+
+        Based on all the information above, perform the following two tasks:
+
+        TASK 1: GENERATE TEXTUAL ANALYSIS
+        Write a comprehensive comparative analysis in Markdown format.
+        - If detail_level is 'detailed', provide an in-depth, experiment-by-experiment comparison, parameter analysis, biological interpretation, and robust conclusions.
+        - If detail_level is 'summarized', provide a concise overview, highlight the best models per experiment, and give clear, practical recommendations.
+        - The analysis MUST be in {language}.
+
+        TASK 2: GENERATE PYTHON CODE
+        Write a complete, executable Python script that a researcher can use to replicate and visualize this analysis.
+        - The script should include data loading (embed the provided data directly).
+        - It must contain functions to compare models and find the best ones.
+        - It must include plotting functions (using matplotlib or seaborn) to visualize the results, such as comparing R² values across experiments.
+        - The code should be well-commented.
+
+        IMPORTANT: Your final output must be a single, valid JSON object containing two keys: "analysis" and "code".
+        Example format:
+        {{
+          "analysis": "### Comparative Analysis\\n\\nHere is the detailed analysis in Markdown...",
+          "code": "import pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n# Your Python code here..."
+        }}
+
+        Do not add any text or explanations outside of the JSON object.
         """
-        
-        # 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)
-        
-        # Agregar especificaciones adicionales del usuario si existen
-        user_specs_section = f"""
-        
-        USER ADDITIONAL SPECIFICATIONS:
-        {additional_specs}
-        
-        Please ensure to address these specific requirements in your analysis.
-        """ if additional_specs else ""
-        
-        # Prompt mejorado con instrucciones específicas para cada nivel
-        if detail_level == "detailed":
-            prompt = f"""
-            {lang_prefix}
-            
-            You are an expert in biotechnology and mathematical modeling. Analyze these kinetic/biotechnological model fitting results.
-            
-            {user_specs_section}
-            
-            DETAIL LEVEL: DETAILED - Provide comprehensive analysis BY EXPERIMENT
-            
-            PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS PER EXPERIMENT:
-            
-            1. **EXPERIMENT IDENTIFICATION AND OVERVIEW**
-               - List ALL experiments/conditions tested (e.g., pH levels, temperatures, time points)
-               - For EACH experiment, identify:
-                 * Experimental conditions
-                 * Number of models tested
-                 * Variables measured (biomass, substrate, product)
-            
-            2. **MODEL IDENTIFICATION AND CLASSIFICATION BY EXPERIMENT**
-               For EACH EXPERIMENT separately:
-               - Identify ALL fitted mathematical models BY NAME
-               - Classify them: biomass growth, substrate consumption, product formation
-               - Show the mathematical equation of each model
-               - List parameter values obtained for that specific experiment
-            
-            3. **COMPARATIVE ANALYSIS PER EXPERIMENT**
-               Create a section for EACH EXPERIMENT showing:
-               
-               **EXPERIMENT [Name/Condition]:**
-               
-               a) **BIOMASS MODELS** (if applicable):
-                  - Best model: [Name] with R²=[value], RMSE=[value]
-                  - Parameters: μmax=[value], Xmax=[value], etc.
-                  - Ranking of all biomass models tested
-                  
-               b) **SUBSTRATE MODELS** (if applicable):
-                  - Best model: [Name] with R²=[value], RMSE=[value]
-                  - Parameters: Ks=[value], Yxs=[value], etc.
-                  - Ranking of all substrate models tested
-                  
-               c) **PRODUCT MODELS** (if applicable):
-                  - Best model: [Name] with R²=[value], RMSE=[value]
-                  - Parameters: α=[value], β=[value], etc.
-                  - Ranking of all product models tested
-            
-            4. **DETAILED COMPARATIVE TABLES**
-               
-               **Table 1: Summary by Experiment and Variable Type**
-               | Experiment | Variable | Best Model | R² | RMSE | Key Parameters | Ranking |
-               |------------|----------|------------|-------|------|----------------|---------|
-               | Exp1       | Biomass  | [Name]     | [val] | [val]| μmax=X         | 1       |
-               | Exp1       | Substrate| [Name]     | [val] | [val]| Ks=Y           | 1       |
-               | Exp1       | Product  | [Name]     | [val] | [val]| α=Z            | 1       |
-               | Exp2       | Biomass  | [Name]     | [val] | [val]| μmax=X2        | 1       |
-               
-               **Table 2: Complete Model Comparison Across All Experiments**
-               | Model Name | Type | Exp1_R² | Exp1_RMSE | Exp2_R² | Exp2_RMSE | Avg_R² | Best_For |
-            
-            5. **PARAMETER ANALYSIS ACROSS EXPERIMENTS**
-               - Compare how parameters change between experiments
-               - Identify trends (e.g., μmax increases with temperature)
-               - Calculate average parameters and variability
-               - Suggest optimal conditions based on parameters
-            
-            6. **BIOLOGICAL INTERPRETATION BY EXPERIMENT**
-               For each experiment, explain:
-               - What the parameter values mean biologically
-               - Whether values are realistic for the conditions
-               - Key differences between experiments
-               - Critical control parameters identified
-            
-            7. **OVERALL BEST MODELS DETERMINATION**
-               - **BEST BIOMASS MODEL OVERALL**: [Name] - performs best in [X] out of [Y] experiments
-               - **BEST SUBSTRATE MODEL OVERALL**: [Name] - average R²=[value]
-               - **BEST PRODUCT MODEL OVERALL**: [Name] - most consistent across conditions
-               
-               Justify with numerical evidence from multiple experiments.
-            
-            8. **CONCLUSIONS AND RECOMMENDATIONS**
-               - Which models are most robust across different conditions
-               - Specific models to use for each experimental condition
-               - Confidence intervals and prediction reliability
-               - Scale-up recommendations with specific values
-            
-            Use Markdown format with clear structure. Include ALL numerical values from the data.
-            Create clear sections for EACH EXPERIMENT.
-            """
-        else:  # summarized
-            prompt = f"""
-            {lang_prefix}
-            
-            You are an expert in biotechnology. Provide a CONCISE but COMPLETE analysis BY EXPERIMENT.
-            
-            {user_specs_section}
-            
-            DETAIL LEVEL: SUMMARIZED - Be concise but include all experiments and essential information
-            
-            PROVIDE A FOCUSED COMPARATIVE ANALYSIS:
-            
-            1. **EXPERIMENTS OVERVIEW**
-               - Total experiments analyzed: [number]
-               - Conditions tested: [list]
-               - Variables measured: biomass/substrate/product
-            
-            2. **BEST MODELS BY EXPERIMENT - QUICK SUMMARY**
-               
-               📊 **EXPERIMENT 1 [Name/Condition]:**
-               - Biomass: [Model] (R²=[value])
-               - Substrate: [Model] (R²=[value])  
-               - Product: [Model] (R²=[value])
-               
-               📊 **EXPERIMENT 2 [Name/Condition]:**
-               - Biomass: [Model] (R²=[value])
-               - Substrate: [Model] (R²=[value])
-               - Product: [Model] (R²=[value])
-               
-               [Continue for all experiments...]
-            
-            3. **OVERALL WINNERS ACROSS ALL EXPERIMENTS**
-               🏆 **Best Models Overall:**
-               - **Biomass**: [Model] - Best in [X]/[Y] experiments
-               - **Substrate**: [Model] - Average R²=[value]
-               - **Product**: [Model] - Most consistent performance
-            
-            4. **QUICK COMPARISON TABLE**
-               | Experiment | Best Biomass | Best Substrate | Best Product | Overall R² |
-               |------------|--------------|----------------|--------------|------------|
-               | Exp1       | [Model]      | [Model]        | [Model]      | [avg]      |
-               | Exp2       | [Model]      | [Model]        | [Model]      | [avg]      |
-            
-            5. **KEY FINDINGS**
-               - Parameter ranges across experiments: μmax=[min-max], Ks=[min-max]
-               - Best conditions identified: [specific values]
-               - Most robust models: [list with reasons]
-            
-            6. **PRACTICAL RECOMMENDATIONS**
-               - For biomass prediction: Use [Model]
-               - For substrate monitoring: Use [Model]
-               - For product estimation: Use [Model]
-               - Critical parameters: [list with values]
-            
-            Keep it concise but include ALL experiments and model names with their key metrics.
-            """
-        
+
         try:
-            # CAMBIO: Llamada a la API y acceso a la respuesta
             response = self.client.chat.completions.create(
-                model=nebius_model,
+                model=model,
                 temperature=0.6,
                 top_p=0.95,
-                max_tokens=4000,
-                messages=[{
-                    "role": "user",
-                    "content": f"{prompt}\n\n{data_summary}"
-                }]
+                max_tokens=4000, # Usar un valor alto para permitir respuestas completas
+                messages=[{"role": "user", "content": prompt}]
             )
             
-            # 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.to_string()}
-            
-            Generate Python code that:
-            
-            1. Creates a complete analysis system with the ACTUAL NUMERICAL VALUES from the data
-            2. Implements analysis BY EXPERIMENT showing:
-               - Best models for each experiment
-               - Comparison across experiments
-               - Parameter evolution between conditions
-            3. Includes visualization functions that:
-               - Show results PER EXPERIMENT
-               - Compare models across experiments
-               - Display parameter trends
-            4. Shows the best model for biomass, substrate, and product separately
-            
-            The code must include:
-            - Data loading with experiment identification
-            - Model comparison by experiment and variable type
-            - Visualization showing results per experiment
-            - Overall best model selection with justification
-            - Functions to predict using the best models for each category
+            raw_response_text = response.choices[0].message.content
             
-            Make sure to include comments indicating which model won for each variable type and why.
-            
-            Format: Complete, executable Python code with actual data values embedded.
-            """
-            
-            # CAMBIO: Llamada a la API y acceso a la respuesta
-            code_response = self.client.chat.completions.create(
-                model=nebius_model,
-                temperature=0.6,
-                top_p=0.95,
-                max_tokens=3000,
-                messages=[{
-                    "role": "user",
-                    "content": code_prompt
-                }]
-            )
-            
-            return {
-                "tipo": "Comparative Analysis of Mathematical Models",
-                "analisis_completo": response.choices[0].message.content,
-                "codigo_implementacion": code_response.choices[0].message.content,
-                "resumen_datos": {
-                    "n_modelos": len(data),
-                    "columnas": list(data.columns),
-                    "metricas_disponibles": [col for col in data.columns if any(metric in col.lower() 
-                                           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
+            # Intentar parsear la respuesta JSON
+            try:
+                # Limpiar el texto para asegurar que sea un JSON válido
+                json_text = raw_response_text[raw_response_text.find('{'):raw_response_text.rfind('}')+1]
+                parsed_json = json.loads(json_text)
+                return {
+                    "analysis": parsed_json.get("analysis", "API did not return an analysis."),
+                    "code": parsed_json.get("code", "# API did not return code.")
                 }
-            }
-            
+            except (json.JSONDecodeError, IndexError):
+                # Si falla el parseo, devolver el texto crudo como análisis
+                return {
+                    "analysis": f"API returned a non-JSON response:\n\n{raw_response_text}",
+                    "code": "# Could not parse API response to extract code."
+                }
+
         except Exception as e:
-            return {"error": str(e)}
+            error_message = f"An error occurred while calling the API: {str(e)}"
+            return {
+                "analysis": error_message,
+                "code": f"# {error_message}"
+            }
+
+def process_files(files: List, model: str, detail_level: str, language: str, additional_specs: str) -> Tuple[str, str]:
+    """
+    Procesa los archivos subidos, llama al analizador de IA y devuelve los resultados.
+    """
+    if not files:
+        return TRANSLATIONS[language]['error_no_files'], ""
 
-def process_files(files, model_name: 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)
-    results = []
-    all_code = []
+    analyzer = AIAnalyzer(client)
     
+    # Por simplicidad, se procesa solo el primer archivo válido
+    full_analysis = []
+    full_code = []
+
     for file in files:
-        if file is None:
-            continue
-            
-        file_name = file.name if hasattr(file, 'name') else "archivo"
+        if file is None: continue
+        
+        file_name = file.name
         file_ext = Path(file_name).suffix.lower()
         
         with open(file.name, 'rb') as f:
             file_content = f.read()
         
-        if file_ext in ['.csv', '.xlsx', '.xls']:
-            if language == 'es':
-                results.append(f"## 📊 Análisis de Resultados: {file_name}")
-            else:
-                results.append(f"## 📊 Results Analysis: {file_name}")
-            
-            if file_ext == '.csv':
-                df = processor.read_csv(file_content)
-            else:
-                df = processor.read_excel(file_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, model_name, detail_level, language, additional_specs
-                    )
-                    
-                    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"])
-        
-        results.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)
-    
-    return analysis_text, code_text
-
-def generate_implementation_code(analysis_results: str) -> str:
-    """Genera código de implementación con análisis por experimento"""
-    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_analysis = ""
-        self.current_code = ""
-        self.current_language = "en"
-
-app_state = AppState()
+        df = None
+        if file_ext == '.csv':
+            df = processor.read_csv(file_content)
+        elif file_ext in ['.xlsx', '.xls']:
+            df = processor.read_excel(file_content)
+        
+        if df is not None:
+            full_analysis.append(f"# Analysis for: {file_name}")
+            api_result = analyzer.get_analysis_and_code(df, model, detail_level, language, additional_specs)
+            full_analysis.append(api_result.get("analysis", ""))
+            full_code.append(f"# Code generated for: {file_name}\n" + api_result.get("code", ""))
+            # Rompemos el bucle para analizar solo un archivo a la vez y evitar confusión
+            break 
+    
+    if not full_analysis:
+        return "No valid CSV/Excel files found to analyze.", ""
 
-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"
-        }
-        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)}", ""
+    return "\n\n".join(full_analysis), "\n\n".join(full_code)
 
-# Interfaz Gradio con soporte multiidioma y temas
+# --- Interfaz de Gradio ---
 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
+    current_language = "es"
+
+    def update_language(language):
         t = TRANSLATIONS[language]
-        
         return [
-            gr.update(value=f"# {t['title']}"),  # title_text
-            gr.update(value=t['subtitle']),       # subtitle_text
-            gr.update(label=t['upload_files']),   # files_input
-            gr.update(label=t['select_model']),   # model_selector
-            gr.update(label=t['select_language']), # language_selector
-            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(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['comparative_analysis']), # analysis_output
-            gr.update(label=t['implementation_code']),  # code_output
-            gr.update(label=t['data_format'])    # data_format_accordion
+            gr.update(value=f"# {t['title']}"), gr.update(value=t['subtitle']),
+            gr.update(label=t['upload_files']), gr.update(label=t['select_model']),
+            gr.update(label=t['select_language']), gr.update(label=t['detail_level']),
+            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']),
+            gr.update(value=t['analyze_button']), gr.update(label=t['export_format']),
+            gr.update(value=t['export_button']), gr.update(label=t['comparative_analysis']),
+            gr.update(label=t['implementation_code']), gr.update(label=t['data_format'])
         ]
-    
-    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, ""
-        
-        analysis, code = process_files(files, model, detail, language, additional_specs)
-        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.Blocks(theme=gr.themes.Soft()) as demo:
+        app_state = gr.State({"analysis": "", "code": "", "language": "es"})
+
+        title_text = gr.Markdown(f"# {TRANSLATIONS[current_language]['title']}")
+        subtitle_text = gr.Markdown(TRANSLATIONS[current_language]['subtitle'])
         
         with gr.Row():
             with gr.Column(scale=1):
-                files_input = gr.File(
-                    label=TRANSLATIONS[current_language]['upload_files'],
-                    file_count="multiple",
-                    file_types=[".csv", ".xlsx", ".xls", ".pdf", ".zip"],
-                    type="filepath"
-                )
+                files_input = gr.File(label=TRANSLATIONS[current_language]['upload_files'], file_count="multiple", file_types=[".csv", ".xlsx", ".xls"], type="filepath")
                 
-                # CAMBIO: Usar el diccionario de modelos de Nebius
                 default_model = "Qwen/Qwen3-14B"
-                model_selector = gr.Dropdown(
-                    choices=list(NEBIUS_MODELS.keys()),
-                    value=default_model,
-                    label=TRANSLATIONS[current_language]['select_model'],
-                    info=f"{TRANSLATIONS[current_language]['best_for']}: {NEBIUS_MODELS[default_model]['best_for']}"
-                )
-                
-                detail_level = gr.Radio(
-                    choices=[
-                        (TRANSLATIONS[current_language]['detailed'], "detailed"),
-                        (TRANSLATIONS[current_language]['summarized'], "summarized")
-                    ],
-                    value="detailed",
-                    label=TRANSLATIONS[current_language]['detail_level']
-                )
+                model_selector = gr.Dropdown(choices=list(NEBIUS_MODELS.keys()), value=default_model, label=TRANSLATIONS[current_language]['select_model'])
                 
-                # Nueva entrada para especificaciones adicionales
-                additional_specs = gr.Textbox(
-                    label=TRANSLATIONS[current_language]['additional_specs'],
-                    placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'],
-                    lines=3,
-                    max_lines=5,
-                    interactive=True
-                )
+                detail_level_selector = gr.Radio(choices=[(TRANSLATIONS[current_language]['detailed'], "detailed"), (TRANSLATIONS[current_language]['summarized'], "summarized")], value="detailed", label=TRANSLATIONS[current_language]['detail_level'])
                 
-                analyze_btn = gr.Button(
-                    TRANSLATIONS[current_language]['analyze_button'],
-                    variant="primary",
-                    size="lg"
-                )
-                
-                gr.Markdown("---")
+                additional_specs_input = gr.Textbox(label=TRANSLATIONS[current_language]['additional_specs'], placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'], lines=3)
                 
-                export_format = gr.Radio(
-                    choices=["DOCX", "PDF"],
-                    value="PDF",
-                    label=TRANSLATIONS[current_language]['export_format']
-                )
+                language_selector = gr.Dropdown(choices=[("English", "en"), ("Español", "es")], value="es", label=TRANSLATIONS[current_language]['select_language'])
                 
-                export_btn = gr.Button(
-                    TRANSLATIONS[current_language]['export_button'],
-                    variant="secondary"
-                )
+                analyze_btn = gr.Button(TRANSLATIONS[current_language]['analyze_button'], variant="primary")
                 
-                export_status = gr.Textbox(
-                    label="Export Status",
-                    interactive=False,
-                    visible=False
-                )
+                gr.Markdown("---")
                 
-                export_file = gr.File(
-                    label="Download Report",
-                    visible=False
-                )
-            
+                export_format_selector = gr.Radio(choices=["DOCX", "PDF"], value="PDF", label=TRANSLATIONS[current_language]['export_format'])
+                export_btn = gr.Button(TRANSLATIONS[current_language]['export_button'])
+                export_file_output = gr.File(label="Download Report", visible=False)
+
             with gr.Column(scale=2):
-                analysis_output = gr.Markdown(
-                    label=TRANSLATIONS[current_language]['comparative_analysis']
-                )
-                
-                code_output = gr.Code(
-                    label=TRANSLATIONS[current_language]['implementation_code'],
-                    language="python",
-                    interactive=True,
-                    lines=20
-                )
-        
-        data_format_accordion = gr.Accordion(
-            label=TRANSLATIONS[current_language]['data_format'],
-            open=False
-        )
-        
-        with data_format_accordion:
-            gr.Markdown("""
-            ### Expected CSV/Excel structure:
+                analysis_output = gr.Markdown(label=TRANSLATIONS[current_language]['comparative_analysis'])
+                code_output = gr.Code(label=TRANSLATIONS[current_language]['implementation_code'], language="python", interactive=True)
+
+        def run_analysis(files, model, detail, lang, specs, state):
+            analysis, code = process_files(files, model, detail, lang, specs)
+            state["analysis"] = analysis
+            state["code"] = code
+            state["language"] = lang
+            return analysis, code, state
+
+        def run_export(state, format):
+            if not state["analysis"]:
+                return gr.update(visible=False)
             
-            | Experiment | Model | Type | R2 | RMSE | AIC | BIC | mu_max | Ks | Parameters |
-            |------------|-------|------|-----|------|-----|-----|--------|-------|------------|
-            | pH_7.0 | Monod | Biomass | 0.985 | 0.023 | -45.2 | -42.1 | 0.45 | 2.1 | {...} |
-            | pH_7.0 | Logistic | Biomass | 0.976 | 0.031 | -42.1 | -39.5 | 0.42 | - | {...} |
-            | pH_7.0 | First_Order | Substrate | 0.992 | 0.018 | -48.5 | -45.2 | - | 1.8 | {...} |
-            | pH_7.5 | Monod | Biomass | 0.978 | 0.027 | -44.1 | -41.2 | 0.43 | 2.2 | {...} |
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            ext = "docx" if format == "DOCX" else "pdf"
+            filename = f"analysis_report_{timestamp}.{ext}"
             
-            **Important columns:**
-            - **Experiment**: Experimental condition identifier
-            - **Model**: Model name
-            - **Type**: Variable type (Biomass/Substrate/Product)
-            - **R2, RMSE**: Fit quality metrics
-            - **Parameters**: Model-specific parameters
-            """)
-        
-        # CAMBIO: Actualizar el modelo en los ejemplos
-        examples = gr.Examples(
-            examples=[
-                [["examples/biomass_models_comparison.csv"], "Qwen/Qwen3-14B", "detailed", ""],
-                [["examples/substrate_kinetics_results.xlsx"], "Qwen/Qwen3-14B", "summarized", "Focus on temperature effects"]
-            ],
-            inputs=[files_input, model_selector, detail_level, additional_specs],
-            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, additional_specs,
-                analyze_btn, export_format, export_btn, analysis_output, 
-                code_output, data_format_accordion
-            ]
-        )
-        
-        def change_theme(theme_name):
-            """Cambia el tema de la interfaz"""
-            return gr.Info("Theme will be applied on next page load")
-        
-        theme_selector.change(
-            change_theme,
-            inputs=[theme_selector],
-            outputs=[]
-        )
-        
+            if format == "DOCX":
+                ReportExporter.export_to_docx(state["analysis"], filename, state["language"])
+            else:
+                ReportExporter.export_to_pdf(state["analysis"], filename, state["language"])
+            
+            return gr.update(value=filename, visible=True)
+
         analyze_btn.click(
-            fn=process_and_store,
-            inputs=[files_input, model_selector, detail_level, language_selector, additional_specs],
-            outputs=[analysis_output, code_output]
+            fn=run_analysis,
+            inputs=[files_input, model_selector, detail_level_selector, language_selector, additional_specs_input, app_state],
+            outputs=[analysis_output, code_output, app_state]
         )
         
-        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]
+            fn=run_export,
+            inputs=[app_state, export_format_selector],
+            outputs=[export_file_output]
         )
-    
+
     return demo
 
-# Función principal
 def main():
-    # CAMBIO: Comprobar la nueva variable de entorno
     if not os.getenv("NEBIUS_API_KEY"):
-        print("⚠️ Configure NEBIUS_API_KEY in HuggingFace Space secrets")
-        return gr.Interface(
-            fn=lambda x: TRANSLATIONS['en']['error_no_api'],
-            inputs=gr.Textbox(),
-            outputs=gr.Textbox(),
-            title="Configuration Error"
-        )
+        print("⚠️ NEBIUS_API_KEY not found. Please set it as an environment variable.")
+        return gr.Interface(fn=lambda: TRANSLATIONS['en']['error_no_api'], inputs=[], outputs="text", title="Configuration Error")
     
     return create_interface()
 
-# Para ejecución local
 if __name__ == "__main__":
+    # Crear archivos de ejemplo para Gradio si no existen
+    if not os.path.exists("examples"):
+        os.makedirs("examples")
+    if not os.path.exists("examples/biomass_models_comparison.csv"):
+        pd.DataFrame({
+            'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5'],
+            'Model': ['Monod', 'Logistic', 'Monod', 'Logistic'],
+            'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass'],
+            'R2': [0.98, 0.99, 0.97, 0.985],
+            'RMSE': [0.02, 0.01, 0.03, 0.015]
+        }).to_csv("examples/biomass_models_comparison.csv", index=False)
+
     demo = main()
     if demo:
-        # Para crear los archivos de ejemplo si no existen
-        if not os.path.exists("examples"):
-            os.makedirs("examples")
-        if not os.path.exists("examples/biomass_models_comparison.csv"):
-            pd.DataFrame({
-                'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.5'],
-                'Model': ['Monod', 'Logistic', 'Gompertz', 'Monod', 'Logistic', 'Gompertz'],
-                'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass'],
-                'R2': [0.98, 0.99, 0.995, 0.97, 0.98, 0.99],
-                'RMSE': [0.02, 0.01, 0.005, 0.03, 0.02, 0.01]
-            }).to_csv("examples/biomass_models_comparison.csv", index=False)
-        if not os.path.exists("examples/substrate_kinetics_results.xlsx"):
-             pd.DataFrame({
-                'Experiment': ['Temp_30C', 'Temp_30C', 'Temp_37C', 'Temp_37C'],
-                'Model': ['First_Order', 'Monod_Substrate', 'First_Order', 'Monod_Substrate'],
-                'Type': ['Substrate', 'Substrate', 'Substrate', 'Substrate'],
-                'R2': [0.97, 0.98, 0.96, 0.985],
-                'RMSE': [0.03, 0.02, 0.04, 0.015]
-            }).to_excel("examples/substrate_kinetics_results.xlsx", index=False)
-
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
-        )
+        demo.launch(server_name="0.0.0.0", server_port=7860)