Update app.py

app.py

@@ -1,837 +1,423 @@
 import gradio as gr
-import PyPDF2
+from gradio_client import Client, handle_file
 import pandas as pd
-import numpy as np
-import io
-import os
 import json
-import zipfile
 import tempfile
-from typing import Dict, List, Tuple, Union, Optional, Generator
-import re
-from pathlib import Path
-import openpyxl
-from dataclasses import dataclass, asdict
-from enum import Enum
-from docx import Document
-from docx.shared import Inches, Pt, RGBColor
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter, A4
-from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import inch
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-import matplotlib.pyplot as plt
+import os
 from datetime import datetime
-from openai import OpenAI
-
-# --- CONFIGURACIÓN Y CONSTANTES ---
-os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
-
-client = OpenAI(
-    base_url="https://api.studio.nebius.com/v1/",
-    api_key=os.environ.get("NEBIUS_API_KEY")
-)
-
-# Se añade la nueva etiqueta para el selector de columna
-TRANSLATIONS = {
-    'en': {
-        'title': '🧬 Scalable Biotech Model Analyzer',
-        'subtitle': 'Analyzes large sets of model fitting results using a chunking strategy',
-        'upload_files': '📁 Upload fitting results (CSV/Excel)',
-        'chunk_column_label': '🔬 Select Column for Grouping Experiments',
-        'chunk_column_info': 'Choose the column that identifies each unique experiment. This is used for chunking.',
-        'select_model': '🤖 IA Model (editable)',
-        'select_language': '🌐 Language',
-        'select_theme': '🎨 Theme',
-        'detail_level': '📋 Analysis detail level',
-        'detailed': 'Detailed',
-        'summarized': 'Summarized',
-        'analyze_button': '🚀 Analyze and Compare Models',
-        'export_format': '📄 Export format',
-        'export_button': '💾 Export Report',
-        'comparative_analysis': '📊 Comparative Analysis',
-        'implementation_code': '💻 Implementation Code',
-        'data_format': '📋 Expected data format',
-        'loading': 'Loading...',
-        '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',
-        'additional_specs': '📝 Additional specifications for analysis',
-        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...',
-        'output_tokens_per_chunk': '🔢 Max output tokens per chunk (1k-32k)',
-        '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'
-    },
-    'es': {
-        'title': '🧬 Analizador Escalable de Modelos Biotecnológicos',
-        'subtitle': 'Analiza grandes conjuntos de datos de ajuste de modelos usando una estrategia por partes',
-        'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
-        'chunk_column_label': '🔬 Seleccionar Columna para Agrupar Experimentos',
-        'chunk_column_info': 'Elige la columna que identifica cada experimento único. Se usará para dividir el análisis.',
-        'select_model': '🤖 Modelo IA (editable)',
-        'select_language': '🌐 Idioma',
-        'select_theme': '🎨 Tema',
-        'detail_level': '📋 Nivel de detalle del análisis',
-        'detailed': 'Detallado',
-        'summarized': 'Resumido',
-        'analyze_button': '🚀 Analizar y Comparar Modelos',
-        'export_format': '📄 Formato de exportación',
-        'export_button': '💾 Exportar Reporte',
-        'comparative_analysis': '📊 Análisis Comparativo',
-        'implementation_code': '💻 Código de Implementación',
-        'data_format': '📋 Formato de datos esperado',
-        'loading': 'Cargando...',
-        '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',
-        'additional_specs': '📝 Especificaciones adicionales para el análisis',
-        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...',
-        'output_tokens_per_chunk': '🔢 Max tokens de salida por pieza (1k-32k)',
-        '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'
-    }
-}
-THEMES = { 'light': gr.themes.Soft(), 'dark': gr.themes.Base() }
-
-QWEN_MODELS = {
-    "Qwen/Qwen3-14B": {"max_context_tokens": 40960, "input_cost": 0.0000007, "output_cost": 0.0000021},
-    "Qwen/Qwen3-7B": {"max_context_tokens": 40960, "input_cost": 0.00000035, "output_cost": 0.00000105},
-    "Qwen/Qwen1.5-14B": {"max_context_tokens": 40960, "input_cost": 0.0000007, "output_cost": 0.0000021}
-}
-
-# --- CLASES DE UTILIDAD (Se asume que existen, omitidas por brevedad) ---
-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
-    
-    @staticmethod
-    def extract_from_zip(zip_file) -> List[Tuple[str, bytes]]:
-        """Extrae archivos de un ZIP"""
-        files = []
+import plotly.graph_objects as go
+import plotly.express as px
+import numpy as np
+from smolagents import CodeAgent, tool, InferenceClientModel
+import logging
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- INICIO DE CONFIGURACIÓN DE CLIENTES ---
+# Se inicializan ambos clientes para el pipeline de dos etapas
+try:
+    biotech_client = Client("C2MV/BiotechU4")
+    logger.info("✅ Cliente BiotechU4 inicializado correctamente.")
+except Exception as e:
+    logger.error(f"❌ No se pudo inicializar el cliente de BiotechU4: {e}")
+    biotech_client = None
+
+try:
+    analysis_client = Client("C2MV/Project-HF-2025-2")
+    logger.info("✅ Cliente Project-HF-2025-2 inicializado correctamente.")
+except Exception as e:
+    logger.error(f"❌ No se pudo inicializar el cliente de Project-HF-2025-2: {e}")
+    analysis_client = None
+
+# Configuración del motor de Hugging Face (opcional)
+try:
+    hf_engine = InferenceClientModel(model_id="mistralai/Mistral-7B-Instruct-v0.2")
+except Exception:
+    logger.warning("No se pudo inicializar el modelo de HF. Los agentes usarán lógica simple.")
+    hf_engine = None
+
+# ============================================================================
+# 🤖 SISTEMA DE AGENTES (Conservado y adaptado)
+# ============================================================================
+class BiotechAgentTools:
+    @tool
+    def analyze_data_characteristics(data_info: str) -> dict:
+        """
+        Analiza las características de los datos biotecnológicos subidos.
+        Args:
+            data_info (str): Información sobre el archivo de datos incluyendo nombre, tipo y contenido
+        Returns:
+            dict: Diccionario con tipo de experimento, modelos recomendados, parámetros sugeridos y calidad de datos
+        """
         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
-
-class ReportExporter:
-    """Clase para exportar reportes a diferentes formatos"""
-    
-    @staticmethod
-    def export_to_docx(content: str, filename: str, language: str = 'en') -> str:
-        """Exporta el contenido a un archivo DOCX"""
-        doc = Document()
-        
-        # Configurar estilos
-        title_style = doc.styles['Title']
-        title_style.font.size = Pt(24)
-        title_style.font.bold = True
-        
-        heading_style = doc.styles['Heading 1']
-        heading_style.font.size = Pt(18)
-        heading_style.font.bold = True
-        
-        # Título
-        title_text = {
-            'en': 'Comparative Analysis Report - Biotechnological Models',
-            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
-        }
-        
-        doc.add_heading(title_text.get(language, title_text['en']), 0)
-        
-        # Fecha
-        date_text = {
-            'en': 'Generated on',
-            'es': 'Generado el',
-        }
-        doc.add_paragraph(f"{date_text.get(language, date_text['en'])}: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        doc.add_paragraph()
-        
-        # Procesar contenido
-        lines = content.split('\n')
-        current_paragraph = None
-        
-        for line in lines:
-            line = line.strip()
-            
-            if line.startswith('###'):
-                doc.add_heading(line.replace('###', '').strip(), level=2)
-            elif line.startswith('##'):
-                doc.add_heading(line.replace('##', '').strip(), level=1)
-            elif line.startswith('#'):
-                doc.add_heading(line.replace('#', '').strip(), level=0)
-            elif line.startswith('**') and line.endswith('**'):
-                # Texto en negrita
-                p = doc.add_paragraph()
-                run = p.add_run(line.replace('**', ''))
-                run.bold = True
-            elif line.startswith('- ') or line.startswith('* '):
-                # Lista
-                doc.add_paragraph(line[2:], style='List Bullet')
-            elif line.startswith(tuple('0123456789')):
-                # Lista numerada
-                doc.add_paragraph(line, style='List Number')
-            elif line == '---' or line.startswith('==='):
-                # Separador
-                doc.add_paragraph('_' * 50)
-            elif line:
-                # Párrafo normal
-                doc.add_paragraph(line)
-        
-        # Guardar documento
-        doc.save(filename)
-        return filename
-    
-    @staticmethod
-    def export_to_pdf(content: str, filename: str, language: str = 'en') -> str:
-        """Exporta el contenido a un archivo PDF"""
-        # Crear documento PDF
-        doc = SimpleDocTemplate(filename, pagesize=letter)
-        story = []
-        styles = getSampleStyleSheet()
-        
-        # Estilos personalizados
-        title_style = ParagraphStyle(
-            'CustomTitle',
-            parent=styles['Title'],
-            fontSize=24,
-            textColor=colors.HexColor('#1f4788'),
-            spaceAfter=30
-        )
-        
-        heading_style = ParagraphStyle(
-            'CustomHeading',
-            parent=styles['Heading1'],
-            fontSize=16,
-            textColor=colors.HexColor('#2e5090'),
-            spaceAfter=12
-        )
-        
-        # Título
-        title_text = {
-            'en': 'Comparative Analysis Report - Biotechnological Models',
-            'es': 'Informe de Análisis Comparativo - Modelos Biotecnológicos',
-        }
-        
-        story.append(Paragraph(title_text.get(language, title_text['en']), title_style))
-        
-        # Fecha
-        date_text = {
-            'en': 'Generated on',
-            'es': 'Generado el',
-        }
-        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))
+            characteristics = {"experiment_type": "unknown", "recommended_models": [], "suggested_params": {}, "data_quality": "good"}
+            data_lower = data_info.lower()
+            models_from_docs = ['logistic', 'gompertz', 'moser', 'baranyi', 'monod', 'contois', 'andrews', 'tessier', 'richards', 'stannard', 'huang']
+            growth_models = [m for m in ['logistic', 'gompertz', 'baranyi', 'richards'] if m in models_from_docs]
+            fermentation_models = [m for m in ['monod', 'contois', 'andrews', 'moser'] if m in models_from_docs]
+            if "biomass" in data_lower or "growth" in data_lower:
+                characteristics.update({"experiment_type": "growth_kinetics", "recommended_models": growth_models, "suggested_params": {"component": "biomass", "use_de": True, "maxfev": 75000}})
+            elif "ferment" in data_lower or "substrate" in data_lower:
+                characteristics.update({"experiment_type": "fermentation", "recommended_models": fermentation_models,"suggested_params": {"component": "all", "use_de": False, "maxfev": 50000}})
             else:
-                # Limpiar caracteres especiales para PDF
-                clean_line = line.replace('📊', '[GRAPH]').replace('🎯', '[TARGET]').replace('🔍', '[SEARCH]').replace('💡', '[TIP]')
-                story.append(Paragraph(clean_line, styles['Normal']))
-        
-        # Construir PDF
-        doc.build(story)
-        return filename
-
-# --- CLASE AIAnalyzer (MODIFICADA PARA ACEPTAR chunk_column) ---
-class AIAnalyzer:
-    """Clase para análisis con IA que implementa una estrategia 'chunk-and-stitch'."""
-    def __init__(self, client):
-        self.client = client
-        self.token_usage = {}
-        self.reset_token_usage()
-
-    def reset_token_usage(self):
-        self.token_usage = {'input_tokens': 0, 'output_tokens': 0, 'total_tokens': 0, 'estimated_cost': 0.0}
-
-    def _update_token_usage(self, model_name: str, usage):
-        if not usage: return
-        self.token_usage['input_tokens'] += usage.prompt_tokens
-        self.token_usage['output_tokens'] += usage.completion_tokens
-        self.token_usage['total_tokens'] += usage.total_tokens
-        model_info = QWEN_MODELS.get(model_name, {})
-        input_cost = model_info.get('input_cost', 0.0)
-        output_cost = model_info.get('output_cost', 0.0)
-        self.token_usage['estimated_cost'] += (usage.prompt_tokens * input_cost) + (usage.completion_tokens * output_cost)
+                characteristics.update({"experiment_type": "general_biotech", "recommended_models": growth_models, "suggested_params": {"component": "all", "use_de": False, "maxfev": 50000}})
+            logger.info(f"Análisis completado: {characteristics['experiment_type']}")
+            return characteristics
+        except Exception as e:
+            logger.error(f"Error en análisis de datos: {str(e)}")
+            return {"experiment_type": "error", "recommended_models": ['logistic', 'gompertz'], "suggested_params": {"component": "all", "use_de": False, "maxfev": 50000}, "data_quality": "unknown"}
 
-    def _calculate_safe_max_tokens(self, model_name: str, user_requested_tokens: int) -> int:
-        model_info = QWEN_MODELS.get(model_name, {"max_context_tokens": 32768})
-        context_limit = model_info['max_context_tokens']
-        PROMPT_SAFETY_MARGIN = 8192
-        max_allowable_output = context_limit - PROMPT_SAFETY_MARGIN
-        return max(100, min(user_requested_tokens, max_allowable_output))
-####
-    def _analyze_single_experiment(self, experiment_df: pd.DataFrame, experiment_id: str, qwen_model: str, lang_prefix: str, max_output_tokens: int) -> Optional[Dict]:
+    @tool
+    def prepare_ia_context(data_summary: str) -> str:
         """
-        Analiza los resultados de un único experimento (un 'chunk' de datos) y devuelve un JSON estructurado.
-        Esta función es el núcleo de la estrategia 'map' en el enfoque 'map-reduce'.
+        Prepara el contexto específico para el análisis de IA.
+        Args:
+            data_summary (str): Resumen de los datos analizados incluyendo tipo de experimento y resultados
+        Returns:
+            str: Contexto enriquecido y estructurado para el análisis de IA
         """
-        
-        # El prompt es la parte más importante. Está diseñado para ser muy específico y dar un ejemplo claro.
-        prompt = f"""
-    {lang_prefix}
-    You are an expert biotechnological data analyst. Your task is to analyze the provided model fitting results for a single experiment identified as: '{experiment_id}'.
-    The data contains different mathematical models that were fitted to experimental data for variables like Biomass, Substrate, or Product.
-    
-    DATA FOR THIS SPECIFIC EXPERIMENT ('{experiment_id}'):
-    ```
-    {experiment_df.to_string()}
-    ```
-    
-    YOUR INSTRUCTIONS:
-    1.  **Identify Best Models**: For EACH variable type present in the data (e.g., 'Biomass', 'Substrate'), determine the single best-performing model. The best model is the one with the highest R² value. If R² values are equal, use the lowest RMSE as a tie-breaker.
-    2.  **Extract Key Information**: For each of these best models, you must extract:
-        - The model's name.
-        - The specific metrics (R², RMSE, AIC, etc.) as key-value pairs.
-        - All kinetic parameters and their fitted values (e.g., mu_max, Ks) as key-value pairs.
-    3.  **Summarize All Tested Models**: Create a simple list of the names of ALL models that were tested in this experiment, regardless of their performance.
-    4.  **Provide Biological Interpretation**: Write a brief, concise interpretation (2-3 sentences) of what the results for this specific experiment imply. For example, "The selection of the Monod model for biomass with a µ_max of 0.45 suggests rapid growth under these conditions, while the high R² indicates a strong fit."
-    
-    **CRITICAL OUTPUT FORMAT**: You MUST respond ONLY with a single, valid JSON object. Do not add any explanatory text, markdown formatting, or anything else before or after the JSON structure.
-    
-    Follow this EXACT JSON structure:
-    {{
-        "experiment_id": "{experiment_id}",
-        "best_models_by_variable": [
-            {{
-                "variable_type": "Biomass",
-                "model_name": "Name of the best model for Biomass",
-                "metrics": {{
-                    "R2": 0.99,
-                    "RMSE": 0.01,
-                    "AIC": -50.2
-                }},
-                "parameters": {{
-                    "mu_max": 0.5,
-                    "Ks": 10.2
-                }}
-            }},
-            {{
-                "variable_type": "Substrate",
-                "model_name": "Name of the best model for Substrate",
-                "metrics": {{
-                    "R2": 0.98,
-                    "RMSE": 0.05
-                }},
-                "parameters": {{
-                    "k_consumption": 1.5
-                }}
-            }}
-        ],
-        "all_tested_models": ["Monod", "Logistic", "Gompertz", "First_Order"],
-        "interpretation": "A brief, data-driven interpretation of the kinetic behavior observed in this specific experiment."
-    }}
-    """
-        
         try:
-            # Calcular un número seguro de tokens de salida para evitar exceder el límite de contexto del modelo.
-            safe_max_tokens = self._calculate_safe_max_tokens(qwen_model, max_output_tokens)
-            
-            # Realizar la llamada a la API de OpenAI/Nebius
-            response = self.client.chat.completions.create(
-                model=qwen_model,
-                max_tokens=safe_max_tokens,
-                temperature=0.05,  # Temperatura baja para una salida más predecible y estructurada
-                response_format={"type": "json_object"}, # Forza la salida a ser un JSON válido
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant designed to output JSON."},
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            
-            # Actualizar el contador de tokens y el costo estimado.
-            self._update_token_usage(qwen_model, response.usage)
-            
-            # Extraer el contenido de la respuesta.
-            content = response.choices[0].message.content
-            
-            # Parsear la cadena de texto JSON a un diccionario de Python.
-            # Este paso es propenso a errores si el LLM no sigue las instrucciones perfectamente.
-            parsed_json = json.loads(content)
-            return parsed_json
-    
-        except json.JSONDecodeError as e:
-            # Capturar errores si la respuesta del modelo no es un JSON válido.
-            print(f"CRITICAL ERROR: Failed to decode JSON for experiment '{experiment_id}'.")
-            print(f"JSONDecodeError: {e}")
-            print(f"LLM Raw Output that caused the error:\n---\n{content}\n---")
-            return None # Devolver None para indicar que el análisis de este chunk falló.
-        
+            enhanced_context = f"""CONTEXTO BIOTECNOLÓGICO ESPECÍFICO:
+            Resultados del modelado: {data_summary}
+            Por favor, enfócate en:
+            1. Interpretación biológica de los parámetros ajustados (ej. μmax, Ks, Yx/s).
+            2. Comparación de la bondad de ajuste entre modelos (R², RMSE).
+            3. Implicaciones prácticas para el proceso biotecnológico.
+            4. Recomendaciones para la optimización del proceso basadas en los modelos.
+            5. Identificación de posibles limitaciones o artefactos en los datos o modelos.
+            Incluye un análisis estadístico riguroso y recomendaciones prácticas y accionables."""
+            logger.info("Contexto preparado para la IA")
+            return enhanced_context
         except Exception as e:
-            # Capturar otros errores de la API (ej. problemas de red, clave inválida, etc.).
-            print(f"API Error during single analysis for experiment '{experiment_id}': {e}")
-            return None # Devolver None para que el proceso principal pueda saltar este chunk.
+            logger.error(f"Error preparando contexto: {str(e)}")
+            return data_summary
 
-####    
-    def _synthesize_comparative_analysis(self, individual_analyses: List[Dict], qwen_model: str, detail_level: str, lang_prefix: str, additional_specs: str, max_output_tokens: int) -> str:
-        """
-        Sintetiza los análisis individuales (JSONs) en un reporte comparativo final en formato Markdown.
-        Esta es la etapa 'reduce' del proceso.
-        """
-        
-        # 1. Preparar los datos de entrada para el modelo.
-        # Convertimos la lista de diccionarios de Python a una cadena de texto JSON bien formateada.
-        # Esto es lo que el LLM verá como su "base de conocimiento".
-        analyses_summary = json.dumps(individual_analyses, indent=2)
-    
-        # 2. Construir el prompt de síntesis.
-        # Este prompt es más conceptual que el anterior. Le pide al modelo que actúe como un científico senior.
-        
-        # Sección para las especificaciones adicionales del usuario.
-        user_specs_section = f"""
-        ## User's Additional Specifications
-        Please pay special attention to the following user-provided requirements during your analysis:
-        - {additional_specs}
-        """ if additional_specs else ""
-    
-        # Instrucción de nivel de detalle basada en la selección del usuario.
-        detail_instruction = (
-            "Your report must be highly detailed and exhaustive. Include multiple tables, in-depth parameter comparisons, and nuanced biological interpretations."
-            if detail_level == "detailed" else
-            "Your report should be a high-level summary. Focus on the main conclusions and key takeaways, using concise tables and bullet points."
-        )
-    
-        prompt = f"""
-    {lang_prefix}
-    You are a Principal Scientist tasked with creating a final, consolidated report from a series of individual experimental analyses.
-    You have been provided with a JSON array, where each object represents the detailed analysis of one specific experiment.
-    
-    {user_specs_section}
-    
-    YOUR PRIMARY OBJECTIVE:
-    Synthesize all the provided information into a single, cohesive, and comparative analysis report. The report must be written in rich Markdown format.
-    {detail_instruction}
-    
-    Your final report MUST contain the following sections:
-    
-    ### 1. Executive Summary & Experimental Inventory
-    - Start with a brief paragraph summarizing the scope of the experiments analyzed.
-    - Create a Markdown table that serves as an inventory of all experiments. The table should list each `experiment_id`, the `variable_type` (e.g., Biomass), and the `model_name` of the best-performing model for that variable.
-    
-    ### 2. In-Depth Comparative Analysis
-    - **Model Performance Matrix:** This is the most critical part. Create a Markdown table that compares the performance of all major models across all experiments. Use R² as the primary metric. Rows should be model names, and columns should be experiment IDs. This allows for a direct visual comparison of which models are robust across different conditions.
-    - **Parameter Trend Analysis:** Analyze how key kinetic parameters (e.g., `mu_max`, `Ks`, etc.) change across the different experimental conditions. Discuss any observable trends, correlations, or significant differences. For example: "We observed that `mu_max` consistently increased as temperature rose from Exp_A to Exp_C, suggesting a direct correlation in this range."
-    - **Model Selection Justification:** Discuss why certain models performed better under specific conditions, referencing the biological interpretations from the input data.
-    
-    ### 3. Overall Recommendations & Conclusions
-    - **Globally Recommended Models:** Based on the entire dataset, declare the best overall model for each primary variable type (Biomass, Substrate, etc.). Justify your choice based on consistent high performance and robustness across experiments.
-    - **Condition-Specific Guidelines:** Provide actionable recommendations. For example, "For experiments conducted under high pH conditions (similar to 'Exp_C'), the 'Gompertz' model is strongly recommended due to its superior fit."
-    - **Suggestions for Future Research:** Briefly suggest a few next steps or potential experiments to validate the findings or explore new hypotheses.
-    
-    ---
-    **INPUT DATA: JSON ARRAY OF INDIVIDUAL ANALYSES**
-    ```json
-    {analyses_summary}
-    ```
-    ---
-    
-    Now, generate the complete, final Markdown report based on these instructions.
-    """
-    
+class CoordinatorAgent:
+    def __init__(self):
+        self.agent = CodeAgent(tools=[BiotechAgentTools.analyze_data_characteristics, BiotechAgentTools.prepare_ia_context], model=hf_engine) if hf_engine else None
+        self.tools = BiotechAgentTools()
+    def analyze_and_optimize(self, file_info: str, current_config: dict) -> dict:
         try:
-            # Aumentamos el número de tokens de salida solicitados para la etapa de síntesis,
-            # ya que el reporte final puede ser largo. Se multiplica por 2 como heurística.
-            safe_max_tokens = self._calculate_safe_max_tokens(qwen_model, max_output_tokens * 2)
-            
-            # Realizar la llamada a la API
-            response = self.client.chat.completions.create(
-                model=qwen_model,
-                max_tokens=safe_max_tokens,
-                temperature=0.2,  # Una temperatura ligeramente más alta que en el análisis individual para permitir más creatividad en la redacción.
-                messages=[
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            
-            # Actualizar el uso de tokens y el costo.
-            self._update_token_usage(qwen_model, response.usage)
-            
-            # Devolver el contenido del reporte generado.
-            return response.choices[0].message.content
-    
+            logger.info("🤖 Agente Coordinador iniciando análisis...")
+            characteristics = self.tools.analyze_data_characteristics(file_info)
+            optimized_config = current_config.copy()
+            if characteristics["experiment_type"] != "error":
+                # Optimiza parámetros para BiotechU4
+                optimized_config.update({
+                    "models": characteristics["recommended_models"], 
+                    "component": characteristics["suggested_params"]["component"], 
+                    "use_de": characteristics["suggested_params"]["use_de"], 
+                    "maxfev": characteristics["suggested_params"]["maxfev"]
+                })
+                # Optimiza 'additional_specs' para Project-HF-2025-2
+                if characteristics["experiment_type"] == "growth_kinetics":
+                    optimized_config["additional_specs"] = self.tools.prepare_ia_context("Análisis de cinética de crecimiento.")
+                elif characteristics["experiment_type"] == "fermentation":
+                    optimized_config["additional_specs"] = self.tools.prepare_ia_context("Análisis de datos de fermentación.")
+            logger.info(f"✅ Configuración optimizada para: {characteristics['experiment_type']}")
+            return {"config": optimized_config, "analysis": characteristics, "recommendations": f"Configuración optimizada para {characteristics['experiment_type']}"}
         except Exception as e:
-            # Manejar cualquier error durante la llamada a la API de síntesis.
-            error_message = f"CRITICAL ERROR: Failed during the final report synthesis stage. Details: {e}"
-            print(error_message)
-            return error_message
+            logger.error(f"❌ Error en Agente Coordinador: {str(e)}")
+            return {"config": current_config, "analysis": {"experiment_type": "error"}, "recommendations": f"Error en optimización: {str(e)}"}
 
-    # --- DENTRO DE LA CLASE AIAnalyzer ---
-    
-    def analyze_data(self, data: pd.DataFrame, chunk_column: str, qwen_model: str, detail_level: str, language: str, additional_specs: str, max_output_tokens: int) -> Generator[Union[str, Dict], None, None]:
-        """
-        Orquesta el análisis completo como un generador, produciendo actualizaciones de estado.
-        """
-        self.reset_token_usage()
-        
-        if chunk_column not in data.columns:
-            yield {"error": f"The selected chunking column '{chunk_column}' was not found in the data."}
-            return
-        
-        unique_experiments = data[chunk_column].unique()
-        yield f"Identified {len(unique_experiments)} groups to analyze using column '{chunk_column}': {list(unique_experiments)}"
-    
-        individual_results = []
-        lang_prefix = "Please respond in English. " if language == 'en' else "Por favor responde en español. "
-        
-        for i, exp_id in enumerate(unique_experiments):
-            yield f"({i+1}/{len(unique_experiments)}) Analyzing group: '{str(exp_id)}'..."
-            experiment_df = data[data[chunk_column] == exp_id]
-            
-            result = self._analyze_single_experiment(experiment_df, str(exp_id), qwen_model, lang_prefix, max_output_tokens)
-            
-            if result:
-                individual_results.append(result)
-                yield f"✅ Analysis for '{str(exp_id)}' complete."
-            else:
-                yield f"⚠️ Failed to analyze '{str(exp_id)}'. Skipping."
-    
-        if not individual_results:
-            yield {"error": "Could not analyze any of the data groups. Please check data format and API status."}
-            return
-    
-        yield "All groups analyzed. Synthesizing final comparative report..."
-        final_analysis = self._synthesize_comparative_analysis(
-            individual_results, qwen_model, detail_level, lang_prefix, additional_specs, max_output_tokens
+class BiotechAgentSystem:
+    def __init__(self):
+        self.coordinator = CoordinatorAgent()
+        logger.info("🚀 Sistema de agentes inicializado")
+    def process_with_agents(self, file_info: str, user_config: dict) -> dict:
+        try:
+            coordination_result = self.coordinator.analyze_and_optimize(file_info, user_config)
+            return {"success": True, **coordination_result}
+        except Exception as e:
+            logger.error(f"❌ Error en sistema de agentes: {str(e)}")
+            return {"success": False, "config": user_config, "analysis": {"experiment_type": "error"}, "recommendations": f"Error: {str(e)}"}
+
+# ============================================================================
+# ⚙️ FUNCIONES DEL PIPELINE
+# ============================================================================
+agent_system = BiotechAgentSystem()
+
+def create_dummy_plot():
+    fig = go.Figure(go.Scatter(x=[], y=[]))
+    fig.update_layout(title="Esperando resultados...", template="plotly_white", height=500, annotations=[dict(text="Sube un archivo y ejecuta el pipeline para ver los resultados", showarrow=False)])
+    return fig
+
+def parse_plot_data(plot_info):
+    """Parsea la información de la gráfica recibida de la API BiotechU4."""
+    if not plot_info:
+        return create_dummy_plot()
+    try:
+        if isinstance(plot_info, dict) and 'plot' in plot_info:
+            plot_json_string = plot_info['plot']
+            return go.Figure(json.loads(plot_json_string))
+        if isinstance(plot_info, str): return go.Figure(json.loads(plot_info))
+        if isinstance(plot_info, dict): return go.Figure(plot_info)
+    except Exception as e:
+        logger.error(f"Error parsing plot: {e}")
+    return create_dummy_plot()
+
+# --- FUNCIÓN PRINCIPAL DEL PIPELINE COMBINADO ---
+def process_complete_pipeline_with_agents(
+    # Entradas de la UI
+    file, models, component, use_de, maxfev, exp_names, 
+    chunk_column, ia_model, detail_level, language, additional_specs, max_output_tokens,
+    export_format, use_personal_key, personal_api_key,
+    # Progreso
+    progress=gr.Progress()):
+    
+    progress(0, desc="🚀 Iniciando Pipeline...")
+    if not file:
+        return create_dummy_plot(), None, None, None, None, "❌ Por favor, sube un archivo."
+    if not models:
+        return create_dummy_plot(), None, None, None, None, "❌ Por favor, selecciona al menos un modelo para el análisis."
+    
+    progress_updates = []
+    
+    # 1. Sistema de Agentes para optimizar la configuración
+    progress(0.1, desc="🤖 Activando sistema de agentes...")
+    file_info = f"Archivo: {os.path.basename(file.name)}, Modelos: {models}"
+    user_config = {
+        "models": models, "component": component, "use_de": use_de, "maxfev": maxfev,
+        "additional_specs": additional_specs
+    }
+    agent_result = agent_system.process_with_agents(file_info, user_config)
+    
+    if agent_result["success"]:
+        optimized_config = agent_result["config"]
+        progress_updates.append(f"✅ Agentes detectaron: {agent_result['analysis']['experiment_type']}")
+        progress_updates.append(f"🎯 {agent_result['recommendations']}")
+        # Sobrescribir parámetros con las optimizaciones del agente
+        models, component, use_de, maxfev, additional_specs = (
+            optimized_config.get("models", models), 
+            optimized_config.get("component", component),
+            optimized_config.get("use_de", use_de), 
+            optimized_config.get("maxfev", maxfev),
+            optimized_config.get("additional_specs", additional_specs)
         )
-        yield "✅ Final report generated."
-    
-        yield "Generating implementation code..."
-        code_result = "# Code generation is a placeholder in this version."
-        yield "✅ Code generated."
-    
-        # Al final, produce el diccionario de resultados completo.
-        yield {
-            "analisis_completo": final_analysis,
-            "codigo_implementacion": code_result,
-        }
+    else:
+        progress_updates.append(f"⚠️ Agentes no pudieron optimizar: {agent_result['recommendations']}")
 
-# --- FUNCIÓN DE PROCESAMIENTO PRINCIPAL ---
-# --- FUNCIÓN DE PROCESAMIENTO PRINCIPAL (fuera de cualquier clase) ---
-
-def process_files_and_analyze(files, chunk_column: str, qwen_model: str, detail_level: str, language: str, additional_specs: str, max_output_tokens: int):
-    """
-    Procesa archivos subidos y orquesta el análisis, actualizando la UI con 'yield'.
-    """
-    if not files:
-        yield "Please upload a file first.", "", "", ""
-        return
-    if not chunk_column:
-        yield "Please upload a file and select a column for grouping before analyzing.", "", "", ""
-        return
+    # 2. Ejecutar análisis biotecnológico con BiotechU4
+    progress(0.2, desc="🔬 Ejecutando análisis biotecnológico...")
+    if not biotech_client:
+        return create_dummy_plot(), None, None, None, None, "\n".join(progress_updates) + "\n❌ Error: El cliente de BiotechU4 no está disponible."
     
-    # Inicializa las variables que se irán actualizando.
-    thinking_log = ["### 🚀 Starting Analysis\n"]
-    analysis_result, code_result, token_report = "", "", ""
-
-    # Función auxiliar para actualizar el log y hacer yield a la UI
-    def update_log_and_yield(message):
-        nonlocal thinking_log
-        thinking_log.append(f"- {datetime.now().strftime('%H:%M:%S')}: {message}\n")
-        return "\n".join(thinking_log), gr.update(), gr.update(), gr.update()
-
-    yield update_log_and_yield("Processing uploaded file...")
-    
-    file = files[0]
     try:
-        df = pd.read_csv(file.name) if file.name.endswith('.csv') else pd.read_excel(file.name)
-        yield update_log_and_yield(f"Successfully loaded data from '{Path(file.name).name}'.")
+        plot_info, df_data, status = biotech_client.predict(
+            file=handle_file(file.name), models=models, component=component, 
+            use_de=use_de, maxfev=maxfev, exp_names=exp_names, 
+            api_name="/run_analysis_wrapper"
+        )
+        progress_updates.append(f"✅ Análisis BiotechU4 completado: {status}")
     except Exception as e:
-        yield update_log_and_yield(f"Error reading file: {e}")
-        return
-
-    # Inicia el analizador
-    analyzer = AIAnalyzer(client)
-    
-    # Itera sobre el generador `analyze_data`
-    # Cada 'item' será una actualización de estado (string) o el resultado final (dict)
-    for item in analyzer.analyze_data(df, chunk_column, qwen_model, detail_level, language, additional_specs, max_output_tokens):
-        if isinstance(item, str):
-            # Es una actualización de estado, actualizamos el log de "thinking"
-            yield update_log_and_yield(item)
-        elif isinstance(item, dict) and "error" in item:
-            # Es un diccionario de error, terminamos el proceso.
-            yield update_log_and_yield(f"ANALYSIS FAILED: {item['error']}")
-            return
-        elif isinstance(item, dict):
-            # Es el diccionario de resultados final.
-            analysis_result = item["analisis_completo"]
-            code_result = item["codigo_implementacion"]
-            
-            # Almacenar en el estado global para la exportación
-            app_state.current_analysis = analysis_result
-            app_state.current_code = code_result
-            
-            # Formatear el reporte de tokens final
-            t = TRANSLATIONS[language]
-            token_info = analyzer.token_usage
-            token_report = f"""
-            ### {t['token_info']}
-            - **{t['input_token_count']}:** {token_info['input_tokens']}
-            - **{t['output_token_count']}:** {token_info['output_tokens']}
-            - **{t['total_token_count']}:** {token_info['total_tokens']}
-            - **{t['token_cost']}:** ${token_info['estimated_cost']:.6f}
-            """
-            
-            # Hacemos un último yield con todos los resultados finales.
-            yield "\n".join(thinking_log), analysis_result, code_result, token_report
+        error_msg = f"Error en análisis biotecnológico: {e}"
+        return create_dummy_plot(), None, None, None, None, "\n".join(progress_updates) + f"\n❌ {error_msg}"
 
-# --- ESTADO Y FUNCIONES DE UTILIDAD PARA LA UI ---
-class AppState:
-    def __init__(self):
-        self.current_analysis = ""
-        self.current_code = ""
-        self.current_language = "en"
+    if "Error" in status or not df_data:
+        return parse_plot_data(plot_info), None, None, None, None, "\n".join(progress_updates) + f"\n❌ {status}"
 
-app_state = AppState()
-app = None
+    # 3. Crear archivo CSV temporal para hacer de puente a la siguiente API
+    progress(0.4, desc="🌉 Creando puente de datos (CSV)...")
+    temp_csv_file = None
+    try:
+        df = pd.DataFrame(df_data['data'], columns=df_data['headers'])
+        with tempfile.NamedTemporaryFile(mode='w+', suffix='.csv', delete=False, encoding='utf-8') as temp_f:
+            df.to_csv(temp_f.name, index=False)
+            temp_csv_file = temp_f.name
+        progress_updates.append("✅ Puente de datos creado exitosamente.")
+    except Exception as e:
+        error_msg = f"Error al crear el archivo intermedio: {e}"
+        return parse_plot_data(plot_info), df_data, None, None, None, "\n".join(progress_updates) + f"\n❌ {error_msg}"
 
-def export_report(export_format: str, language: str) -> Tuple[str, Optional[str]]:
-    """
-    Exporta el reporte al formato seleccionado (DOCX o PDF) usando el estado global.
-    Crea el archivo en un directorio temporal para evitar saturar el directorio de trabajo.
-    """
-    # 1. Verificar si hay contenido para exportar en el estado global.
-    if not app_state.current_analysis:
-        error_msg = TRANSLATIONS[language].get('error_no_files', 'No analysis available to export.')
-        # Devuelve el mensaje de error y None para la ruta del archivo.
-        return error_msg, None
-    
-    # 2. Generar un nombre de archivo único con marca de tiempo.
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    # 4. Generar informe con Project-HF-2025-2
+    progress(0.5, desc=f"🤖 Generando informe con {ia_model}...")
+    if not analysis_client:
+        os.remove(temp_csv_file)
+        return parse_plot_data(plot_info), df_data, None, None, None, "\n".join(progress_updates) + "\n❌ Error: El cliente de análisis no está disponible."
     
-    # 3. Crear un directorio temporal para almacenar el reporte.
-    #    Esto es una buena práctica para no llenar el directorio raíz de la aplicación.
     try:
-        temp_dir = tempfile.mkdtemp()
-    except Exception as e:
-        return f"Error creating temporary directory: {e}", None
+        # Usar clave personal si se proporciona
+        current_analysis_client = analysis_client
+        if use_personal_key and personal_api_key:
+            current_analysis_client = Client("C2MV/Project-HF-2025-2", hf_token=personal_api_key)
+            progress_updates.append("🔑 Usando clave API personal para el informe.")
+
+        # Actualizar dinámicamente el selector de columna antes de la llamada principal
+        if not chunk_column:
+             chunk_choices = current_analysis_client.predict(files=[handle_file(temp_csv_file)], api_name="/update_chunk_column_selector")
+             chunk_column = chunk_choices[0] if chunk_choices else 'Experiment' # Fallback
+             progress_updates.append(f"✅ Columna de agrupación seleccionada automáticamente: {chunk_column}")
+
+        # Llamada principal a la API de análisis
+        thinking_process, analysis_report, implementation_code, token_usage = current_analysis_client.predict(
+            files=[handle_file(temp_csv_file)],
+            chunk_column=chunk_column,
+            qwen_model=ia_model,
+            detail_level=detail_level,
+            language=language,
+            additional_specs=additional_specs,
+            max_output_tokens=max_output_tokens,
+            api_name="/process_files_and_analyze"
+        )
+        progress_updates.append(f"✅ Informe de IA generado. {token_usage}")
+        progress_updates.append(f"🧠 Proceso de Pensamiento: {thinking_process}")
 
-    # 4. Construir la ruta completa del archivo y llamar al exportador correspondiente.
+    except Exception as e:
+        error_msg = f"Error generando el informe de IA: {e}"
+        return parse_plot_data(plot_info), df_data, error_msg, None, None, "\n".join(progress_updates) + f"\n❌ {error_msg}"
+    finally:
+        if temp_csv_file and os.path.exists(temp_csv_file):
+            os.remove(temp_csv_file) # Limpiar el archivo temporal
+
+    # 5. Exportar el informe final
+    progress(0.9, desc=f"📄 Exportando informe en {export_format}...")
     try:
-        if export_format == "DOCX":
-            # Construye la ruta para el archivo .docx
-            filename = os.path.join(temp_dir, f"biotech_analysis_report_{timestamp}.docx")
-            
-            # Llama al método estático de la clase ReportExporter para crear el DOCX.
-            # Se asume que ReportExporter está definido en otra parte del código.
-            ReportExporter.export_to_docx(
-                content=app_state.current_analysis,
-                filename=filename,
-                language=language
-            )
-        
-        elif export_format == "PDF":
-            # Construye la ruta para el archivo .pdf
-            filename = os.path.join(temp_dir, f"biotech_analysis_report_{timestamp}.pdf")
-            
-            # Llama al método estático de la clase ReportExporter para crear el PDF.
-            # Se asume que ReportExporter está definido en otra parte del código.
-            ReportExporter.export_to_pdf(
-                content=app_state.current_analysis,
-                filename=filename,
-                language=language
-            )
+        export_status, report_file = analysis_client.predict(
+            export_format=export_format, 
+            language=language, 
+            api_name="/export_report"
+        )
+        if report_file:
+            progress_updates.append(f"✅ Informe exportado: {export_status}")
         else:
-            # Manejar un caso improbable de formato no soportado.
-            return f"Unsupported export format: {export_format}", None
-
-        # 5. Si la creación del archivo fue exitosa, devolver un mensaje de éxito y la ruta al archivo.
-        success_msg_template = TRANSLATIONS[language].get('report_exported', 'Report exported successfully as')
-        success_msg = f"{success_msg_template} {os.path.basename(filename)}"
-        
-        return success_msg, filename
-
+            progress_updates.append(f"❌ Error al exportar: {export_status}")
     except Exception as e:
-        # 6. Si ocurre cualquier error durante la exportación (ej. falta de permisos, error en la librería),
-        #    capturarlo y devolver un mensaje de error claro.
-        error_message = f"Error during report export to {export_format}: {str(e)}"
-        print(f"EXPORT ERROR: {error_message}") # Loguear el error en la consola para depuración.
-        return error_message, None
+        report_file = None
+        progress_updates.append(f"❌ Error excepcional durante la exportación: {e}")
 
-# --- INTERFAZ GRADIU COMPLETA ---
-def create_interface():
-    global app
+    progress(1, desc="🎉 Pipeline Completado")
     
-    def update_interface_language(language):
-        app_state.current_language = language
-        t = TRANSLATIONS[language]
-        return [
-            gr.update(value=f"# {t['title']}"), gr.update(value=t['subtitle']),
-            gr.update(label=t['upload_files']), gr.update(label=t['chunk_column_label'], info=t['chunk_column_info']),
-            gr.update(label=t['select_model']), gr.update(label=t['select_language']), gr.update(label=t['select_theme']),
-            gr.update(label=t['detail_level']), gr.update(choices=[(t['detailed'], "detailed"), (t['summarized'], "summarized")]),
-            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']),
-            gr.update(label=t['output_tokens_per_chunk']), gr.update(value=t['analyze_button']),
-            gr.update(label=t['export_format']), gr.update(value=t['export_button']),
-            gr.update(label=t['thinking_process']), gr.update(label=t['analysis_report']),
-            gr.update(label=t['code_output']), gr.update(label=t['token_usage']), gr.update(label=t['data_format'])
-        ]
+    return parse_plot_data(plot_info), df_data, analysis_report, implementation_code, report_file, "\n".join(progress_updates)
 
-    with gr.Blocks(theme=THEMES['light'], title="Scalable Biotech Analyzer") as demo:
-        with gr.Row():
-            with gr.Column(scale=3):
-                title_text = gr.Markdown(f"# {TRANSLATIONS['en']['title']}")
-                subtitle_text = gr.Markdown(TRANSLATIONS['en']['subtitle'])
-            with gr.Column(scale=1):
-                language_selector = gr.Dropdown(choices=[("English", "en"), ("Español", "es")], value="en", label="Language/Idioma")
-                theme_selector = gr.Dropdown(choices=["light", "dark"], value="light", label="Theme/Tema")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                files_input = gr.File(label=TRANSLATIONS['en']['upload_files'], file_count="multiple", type="filepath")
-                
-                # NUEVO COMPONENTE: Selector de columna de agrupación
-                chunk_column_selector = gr.Dropdown(
-                    label=TRANSLATIONS['en']['chunk_column_label'],
-                    info=TRANSLATIONS['en']['chunk_column_info'],
-                    interactive=False  # Se activa al subir archivo
-                )
-                
-                model_selector = gr.Textbox(label=TRANSLATIONS['en']['select_model'], value="deepseek-ai/DeepSeek-V3-0324")
-                detail_level_radio = gr.Radio(choices=[("Detailed", "detailed"), ("Summarized", "summarized")], value="detailed", label=TRANSLATIONS['en']['detail_level'])
-                additional_specs = gr.Textbox(label=TRANSLATIONS['en']['additional_specs'], placeholder=TRANSLATIONS['en']['additional_specs_placeholder'], lines=3)
-                output_tokens_slider = gr.Slider(minimum=1000, maximum=32000, value=4000, step=500, label=TRANSLATIONS['en']['output_tokens_per_chunk'])
-                
-                analyze_btn = gr.Button(TRANSLATIONS['en']['analyze_button'], variant="primary", interactive=False) # Desactivado por defecto
-                
-                gr.Markdown("---")
-                export_format_radio = gr.Radio(choices=["DOCX", "PDF"], value="PDF", label=TRANSLATIONS['en']['export_format'])
-                export_btn = gr.Button(TRANSLATIONS['en']['export_button'])
-                export_status = gr.Textbox(label="Export Status", visible=False)
-                export_file = gr.File(label="Download Report", visible=False)
-
-            with gr.Column(scale=2):
-                thinking_output = gr.Markdown(label=TRANSLATIONS['en']['thinking_process'])
-                analysis_output = gr.Markdown(label=TRANSLATIONS['en']['analysis_report'])
-                code_output = gr.Code(label=TRANSLATIONS['en']['code_output'], language="python")
-                token_usage_output = gr.Markdown(label=TRANSLATIONS['en']['token_usage'])
+def create_example_videos():
+    # ... (código sin cambios)
+    pass
+    
+# ============================================================================
+# 🖼️ INTERFAZ DE USUARIO CON GRADIO (Combinada y Organizada)
+# ============================================================================
+BIOTECH_MODELS = ['logistic', 'gompertz', 'moser', 'baranyi', 'monod', 'contois', 'andrews', 'tessier', 'richards', 'stannard', 'huang']
+DEFAULT_BIOTECH_SELECTION = ['logistic', 'gompertz', 'moser', 'baranyi']
+IA_MODELS = ["deepseek-ai/DeepSeek-V3-0324"]
+DEFAULT_IA_MODEL = "deepseek-ai/DeepSeek-V3-0324"
 
-        data_format_accordion = gr.Accordion(label=TRANSLATIONS['en']['data_format'], open=False)
-        with data_format_accordion:
-            gr.Markdown("""...""") # Contenido del acordeón sin cambios
+theme = gr.themes.Soft(primary_hue="blue", secondary_hue="indigo", neutral_hue="slate")
+custom_css = ".file-upload { border: 2px dashed #3b82f6; } button.primary { background: linear-gradient(135deg, #3b82f6 0%, #8b5cf6 100%); }"
 
-        # --- LÓGICA DE EVENTOS DE LA UI ---
-        
-        # NUEVO EVENTO: Se activa al subir un archivo para poblar el selector de columna
-        def update_chunk_column_selector(files):
-            if not files:
-                return gr.update(choices=[], value=None, interactive=False), gr.update(interactive=False)
-            
-            try:
-                file_path = files[0].name
-                df = pd.read_csv(file_path, nrows=0) if file_path.endswith('.csv') else pd.read_excel(file_path, nrows=0)
-                columns = df.columns.tolist()
-                
-                # Intenta encontrar una columna por defecto
-                default_candidates = ['Experiment', 'Experimento', 'Condition', 'Run', 'Batch', 'ID']
-                default_selection = next((col for col in default_candidates if col in columns), None)
-                
-                return gr.update(choices=columns, value=default_selection, interactive=True), gr.update(interactive=True)
-            except Exception as e:
-                gr.Warning(f"Could not read columns from file: {e}")
-                return gr.update(choices=[], value=None, interactive=False), gr.update(interactive=False)
+create_example_videos()
 
-        files_input.upload(
-            fn=update_chunk_column_selector,
-            inputs=[files_input],
-            outputs=[chunk_column_selector, analyze_btn]
-        )
-        
-        analyze_btn.click(
-            fn=process_files_and_analyze,
-            inputs=[files_input, chunk_column_selector, model_selector, detail_level_radio, language_selector, additional_specs, output_tokens_slider],
-            outputs=[thinking_output, analysis_output, code_output, token_usage_output]
-        )
-        
-        # Eventos de idioma y exportación (sin cambios)
-        language_selector.change(
-            fn=update_interface_language,
-            inputs=[language_selector],
-            outputs=[title_text, subtitle_text, files_input, chunk_column_selector, model_selector, language_selector, theme_selector, detail_level_radio, detail_level_radio, additional_specs, output_tokens_slider, analyze_btn, export_format_radio, export_btn, thinking_output, analysis_output, code_output, token_usage_output, data_format_accordion]
+with gr.Blocks(theme=theme, title="BioTech Analysis & Report Generator", css=custom_css) as demo:
+    gr.Markdown(
+        """
+        # 🧬 BioTech Analysis & Report Generator
+        ## **Full Pipeline: Biotech Modeling → AI Reporting**
+        *An intelligent pipeline that automates the analysis of bioprocess data, from kinetic modeling with `BiotechU4` to generating detailed reports with `Project-HF-2025-2`.*
+        """
+    )
+    # ... (El resto del Markdown y Videos se mantiene igual)
+    with gr.Accordion("🤖 How the AI Agents Work (Click to Expand)", open=True):
+        gr.Markdown(
+            """
+            ```text
+            [ 👤 USER INPUT: Data File & Initial Settings ]
+                                 │
+                                 ▼
+            ┌──────────────────────────────────────────────────────────┐
+            │ 🤖 Coordinator Agent                                     │
+            │  • Analyzes experiment type (e.g., kinetics, ferment.).  │
+            │  • Recommends optimal models and parameters for BiotechU4.│
+            │  • Prepares a rich context for the AI Report Generator.  │
+            └──────────────────────────┬───────────────────────────────┘
+                                       │
+                                       ▼
+            ┌──────────────────────────────────────────────────────────┐
+            │ ⚙️ BiotechU4 API                                         │
+            │  • Performs kinetic modeling and statistical fitting.    │
+            │  • Returns: Plot, Results Table, Status.                 │
+            └──────────────────────────┬───────────────────────────────┘
+                                       │
+                                       ▼
+            ┌──────────────────────────────────────────────────────────┐
+            │ 🌉 Data Bridge                                           │
+            │  • Converts the results table into a temporary CSV file. │
+            └──────────────────────────┬───────────────────────────────┘
+                                       │
+                                       ▼
+            ┌──────────────────────────────────────────────────────────┐
+            │ 🧠 Project-HF-2025-2 API                                 │
+            │  • Analyzes the modeling results from the CSV file.      │
+            │  • Generates: Detailed Report, Python Code, Token Usage. │
+            └─────────────���────────────┬───────────────────────────────┘
+                                       │
+                                       ▼
+            [ 📄 FINAL OUTPUT: Plot, Table, Report, Code & Download ]
+            ```
+            """
         )
-        export_btn.click(fn=export_report, inputs=[export_format_radio, language_selector], outputs=[export_status, export_file])
-
-    app = demo
-    return demo
-
-# --- FUNCIÓN PRINCIPAL DE EJECUCIÓN ---
-def main():
-    if not os.getenv("NEBIUS_API_KEY"):
-        return gr.Interface(lambda: TRANSLATIONS['en']['error_no_api'], [], gr.Textbox(label="Configuration Error"))
-    return create_interface()
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 📊 Configuration")
+            file_input = gr.File(label="📁 Data File (CSV/Excel)", file_types=[".csv", ".xlsx", ".xls"], elem_classes=["file-upload"])
+            gr.Examples(examples=[os.path.join("examples", "archivo.xlsx")], inputs=[file_input], label="Click an example to run")
+
+            with gr.Accordion("🔬 Step 1: Biotech Analysis Parameters (AI Optimized)", open=True):
+                models_input = gr.CheckboxGroup(choices=BIOTECH_MODELS, value=DEFAULT_BIOTECH_SELECTION, label="📊 Models to Test")
+                component_input = gr.Dropdown(['all', 'biomass', 'substrate', 'product'], value='all', label="📈 Component to Visualize")
+                exp_names_input = gr.Textbox(label="🏷️ Experiment Names", value="Biotech Analysis")
+                use_de_input = gr.Checkbox(label="🧮 Use Differential Evolution", value=False)
+                maxfev_input = gr.Slider(label="🔄 Max Iterations", minimum=10000, maximum=100000, value=50000, step=1000)
+
+            with gr.Accordion("🤖 Step 2: AI Report Generation Parameters", open=True):
+                chunk_column_input = gr.Dropdown(label="🔬 Select Column for Grouping", info="This is based on the results from Step 1. Default is usually fine.", choices=["Experiment"], value="Experiment", interactive=True)
+                ia_model_input = gr.Dropdown(choices=IA_MODELS, value=DEFAULT_IA_MODEL, label="🤖 IA Model")
+                detail_level_input = gr.Radio(['detailed', 'summarized'], value='detailed', label="📋 Detail Level")
+                max_output_tokens_input = gr.Slider(minimum=1000, maximum=32000, value=4000, step=100, label="🔢 Max Output Tokens")
+                additional_specs_input = gr.Textbox(label="📝 Additional Specifications", placeholder="AI Agents will customize this...", lines=3, value="Provide a detailed analysis of the models, metrics, and practical recommendations.")
+
+            with gr.Accordion("⚙️ Global & Export Settings", open=True):
+                language_input = gr.Dropdown(['en', 'es'], value='en', label="🌐 Language")
+                export_format_input = gr.Radio(['PDF', 'DOCX'], value='PDF', label="📄 Export Format")
+                with gr.Accordion("🔑 Personal API Key (Optional)", open=False):
+                    use_personal_key_input = gr.Checkbox(label="Use Personal HF Token for AI Report", value=False)
+                    personal_api_key_input = gr.Textbox(label="Personal HF Token", type="password", placeholder="Enter your token (hf_...)", visible=False)
+            
+            process_btn = gr.Button("🚀 Run Full Pipeline with AI Agents", variant="primary", size="lg")
+            
+        with gr.Column(scale=2):
+            gr.Markdown("## 📈 Results")
+            status_output = gr.Textbox(label="📊 Process Status Log", lines=8, interactive=False)
+            with gr.Tabs():
+                with gr.TabItem("📊 Visualization"):
+                    plot_output = gr.Plot()
+                with gr.TabItem("📋 Modeling Results Table"):
+                    table_output = gr.Dataframe()
+                with gr.TabItem("📝 AI Analysis Report"):
+                    analysis_output = gr.Markdown()
+                with gr.TabItem("💻 Implementation Code"):
+                    code_output = gr.Code(language="python")
+            report_output = gr.File(label="📥 Download Final Report", interactive=False)
+
+    def toggle_api_key_visibility(checked):
+        return gr.Textbox(visible=checked)
+
+    use_personal_key_input.change(fn=toggle_api_key_visibility, inputs=use_personal_key_input, outputs=personal_api_key_input)
+    
+    process_btn.click(
+        fn=process_complete_pipeline_with_agents,
+        inputs=[
+            file_input, models_input, component_input, use_de_input, maxfev_input, exp_names_input,
+            chunk_column_input, ia_model_input, detail_level_input, language_input, additional_specs_input,
+            max_output_tokens_input, export_format_input, use_personal_key_input, personal_api_key_input
+        ],
+        outputs=[
+            plot_output, table_output, analysis_output, code_output, report_output, status_output
+        ]
+    )
 
 if __name__ == "__main__":
-    demo = main()
-    if demo:
-        print("===== Application Startup =====")
-        demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=False, inbrowser=True)
+    if not os.path.exists("examples"):
+        os.makedirs("examples")
+        print("Carpeta 'examples' creada. Por favor, añade 'video1.mp4', 'video2.mp4', y 'archivo.xlsx' dentro.")
+    demo.launch(show_error=True, debug=True)