Update app.py

app.py

@@ -17,13 +17,11 @@ from unittest.mock import MagicMock
 from dataclasses import dataclass
 from enum import Enum
 import json
-import base64
 
 from PIL import Image
 import gradio as gr
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-import plotly.io as pio
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -70,11 +68,7 @@ TRANSLATIONS = {
         "language": "Idioma",
         "theory": "Teoría y Modelos",
         "guide": "Guía de Uso",
-        "api_docs": "Documentación API",
-        "individual": "Individual",
-        "average": "Promedio",
-        "combined": "Combinado",
-        "config": "Configuración"
+        "api_docs": "Documentación API"
     },
     Language.EN: {
         "title": "🔬 Bioprocess Kinetics Analyzer",
@@ -97,11 +91,7 @@ TRANSLATIONS = {
         "language": "Language",
         "theory": "Theory and Models",
         "guide": "User Guide",
-        "api_docs": "API Documentation",
-        "individual": "Individual",
-        "average": "Average",
-        "combined": "Combined",
-        "config": "Configuration"
+        "api_docs": "API Documentation"
     },
 }
 
@@ -110,6 +100,9 @@ C_TIME = 'tiempo'
 C_BIOMASS = 'biomass'
 C_SUBSTRATE = 'substrate'
 C_PRODUCT = 'product'
+C_OXYGEN = 'oxygen'
+C_CO2 = 'co2'
+C_PH = 'ph'
 COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
 
 # --- SISTEMA DE TEMAS ---
@@ -548,7 +541,6 @@ class BioprocessFitter:
         self.data_time: Optional[np.ndarray] = None
         self.data_means: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
         self.data_stds: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
-        self.raw_data: Dict[str, List[np.ndarray]] = {c: [] for c in COMPONENTS}  # Para análisis individual
 
     def _get_biomass_at_t(self, t: np.ndarray, p: List[float]) -> np.ndarray: 
         return self.model.model_function(t, *p)
@@ -587,24 +579,20 @@ class BioprocessFitter:
             self.data_time = df[time_col].dropna().to_numpy()
             min_len = len(self.data_time)
             
-            def extract(name: str) -> Tuple[np.ndarray, np.ndarray, List[np.ndarray]]:
+            def extract(name: str) -> Tuple[np.ndarray, np.ndarray]:
                 cols = [c for c in df.columns if c[1].strip().lower() == name.lower()]
-                if not cols: return np.array([]), np.array([]), []
+                if not cols: return np.array([]), np.array([])
                 reps = [df[c].dropna().values[:min_len] for c in cols]
                 reps = [r for r in reps if len(r) == min_len]
-                if not reps: return np.array([]), np.array([]), []
+                if not reps: return np.array([]), np.array([])
                 arr = np.array(reps)
                 mean = np.mean(arr, axis=0)
                 std = np.std(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
-                return mean, std, reps
+                return mean, std
             
-            # Extraer datos con réplicas individuales
-            for comp, name in [(C_BIOMASS, 'Biomasa'), (C_SUBSTRATE, 'Sustrato'), (C_PRODUCT, 'Producto')]:
-                mean, std, reps = extract(name)
-                self.data_means[comp] = mean
-                self.data_stds[comp] = std
-                self.raw_data[comp] = reps
-                
+            self.data_means[C_BIOMASS], self.data_stds[C_BIOMASS] = extract('Biomasa')
+            self.data_means[C_SUBSTRATE], self.data_stds[C_SUBSTRATE] = extract('Sustrato')
+            self.data_means[C_PRODUCT], self.data_stds[C_PRODUCT] = extract('Producto')
         except (IndexError, KeyError) as e:
             raise ValueError(f"Estructura de DataFrame inválida. Error: {e}")
         
@@ -757,90 +745,6 @@ class BioprocessFitter:
             if self.params[C_PRODUCT]:
                 P = self.product(t_fine, *list(self.params[C_PRODUCT].values()), bio_p)
         return X, S, P
-    
-    def plot_individual_or_combined(self, cfg, mode):
-        """Crea gráficos individuales o combinados con Matplotlib/Seaborn"""
-        t_exp, t_fine = cfg['time_exp'], self._generate_fine_time_grid(cfg['time_exp'])
-        X_m, S_m, P_m = self.get_model_curves_for_plot(t_fine, cfg.get('use_differential', False))
-        
-        sns.set_style(cfg.get('style', 'whitegrid'))
-        
-        if mode == 'average':
-            fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15), sharex=True)
-            fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
-            axes = [ax1, ax2, ax3]
-        else:
-            fig, ax1 = plt.subplots(figsize=(12, 8))
-            fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
-            ax2 = ax1.twinx()
-            ax3 = ax1.twinx()
-            ax3.spines["right"].set_position(("axes", 1.18))
-            axes = [ax1, ax2, ax3]
-        
-        data_map = {C_BIOMASS: X_m, C_SUBSTRATE: S_m, C_PRODUCT: P_m}
-        comb_styles = {
-            C_BIOMASS: {'c': '#0072B2', 'mc': '#56B4E9', 'm': 'o', 'ls': '-'},
-            C_SUBSTRATE: {'c': '#009E73', 'mc': '#34E499', 'm': 's', 'ls': '--'},
-            C_PRODUCT: {'c': '#D55E00', 'mc': '#F0E442', 'm': '^', 'ls': '-.'}
-        }
-        
-        for ax, comp in zip(axes, COMPONENTS):
-            ylabel = cfg.get('axis_labels', {}).get(f'{comp}_label', comp.capitalize())
-            data = cfg.get(f'{comp}_exp')
-            std = cfg.get(f'{comp}_std')
-            model_data = data_map.get(comp)
-            
-            if mode == 'combined':
-                s = comb_styles[comp]
-                pc, lc, ms, ls = s['c'], s['mc'], s['m'], s['ls']
-            else:
-                pc = cfg.get(f'{comp}_point_color')
-                lc = cfg.get(f'{comp}_line_color')
-                ms = cfg.get(f'{comp}_marker_style')
-                ls = cfg.get(f'{comp}_line_style')
-            
-            ax_c = pc if mode == 'combined' else 'black'
-            ax.set_ylabel(ylabel, color=ax_c)
-            ax.tick_params(axis='y', labelcolor=ax_c)
-            
-            if data is not None and len(data) > 0:
-                if cfg.get('show_error_bars') and std is not None and np.any(std > 0):
-                    ax.errorbar(t_exp, data, yerr=std, fmt=ms, color=pc, 
-                               label=f'{comp.capitalize()} (Datos)', 
-                               capsize=cfg.get('error_cap_size', 3),
-                               elinewidth=cfg.get('error_line_width', 1))
-                else:
-                    ax.plot(t_exp, data, ls='', marker=ms, color=pc, 
-                           label=f'{comp.capitalize()} (Datos)')
-            
-            if model_data is not None and len(model_data) > 0:
-                ax.plot(t_fine, model_data, ls=ls, color=lc, 
-                       label=f'{comp.capitalize()} (Modelo)')
-            
-            if mode == 'average' and cfg.get('show_legend', True):
-                ax.legend(loc=cfg.get('legend_pos', 'best'))
-            
-            if mode == 'average' and cfg.get('show_params', True) and self.params[comp]:
-                decs = cfg.get('decimal_places', 3)
-                p_txt = '\n'.join([f"{k}={format_number(v, decs)}" for k, v in self.params[comp].items()])
-                full_txt = f"{p_txt}\nR²={format_number(self.r2.get(comp, 0), 3)}, RMSE={format_number(self.rmse.get(comp, 0), 3)}"
-                pos_x, ha = (0.95, 'right') if 'right' in cfg.get('params_pos', 'upper right') else (0.05, 'left')
-                ax.text(pos_x, 0.95, full_txt, transform=ax.transAxes, va='top', ha=ha,
-                       bbox=dict(boxstyle='round,pad=0.4', fc='wheat', alpha=0.7))
-        
-        if mode == 'combined' and cfg.get('show_legend', True):
-            h1, l1 = axes[0].get_legend_handles_labels()
-            h2, l2 = axes[1].get_legend_handles_labels()
-            h3, l3 = axes[2].get_legend_handles_labels()
-            axes[0].legend(handles=h1+h2+h3, labels=l1+l2+l3, loc=cfg.get('legend_pos', 'best'))
-        
-        axes[-1].set_xlabel(cfg.get('axis_labels', {}).get('x_label', 'Tiempo'))
-        plt.tight_layout()
-        
-        if mode == 'combined':
-            fig.subplots_adjust(right=0.8)
-        
-        return fig
 
 # --- FUNCIONES AUXILIARES ---
 
@@ -859,456 +763,235 @@ def format_number(value: Any, decimals: int) -> str:
             
     return str(round(value, decimals))
 
-# --- FUNCIONES DE PLOTEO MEJORADAS ---
+# --- FUNCIONES DE PLOTEO MEJORADAS CON PLOTLY ---
 
-def plot_model_comparison_matplotlib(plot_config: Dict, models_results: List[Dict]) -> plt.Figure:
-    """Crea un gráfico de comparación de modelos estático usando Matplotlib/Seaborn"""
+def create_interactive_plot(plot_config: Dict, models_results: List[Dict], 
+                          selected_component: str = "all") -> go.Figure:
+    """Crea un gráfico interactivo mejorado con Plotly"""
     time_exp = plot_config['time_exp']
-    time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
-    num_models = len(models_results)
-    
-    palettes = {
-        C_BIOMASS: sns.color_palette("Blues", num_models),
-        C_SUBSTRATE: sns.color_palette("Greens", num_models),
-        C_PRODUCT: sns.color_palette("Reds", num_models)
-    }
-    line_styles = ['-', '--', '-.', ':']
-
-    sns.set_style(plot_config.get('style', 'whitegrid'))
-    fig, ax1 = plt.subplots(figsize=(12, 8))
-
-    # Configuración de los 3 ejes Y
-    ax1.set_xlabel(plot_config['axis_labels']['x_label'])
-    ax1.set_ylabel(plot_config['axis_labels']['biomass_label'], color="navy", fontsize=12)
-    ax1.tick_params(axis='y', labelcolor="navy")
-    ax2 = ax1.twinx()
-    ax3 = ax1.twinx()
-    ax3.spines["right"].set_position(("axes", 1.22))
-    ax2.set_ylabel(plot_config['axis_labels']['substrate_label'], color="darkgreen", fontsize=12)
-    ax2.tick_params(axis='y', labelcolor="darkgreen")
-    ax3.set_ylabel(plot_config['axis_labels']['product_label'], color="darkred", fontsize=12)
-    ax3.tick_params(axis='y', labelcolor="darkred")
-
-    # Dibujar datos experimentales
-    data_markers = {C_BIOMASS: 'o', C_SUBSTRATE: 's', C_PRODUCT: '^'}
-    for ax, key, color, face in [(ax1, C_BIOMASS, 'navy', 'skyblue'), 
-                                  (ax2, C_SUBSTRATE, 'darkgreen', 'lightgreen'), 
-                                  (ax3, C_PRODUCT, 'darkred', 'lightcoral')]:
-        data_exp = plot_config.get(f'{key}_exp')
-        data_std = plot_config.get(f'{key}_std')
-        if data_exp is not None:
-            if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0):
-                ax.errorbar(time_exp, data_exp, yerr=data_std, fmt=data_markers[key], 
-                           color=color, label=f'{key.capitalize()} (Datos)', zorder=10, 
-                           markersize=8, markerfacecolor=face, markeredgecolor=color, 
-                           capsize=plot_config.get('error_cap_size', 3), 
-                           elinewidth=plot_config.get('error_line_width', 1))
-            else:
-                ax.plot(time_exp, data_exp, ls='', marker=data_markers[key], 
-                       label=f'{key.capitalize()} (Datos)', zorder=10, ms=8, 
-                       mfc=face, mec=color, mew=1.5)
-
-    # Dibujar curvas de los modelos
-    for i, res in enumerate(models_results):
-        ls = line_styles[i % len(line_styles)]
-        model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
-        model_display_name = model_info.display_name
-        for key_short, ax, name_long in [('X', ax1, C_BIOMASS), ('S', ax2, C_SUBSTRATE), ('P', ax3, C_PRODUCT)]:
-            if res.get(key_short) is not None:
-                ax.plot(time_fine, res[key_short], color=palettes[name_long][i], ls=ls, 
-                       label=f'{name_long.capitalize()} ({model_display_name})', alpha=0.9)
-
-    fig.subplots_adjust(left=0.3, right=0.78, top=0.92, 
-                        bottom=0.35 if plot_config.get('show_params') else 0.1)
-
-    if plot_config.get('show_legend'):
-        h1, l1 = ax1.get_legend_handles_labels()
-        h2, l2 = ax2.get_legend_handles_labels()
-        h3, l3 = ax3.get_legend_handles_labels()
-        fig.legend(h1 + h2 + h3, l1 + l2 + l3, loc='center left', 
-                  bbox_to_anchor=(0.0, 0.5), fancybox=True, shadow=True, fontsize='small')
-
-    if plot_config.get('show_params'):
-        total_width = 0.95
-        box_width = total_width / num_models
-        start_pos = (1.0 - total_width) / 2
-        for i, res in enumerate(models_results):
-            model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
-            text = f"**{model_info.display_name}**\n" + _generate_model_param_text(res, plot_config.get('decimal_places', 3))
-            fig.text(start_pos + i * box_width, 0.01, text, transform=fig.transFigure, 
-                    fontsize=7.5, va='bottom', ha='left', 
-                    bbox=dict(boxstyle='round,pad=0.4', fc='ivory', ec='gray', alpha=0.9))
-
-    fig.suptitle(f"Comparación de Modelos: {plot_config.get('exp_name', '')}", fontsize=16)
-    return fig
-
-def plot_model_comparison_plotly(plot_config: Dict, models_results: List[Dict]) -> go.Figure:
-    """Crea un gráfico de comparación de modelos interactivo usando Plotly"""
-    fig = go.Figure()
-    time_exp = plot_config['time_exp']
-    time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
-    num_models = len(models_results)
-    
-    palettes = {
-        C_BIOMASS: sns.color_palette("Blues", n_colors=num_models).as_hex(),
-        C_SUBSTRATE: sns.color_palette("Greens", n_colors=num_models).as_hex(),
-        C_PRODUCT: sns.color_palette("Reds", n_colors=num_models).as_hex()
-    }
-    line_styles = ['solid', 'dash', 'dot', 'dashdot']
-    data_markers = {C_BIOMASS: 'circle-open', C_SUBSTRATE: 'square-open', C_PRODUCT: 'diamond-open'}
-
-    for key, y_axis, color in [(C_BIOMASS, 'y1', 'navy'), 
-                                (C_SUBSTRATE, 'y2', 'darkgreen'), 
-                                (C_PRODUCT, 'y3', 'darkred')]:
-        data_exp = plot_config.get(f'{key}_exp')
-        data_std = plot_config.get(f'{key}_std')
-        if data_exp is not None:
-            error_y_config = dict(type='data', array=data_std, visible=True) if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0) else None
-            fig.add_trace(go.Scatter(
-                x=time_exp, y=data_exp, mode='markers', 
-                name=f'{key.capitalize()} (Datos)', 
-                marker=dict(color=color, size=10, symbol=data_markers[key], line=dict(width=2)), 
-                error_y=error_y_config, yaxis=y_axis, legendgroup="data"))
-
-    for i, res in enumerate(models_results):
-        ls = line_styles[i % len(line_styles)]
-        model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
-        if res.get('X') is not None: 
-            fig.add_trace(go.Scatter(x=time_fine, y=res['X'], mode='lines', 
-                                    name=f'Biomasa ({model_display_name})', 
-                                    line=dict(color=palettes[C_BIOMASS][i], dash=ls), 
-                                    legendgroup=res["name"]))
-        if res.get('S') is not None: 
-            fig.add_trace(go.Scatter(x=time_fine, y=res['S'], mode='lines', 
-                                    name=f'Sustrato ({model_display_name})', 
-                                    line=dict(color=palettes[C_SUBSTRATE][i], dash=ls), 
-                                    yaxis='y2', legendgroup=res["name"]))
-        if res.get('P') is not None: 
-            fig.add_trace(go.Scatter(x=time_fine, y=res['P'], mode='lines', 
-                                    name=f'Producto ({model_display_name})', 
-                                    line=dict(color=palettes[C_PRODUCT][i], dash=ls), 
-                                    yaxis='y3', legendgroup=res["name"]))
-
-    if plot_config.get('show_params'):
-        x_positions = np.linspace(0, 1, num_models * 2 + 1)[1::2]
-        for i, res in enumerate(models_results):
-            model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
-            text = f"<b>{model_display_name}</b><br>" + _generate_model_param_text(res, plot_config.get('decimal_places', 3)).replace('\n', '<br>')
-            fig.add_annotation(text=text, align='left', showarrow=False, xref='paper', 
-                             yref='paper', x=x_positions[i], y=-0.35, bordercolor='gray', 
-                             borderwidth=1, bgcolor='ivory', opacity=0.9)
-
-    fig.update_layout(
-        title=f"Comparación de Modelos (Interactivo): {plot_config.get('exp_name', '')}",
-        xaxis=dict(domain=[0.18, 0.82]),
-        yaxis=dict(title=plot_config['axis_labels']['biomass_label'], titlefont=dict(color='navy'), 
-                   tickfont=dict(color='navy')),
-        yaxis2=dict(title=plot_config['axis_labels']['substrate_label'], titlefont=dict(color='darkgreen'), 
-                    tickfont=dict(color='darkgreen'), overlaying='y', side='right'),
-        yaxis3=dict(title=plot_config['axis_labels']['product_label'], titlefont=dict(color='darkred'), 
-                    tickfont=dict(color='darkred'), overlaying='y', side='right', position=0.85),
-        legend=dict(traceorder="grouped", yanchor="middle", y=0.5, xanchor="right", x=-0.15),
-        margin=dict(l=200, r=150, b=250 if plot_config.get('show_params') else 80, t=80),
-        template="plotly_white" if plot_config.get('theme', 'light') == 'light' else "plotly_dark",
-        showlegend=plot_config.get('show_legend', True)
-    )
-    return fig
-
-def _generate_model_param_text(result: Dict, decimals: int) -> str:
-    """Genera el texto formateado de los parámetros para las cajas de anotación"""
-    text = ""
-    for comp in COMPONENTS:
-        if params := result.get('params', {}).get(comp):
-            p_str = ', '.join([f"{k}={format_number(v, decimals)}" for k, v in params.items()])
-            r2 = result.get('r2', {}).get(comp, 0)
-            rmse = result.get('rmse', {}).get(comp, 0)
-            text += f"{comp[:4].capitalize()}: {p_str}\n(R²={format_number(r2, 3)}, RMSE={format_number(rmse, 3)})\n"
-    return text.strip()
-
-# --- FUNCIONES DE DESCARGA Y REPORTES ---
-
-def create_zip_file(image_list: List[Any]) -> Optional[str]:
-    """Crea un archivo ZIP con todas las imágenes"""
-    if not image_list:
-        gr.Warning("No hay gráficos para descargar.")
-        return None
-    try:
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
-            for i, fig in enumerate(image_list):
-                buf = io.BytesIO()
-                if isinstance(fig, go.Figure):
-                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
-                elif isinstance(fig, plt.Figure):
-                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
-                    plt.close(fig)
-                elif isinstance(fig, Image.Image):
-                    fig.save(buf, 'PNG')
-                else:
-                    continue
-                buf.seek(0)
-                zf.writestr(f"grafico_{i+1}.png", buf.read())
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp:
-            tmp.write(zip_buffer.getvalue())
-            return tmp.name
-    except Exception as e:
-        traceback.print_exc()
-        gr.Error(f"Error al crear el archivo ZIP: {e}")
-        return None
-
-def create_word_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
-    """Crea un reporte en Word con imágenes y tablas"""
-    if not image_list and (table_df is None or table_df.empty):
-        gr.Warning("No hay datos ni gráficos para crear el reporte.")
-        return None
-    try:
-        doc = Document()
-        doc.add_heading('Reporte de Análisis de Cinéticas', 0)
-        
-        # Resumen ejecutivo
-        doc.add_heading('Resumen Ejecutivo', level=1)
-        doc.add_paragraph(f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}')
-        doc.add_paragraph(f'Total de experimentos analizados: {len(table_df["Experimento"].unique()) if table_df is not None and not table_df.empty else 0}')
-        doc.add_paragraph(f'Modelos utilizados: {", ".join(table_df["Modelo"].unique()) if table_df is not None and not table_df.empty else "N/A"}')
-        
-        if table_df is not None and not table_df.empty:
-            doc.add_heading('Tabla de Resultados', level=1)
-            table = doc.add_table(rows=1, cols=len(table_df.columns), style='Table Grid')
-            for i, col in enumerate(table_df.columns):
-                table.cell(0, i).text = str(col)
-            for _, row in table_df.iterrows():
-                cells = table.add_row().cells
-                for i, val in enumerate(row):
-                    cells[i].text = str(format_number(val, decimals))
-        
-        if image_list:
-            doc.add_page_break()
-            doc.add_heading('Gráficos Generados', level=1)
-            for i, fig in enumerate(image_list):
-                buf = io.BytesIO()
-                if isinstance(fig, go.Figure):
-                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
-                elif isinstance(fig, plt.Figure):
-                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
-                    plt.close(fig)
-                elif isinstance(fig, Image.Image):
-                    fig.save(buf, 'PNG')
-                else:
-                    continue
-                buf.seek(0)
-                doc.add_paragraph(f'Gráfico {i+1}', style='Heading 3')
-                doc.add_picture(buf, width=Inches(6.0))
-                doc.add_paragraph('')  # Espacio entre imágenes
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
-            doc.save(tmp.name)
-            return tmp.name
-    except Exception as e:
-        traceback.print_exc()
-        gr.Error(f"Error al crear el reporte de Word: {e}")
-        return None
-
-def create_pdf_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
-    """Crea un reporte en PDF con imágenes y tablas"""
-    if not image_list and (table_df is None or table_df.empty):
-        gr.Warning("No hay datos ni gráficos para crear el reporte.")
-        return None
-    try:
-        pdf = FPDF()
-        pdf.set_auto_page_break(auto=True, margin=15)
-        pdf.add_page()
-        pdf.set_font("Helvetica", 'B', 16)
-        pdf.cell(0, 10, 'Reporte de Análisis de Cinéticas', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
-        
-        # Resumen ejecutivo
-        pdf.ln(10)
-        pdf.set_font("Helvetica", '', 10)
-        pdf.cell(0, 10, f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}', 
-                new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    time_fine = np.linspace(min(time_exp), max(time_exp), 500)
+    
+    # Configuración de subplots si se muestran todos los componentes
+    if selected_component == "all":
+        fig = make_subplots(
+            rows=3, cols=1,
+            subplot_titles=('Biomasa', 'Sustrato', 'Producto'),
+            vertical_spacing=0.08,
+            shared_xaxes=True
+        )
+        components_to_plot = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
+        rows = [1, 2, 3]
+    else:
+        fig = go.Figure()
+        components_to_plot = [selected_component]
+        rows = [None]
+    
+    # Colores para diferentes modelos
+    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', 
+              '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
+    
+    # Agregar datos experimentales
+    for comp, row in zip(components_to_plot, rows):
+        data_exp = plot_config.get(f'{comp}_exp')
+        data_std = plot_config.get(f'{comp}_std')
         
-        if table_df is not None and not table_df.empty:
-            pdf.ln(10)
-            pdf.set_font("Helvetica", 'B', 12)
-            pdf.cell(0, 10, 'Tabla de Resultados', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-            pdf.set_font("Helvetica", 'B', 8)
-            
-            effective_page_width = pdf.w - 2 * pdf.l_margin
-            num_cols = len(table_df.columns)
-            col_width = effective_page_width / num_cols if num_cols > 0 else 0
+        if data_exp is not None:
+            error_y = dict(
+                type='data',
+                array=data_std,
+                visible=True
+            ) if data_std is not None and np.any(data_std > 0) else None
             
-            if num_cols > 15:
-                pdf.set_font_size(6)
-            elif num_cols > 10:
-                pdf.set_font_size(7)
-                
-            for col in table_df.columns:
-                pdf.cell(col_width, 10, str(col), border=1, align='C')
-            pdf.ln()
+            trace = go.Scatter(
+                x=time_exp,
+                y=data_exp,
+                mode='markers',
+                name=f'{comp.capitalize()} (Experimental)',
+                marker=dict(size=10, symbol='circle'),
+                error_y=error_y,
+                legendgroup=comp,
+                showlegend=True
+            )
             
-            pdf.set_font("Helvetica", '', 7)
-            if num_cols > 15:
-                pdf.set_font_size(5)
-            elif num_cols > 10:
-                pdf.set_font_size(6)
-                
-            for _, row in table_df.iterrows():
-                for val in row:
-                    pdf.cell(col_width, 10, str(format_number(val, decimals)), border=1, align='R')
-                pdf.ln()
+            if selected_component == "all":
+                fig.add_trace(trace, row=row, col=1)
+            else:
+                fig.add_trace(trace)
+    
+    # Agregar curvas de modelos
+    for i, res in enumerate(models_results):
+        color = colors[i % len(colors)]
+        model_name = AVAILABLE_MODELS[res["name"]].display_name
         
-        if image_list:
-            for i, fig in enumerate(image_list):
-                pdf.add_page()
-                pdf.set_font("Helvetica", 'B', 12)
-                pdf.cell(0, 10, f'Gráfico {i+1}', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-                pdf.ln(5)
+        for comp, row, key in zip(components_to_plot, rows, ['X', 'S', 'P']):
+            if res.get(key) is not None:
+                trace = go.Scatter(
+                    x=time_fine,
+                    y=res[key],
+                    mode='lines',
+                    name=f'{model_name} - {comp.capitalize()}',
+                    line=dict(color=color, width=2),
+                    legendgroup=f'{res["name"]}_{comp}',
+                    showlegend=True
+                )
                 
-                buf = io.BytesIO()
-                if isinstance(fig, go.Figure):
-                    buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
-                elif isinstance(fig, plt.Figure):
-                    fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
-                    plt.close(fig)
-                elif isinstance(fig, Image.Image):
-                    fig.save(buf, 'PNG')
+                if selected_component == "all":
+                    fig.add_trace(trace, row=row, col=1)
                 else:
-                    continue
-                    
-                buf.seek(0)
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
-                    tmp_img.write(buf.read())
-                    pdf.image(tmp_img.name, x=None, y=None, w=pdf.w - 20)
-                os.remove(tmp_img.name)
-        
-        pdf_bytes = pdf.output()
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
-            tmp.write(pdf_bytes)
-            return tmp.name
-    except Exception as e:
-        traceback.print_exc()
-        gr.Error(f"Error al crear el reporte PDF: {e}")
-        return None
+                    fig.add_trace(trace)
+    
+    # Actualizar diseño
+    theme = plot_config.get('theme', 'light')
+    template = "plotly_white" if theme == 'light' else "plotly_dark"
+    
+    fig.update_layout(
+        title=f"Análisis de Cinéticas: {plot_config.get('exp_name', '')}",
+        template=template,
+        hovermode='x unified',
+        legend=dict(
+            orientation="v",
+            yanchor="middle",
+            y=0.5,
+            xanchor="left",
+            x=1.02
+        ),
+        margin=dict(l=80, r=250, t=100, b=80)
+    )
+    
+    # Actualizar ejes
+    if selected_component == "all":
+        fig.update_xaxes(title_text="Tiempo", row=3, col=1)
+        fig.update_yaxes(title_text="Biomasa (g/L)", row=1, col=1)
+        fig.update_yaxes(title_text="Sustrato (g/L)", row=2, col=1)
+        fig.update_yaxes(title_text="Producto (g/L)", row=3, col=1)
+    else:
+        fig.update_xaxes(title_text="Tiempo")
+        labels = {
+            C_BIOMASS: "Biomasa (g/L)",
+            C_SUBSTRATE: "Sustrato (g/L)",
+            C_PRODUCT: "Producto (g/L)"
+        }
+        fig.update_yaxes(title_text=labels.get(selected_component, "Valor"))
+    
+    # Agregar botones para cambiar entre modos de visualización
+    fig.update_layout(
+        updatemenus=[
+            dict(
+                type="dropdown",
+                showactive=True,
+                buttons=[
+                    dict(label="Todos los componentes",
+                         method="update",
+                         args=[{"visible": [True] * len(fig.data)}]),
+                    dict(label="Solo Biomasa",
+                         method="update",
+                         args=[{"visible": [i < len(fig.data)//3 for i in range(len(fig.data))]}]),
+                    dict(label="Solo Sustrato",
+                         method="update",
+                         args=[{"visible": [len(fig.data)//3 <= i < 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
+                    dict(label="Solo Producto",
+                         method="update",
+                         args=[{"visible": [i >= 2*len(fig.data)//3 for i in range(len(fig.data))]}]),
+                ],
+                x=0.1,
+                y=1.15,
+                xanchor="left",
+                yanchor="top"
+            )
+        ]
+    )
+    
+    return fig
 
 # --- FUNCIÓN PRINCIPAL DE ANÁLISIS ---
-
-def run_analysis(file, model_names, mode, engine, exp_names, settings):
-    """Ejecuta el análisis completo con todos los modos"""
-    if not file:
-        return [], pd.DataFrame(), "Error: Sube un archivo Excel.", pd.DataFrame()
-    if not model_names:
-        return [], pd.DataFrame(), "Error: Selecciona un modelo.", pd.DataFrame()
+def run_analysis(file, model_names, component, use_de, maxfev, exp_names, theme='light'):
+    if not file: return None, pd.DataFrame(), "Error: Sube un archivo Excel."
+    if not model_names: return None, pd.DataFrame(), "Error: Selecciona un modelo."
     
-    try:
+    try: 
         xls = pd.ExcelFile(file.name)
-    except Exception as e:
-        return [], pd.DataFrame(), f"Error al leer archivo: {e}", pd.DataFrame()
+    except Exception as e: 
+        return None, pd.DataFrame(), f"Error al leer archivo: {e}"
     
-    figs = []
-    results_data = []
-    msgs = []
+    results_data, msgs = [], []
+    models_results = []
     
-    exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()]
+    exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()] if exp_names else []
     
     for i, sheet in enumerate(xls.sheet_names):
         exp_name = exp_list[i] if i < len(exp_list) else f"Hoja '{sheet}'"
-        
         try:
             df = pd.read_excel(xls, sheet_name=sheet, header=[0,1])
             reader = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])
             reader.process_data_from_df(df)
             
-            if reader.data_time is None:
+            if reader.data_time is None: 
                 msgs.append(f"WARN: Sin datos de tiempo en '{sheet}'.")
                 continue
-                
-            cfg = settings.copy()
-            cfg.update({'exp_name': exp_name, 'time_exp': reader.data_time})
             
-            for c in COMPONENTS:
-                cfg[f'{c}_exp'] = reader.data_means[c]
-                cfg[f'{c}_std'] = reader.data_stds[c]
+            plot_config = {
+                'exp_name': exp_name, 
+                'time_exp': reader.data_time,
+                'theme': theme
+            }
+            
+            for c in COMPONENTS: 
+                plot_config[f'{c}_exp'] = reader.data_means[c]
+                plot_config[f'{c}_std'] = reader.data_stds[c]
             
             t_fine = reader._generate_fine_time_grid(reader.data_time)
-            plot_results = []
             
             for m_name in model_names:
-                if m_name not in AVAILABLE_MODELS:
+                if m_name not in AVAILABLE_MODELS: 
                     msgs.append(f"WARN: Modelo '{m_name}' no disponible.")
                     continue
                     
-                fitter = BioprocessFitter(AVAILABLE_MODELS[m_name], maxfev=int(settings.get('maxfev', 50000)))
+                fitter = BioprocessFitter(
+                    AVAILABLE_MODELS[m_name], 
+                    maxfev=int(maxfev),
+                    use_differential_evolution=use_de
+                )
                 fitter.data_time = reader.data_time
                 fitter.data_means = reader.data_means
                 fitter.data_stds = reader.data_stds
-                fitter.raw_data = reader.raw_data
                 fitter.fit_all_models()
                 
-                # Guardar resultados numéricos
                 row = {'Experimento': exp_name, 'Modelo': fitter.model.display_name}
                 for c in COMPONENTS:
-                    if fitter.params[c]:
+                    if fitter.params[c]: 
                         row.update({f'{c.capitalize()}_{k}': v for k, v in fitter.params[c].items()})
                     row[f'R2_{c.capitalize()}'] = fitter.r2.get(c)
                     row[f'RMSE_{c.capitalize()}'] = fitter.rmse.get(c)
                     row[f'MAE_{c.capitalize()}'] = fitter.mae.get(c)
                     row[f'AIC_{c.capitalize()}'] = fitter.aic.get(c)
                     row[f'BIC_{c.capitalize()}'] = fitter.bic.get(c)
+                
                 results_data.append(row)
                 
-                # Generar gráficos según el modo
-                if mode in ["average", "combined"]:
-                    if hasattr(fitter, 'plot_individual_or_combined'):
-                        figs.append(fitter.plot_individual_or_combined(cfg, mode))
-                elif mode == "individual":
-                    # Crear gráficos para cada réplica
-                    for rep_idx, rep_data in enumerate(fitter.raw_data[C_BIOMASS]):
-                        cfg_rep = cfg.copy()
-                        cfg_rep['exp_name'] = f"{exp_name} - Réplica {rep_idx + 1}"
-                        for c in COMPONENTS:
-                            if len(fitter.raw_data[c]) > rep_idx:
-                                cfg_rep[f'{c}_exp'] = fitter.raw_data[c][rep_idx]
-                                cfg_rep[f'{c}_std'] = None  # No hay std para réplicas individuales
-                        figs.append(fitter.plot_individual_or_combined(cfg_rep, "average"))
-                else:
-                    # Modo comparación de modelos
-                    X, S, P = fitter.get_model_curves_for_plot(t_fine, settings.get('use_differential', False))
-                    plot_results.append({
-                        'name': m_name,
-                        'X': X,
-                        'S': S,
-                        'P': P,
-                        'params': fitter.params,
-                        'r2': fitter.r2,
-                        'rmse': fitter.rmse
-                    })
-            
-            if mode == "model_comparison" and plot_results:
-                plot_func = plot_model_comparison_plotly if engine == 'Plotly (Interactivo)' else plot_model_comparison_matplotlib
-                figs.append(plot_func(cfg, plot_results))
+                X, S, P = fitter.get_model_curves_for_plot(t_fine, False)
+                models_results.append({
+                    'name': m_name, 
+                    'X': X, 
+                    'S': S, 
+                    'P': P, 
+                    'params': fitter.params, 
+                    'r2': fitter.r2, 
+                    'rmse': fitter.rmse
+                })
                 
-        except Exception as e:
+        except Exception as e: 
             msgs.append(f"ERROR en '{sheet}': {e}")
             traceback.print_exc()
     
     msg = "Análisis completado." + ("\n" + "\n".join(msgs) if msgs else "")
     df_res = pd.DataFrame(results_data).dropna(axis=1, how='all')
     
-    if not df_res.empty:
-        # Ordenar columnas
-        id_c = ['Experimento', 'Modelo']
-        p_c = sorted([c for c in df_res.columns if '_' in c and not any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
-        m_c = sorted([c for c in df_res.columns if any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
-        df_res = df_res[[c for c in id_c + p_c + m_c if c in df_res.columns]]
-        
-        # Crear DataFrame formateado para UI
-        df_ui = df_res.copy()
-        for c in df_ui.select_dtypes(include=np.number).columns:
-            df_ui[c] = df_ui[c].apply(lambda x: format_number(x, settings.get('decimal_places', 3)) if pd.notna(x) else '')
-    else:
-        df_ui = pd.DataFrame()
+    # Crear gráfico interactivo
+    fig = None
+    if models_results and reader.data_time is not None:
+        fig = create_interactive_plot(plot_config, models_results, component)
     
-    return figs, df_ui, msg, df_res
+    return fig, df_res, msg
 
 # --- API ENDPOINTS PARA AGENTES DE IA ---
 
@@ -1400,15 +1083,16 @@ async def predict_kinetics(
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
-# --- INTERFAZ GRADIO COMPLETA ---
+# --- INTERFAZ GRADIO MEJORADA ---
 
 def create_gradio_interface() -> gr.Blocks:
-    """Crea la interfaz completa con todas las funcionalidades"""
+    """Crea la interfaz mejorada con soporte multiidioma y tema"""
     
     def change_language(lang_key: str) -> Dict:
         """Cambia el idioma de la interfaz"""
         lang = Language[lang_key]
         trans = TRANSLATIONS.get(lang, TRANSLATIONS[Language.ES])
+        
         return trans["title"], trans["subtitle"]
     
     # Obtener opciones de modelo
@@ -1442,304 +1126,196 @@ def create_gradio_interface() -> gr.Blocks:
                     )
         
         with gr.Tabs() as tabs:
-            # --- TAB 1: GUÍA Y FORMATO ---
-            with gr.TabItem("1. Guía y Formato de Datos"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        gr.Markdown("""
-                        ### Bienvenido al Analizador de Cinéticas
-                        Esta herramienta te permite ajustar modelos matemáticos a tus datos de crecimiento microbiano.
-                        
-                        **Pasos a seguir:**
-                        1. Prepara tu archivo Excel según el formato especificado a la derecha.
-                        2. Ve a la pestaña **"2. Configuración y Ejecución"**.
-                        3. Sube tu archivo y selecciona los modelos cinéticos que deseas probar.
-                        4. Ajusta las opciones de visualización y análisis según tus preferencias.
-                        5. Haz clic en **"Analizar y Graficar"**.
-                        6. Explora los resultados en la pestaña **"3. Resultados"**.
-
-                        ### Modos de Análisis
-                        - **Individual**: Un gráfico por cada réplica
-                        - **Promedio**: Promedio de réplicas con barras de error
-                        - **Combinado**: Todos los componentes en un solo gráfico
-                        - **Comparación**: Comparación de múltiples modelos
-                        """)
-                    with gr.Column(scale=3):
-                        gr.Markdown("### Formato del Archivo Excel")
-                        gr.Markdown("Usa una **cabecera de dos niveles** para tus datos.")
-                        df_ejemplo = pd.DataFrame({
-                            ('Rep1', 'Tiempo'): [0, 2, 4, 6],
-                            ('Rep1', 'Biomasa'): [0.1, 0.5, 2.5, 5.0],
-                            ('Rep1', 'Sustrato'): [10.0, 9.5, 7.0, 2.0],
-                            ('Rep1', 'Producto'): [0.0, 0.1, 0.5, 1.2],
-                            ('Rep2', 'Tiempo'): [0, 2, 4, 6],
-                            ('Rep2', 'Biomasa'): [0.12, 0.48, 2.6, 5.2],
-                            ('Rep2', 'Sustrato'): [10.2, 9.6, 7.1, 2.1],
-                            ('Rep2', 'Producto'): [0.0, 0.12, 0.48, 1.1],
-                        })
-                        gr.DataFrame(df_ejemplo, interactive=False, label="Ejemplo de Formato")
+            # --- TAB 1: TEORÍA Y MODELOS ---
+            with gr.TabItem("📚 Teoría y Modelos"):
+                gr.Markdown("""
+                ## Introducción a los Modelos Cinéticos
+                
+                Los modelos cinéticos en biotecnología describen el comportamiento dinámico
+                de los microorganismos durante su crecimiento. Estos modelos son fundamentales
+                para:
+                
+                - **Optimización de procesos**: Determinar condiciones óptimas de operación
+                - **Escalamiento**: Predecir comportamiento a escala industrial
+                - **Control de procesos**: Diseñar estrategias de control efectivas
+                - **Análisis económico**: Evaluar viabilidad de procesos
+                """)
+                
+                # Cards para cada modelo
+                for model_name, model in AVAILABLE_MODELS.items():
+                    with gr.Accordion(f"📊 {model.display_name}", open=False):
+                        with gr.Row():
+                            with gr.Column(scale=3):
+                                gr.Markdown(f"""
+                                **Descripción**: {model.description}
+                                
+                                **Ecuación**: ${model.equation}$
+                                
+                                **Parámetros**: {', '.join(model.param_names)}
+                                
+                                **Referencia**: {model.reference}
+                                """)
+                            with gr.Column(scale=1):
+                                gr.Markdown(f"""
+                                **Características**:
+                                - Parámetros: {model.num_params}
+                                - Complejidad: {'⭐' * min(model.num_params, 5)}
+                                """)
             
-            # --- TAB 2: CONFIGURACIÓN Y EJECUCIÓN ---
-            with gr.TabItem("2. Configuración y Ejecución"):
+            # --- TAB 2: ANÁLISIS ---
+            with gr.TabItem("🔬 Análisis"):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        file_input = gr.File(label="Sube tu archivo Excel (.xlsx)", file_types=['.xlsx'])
+                        file_input = gr.File(
+                            label="📁 Sube tu archivo Excel (.xlsx)",
+                            file_types=['.xlsx']
+                        )
+                        
                         exp_names_input = gr.Textbox(
-                            label="Nombres de Experimentos (opcional)",
-                            placeholder="Nombre Hoja 1\nNombre Hoja 2\n...",
-                            lines=3,
-                            info="Un nombre por línea, en el mismo orden que las hojas del Excel."
+                            label="🏷️ Nombres de Experimentos",
+                            placeholder="Experimento 1\nExperimento 2\n...",
+                            lines=3
                         )
+                        
                         model_selection_input = gr.CheckboxGroup(
                             choices=MODEL_CHOICES,
-                            label="Modelos a Probar",
+                            label="📊 Modelos a Probar",
                             value=DEFAULT_MODELS
                         )
-                        analysis_mode_input = gr.Radio(
-                            ["individual", "average", "combined", "model_comparison"],
-                            label="Modo de Análisis",
-                            value="average",
-                            info="Individual: por réplica. Average: promedio. Combined: 3 ejes. Comparación: todos los modelos."
-                        )
-                        plotting_engine_input = gr.Radio(
-                            ["Seaborn (Estático)", "Plotly (Interactivo)"],
-                            label="Motor Gráfico (en modo Comparación)",
-                            value="Plotly (Interactivo)"
-                        )
-                    
-                    with gr.Column(scale=2):
-                        with gr.Accordion("Opciones Generales de Análisis", open=True):
-                            decimal_places_input = gr.Slider(0, 10, value=3, step=1, label="Precisión Decimal")
-                            show_params_input = gr.Checkbox(label="Mostrar Parámetros en Gráfico", value=True)
-                            show_legend_input = gr.Checkbox(label="Mostrar Leyenda en Gráfico", value=True)
-                            use_differential_input = gr.Checkbox(label="Usar EDO para graficar", value=False)
-                            maxfev_input = gr.Number(label="Iteraciones Máximas de Ajuste", value=50000)
-
-                        with gr.Accordion("Etiquetas de los Ejes", open=True):
-                            with gr.Row():
-                                xlabel_input = gr.Textbox(label="Etiqueta Eje X", value="Tiempo (h)")
-                            with gr.Row():
-                                ylabel_biomass_input = gr.Textbox(label="Etiqueta Biomasa", value="Biomasa (g/L)")
-                                ylabel_substrate_input = gr.Textbox(label="Etiqueta Sustrato", value="Sustrato (g/L)")
-                                ylabel_product_input = gr.Textbox(label="Etiqueta Producto", value="Producto (g/L)")
                         
-                        with gr.Accordion("Opciones de Estilo", open=False):
-                            style_input = gr.Dropdown(
-                                ['whitegrid', 'darkgrid', 'white', 'dark', 'ticks'],
-                                label="Estilo General (Matplotlib)",
-                                value='whitegrid'
+                        with gr.Accordion("⚙️ Opciones Avanzadas", open=False):
+                            use_de_input = gr.Checkbox(
+                                label="Usar Evolución Diferencial",
+                                value=False,
+                                info="Optimización global más robusta pero más lenta"
                             )
-                            with gr.Row():
-                                with gr.Column():
-                                    gr.Markdown("**Biomasa**")
-                                    biomass_point_color_input = gr.ColorPicker(label="Color Puntos", value='#0072B2')
-                                    biomass_line_color_input = gr.ColorPicker(label="Color Línea", value='#56B4E9')
-                                    biomass_marker_style_input = gr.Dropdown(
-                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
-                                        label="Marcador",
-                                        value='o'
-                                    )
-                                    biomass_line_style_input = gr.Dropdown(
-                                        ['-', '--', '-.', ':'],
-                                        label="Estilo Línea",
-                                        value='-'
-                                    )
-                                with gr.Column():
-                                    gr.Markdown("**Sustrato**")
-                                    substrate_point_color_input = gr.ColorPicker(label="Color Puntos", value='#009E73')
-                                    substrate_line_color_input = gr.ColorPicker(label="Color Línea", value='#34E499')
-                                    substrate_marker_style_input = gr.Dropdown(
-                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
-                                        label="Marcador",
-                                        value='s'
-                                    )
-                                    substrate_line_style_input = gr.Dropdown(
-                                        ['-', '--', '-.', ':'],
-                                        label="Estilo Línea",
-                                        value='--'
-                                    )
-                                with gr.Column():
-                                    gr.Markdown("**Producto**")
-                                    product_point_color_input = gr.ColorPicker(label="Color Puntos", value='#D55E00')
-                                    product_line_color_input = gr.ColorPicker(label="Color Línea", value='#F0E442')
-                                    product_marker_style_input = gr.Dropdown(
-                                        ['o', 's', '^', 'D', 'p', '*', 'X'],
-                                        label="Marcador",
-                                        value='^'
-                                    )
-                                    product_line_style_input = gr.Dropdown(
-                                        ['-', '--', '-.', ':'],
-                                        label="Estilo Línea",
-                                        value='-.'
-                                    )
                             
-                            with gr.Row():
-                                legend_pos_input = gr.Radio(
-                                    ["best", "upper right", "upper left", "lower left", "lower right", "center"],
-                                    label="Posición Leyenda",
-                                    value="best"
-                                )
-                                params_pos_input = gr.Radio(
-                                    ["upper right", "upper left", "lower right", "lower left"],
-                                    label="Posición Parámetros",
-                                    value="upper right"
-                                )
+                            maxfev_input = gr.Number(
+                                label="Iteraciones máximas",
+                                value=50000
+                            )
+                    
+                    with gr.Column(scale=2):
+                        # Selector de componente para visualización
+                        component_selector = gr.Dropdown(
+                            choices=[
+                                ("Todos los componentes", "all"),
+                                ("Solo Biomasa", C_BIOMASS),
+                                ("Solo Sustrato", C_SUBSTRATE),
+                                ("Solo Producto", C_PRODUCT)
+                            ],
+                            value="all",
+                            label="📈 Componente a visualizar"
+                        )
                         
-                        with gr.Accordion("Opciones de Barra de Error", open=False):
-                            show_error_bars_input = gr.Checkbox(label="Mostrar barras de error", value=True)
-                            error_cap_size_input = gr.Slider(1, 10, 3, step=1, label="Tamaño Tapa Error")
-                            error_line_width_input = gr.Slider(0.5, 5, 1.0, step=0.5, label="Grosor Línea Error")
-
-                simulate_btn = gr.Button("Analizar y Graficar", variant="primary")
-
+                        plot_output = gr.Plot(label="Visualización Interactiva")
+                        
+                analyze_button = gr.Button("🚀 Analizar y Graficar", variant="primary")
+            
             # --- TAB 3: RESULTADOS ---
-            with gr.TabItem("3. Resultados"):
-                status_output = gr.Textbox(label="Estado del Análisis", interactive=False, lines=2)
-                gallery_output = gr.Gallery(
-                    label="Gráficos Generados",
-                    columns=2,
-                    height=600,
-                    object_fit="contain",
-                    preview=True
+            with gr.TabItem("📊 Resultados"):
+                status_output = gr.Textbox(
+                    label="Estado del Análisis",
+                    interactive=False
                 )
                 
-                with gr.Accordion("Descargar Reportes y Gráficos", open=True):
-                    with gr.Row():
-                        zip_btn = gr.Button("📦 Descargar Gráficos (.zip)")
-                        word_btn = gr.Button("📄 Descargar Reporte (.docx)")
-                        pdf_btn = gr.Button("📄 Descargar Reporte (.pdf)")
-                    download_output = gr.File(label="Archivo de Descarga", interactive=False)
-                
-                gr.Markdown("### Tabla de Resultados Numéricos")
-                table_output = gr.DataFrame(wrap=True)
+                results_table = gr.DataFrame(
+                    label="Tabla de Resultados",
+                    wrap=True
+                )
                 
                 with gr.Row():
-                    excel_btn = gr.Button("📊 Descargar Tabla (.xlsx)")
-                    csv_btn = gr.Button("📊 Descargar Tabla (.csv)")
-                download_table_output = gr.File(label="Descargar Tabla", interactive=False)
+                    download_excel = gr.Button("📥 Descargar Excel")
+                    download_json = gr.Button("📥 Descargar JSON")
+                    api_docs_button = gr.Button("📖 Ver Documentación API")
                 
-                # Estados para almacenar datos
-                df_for_export = gr.State(pd.DataFrame())
-                figures_for_export = gr.State([])
-        
-        # --- EVENTOS ---
-        
-        def simulation_wrapper(file, models, mode, engine, names, use_diff, s_par, s_leg, maxfev, 
-                             decimals, x_label, bio_label, sub_label, prod_label, style, s_err, 
-                             cap, lw, l_pos, p_pos, bio_pc, bio_lc, bio_ms, bio_ls, sub_pc, 
-                             sub_lc, sub_ms, sub_ls, prod_pc, prod_lc, prod_ms, prod_ls):
-            try:
-                def rgba_to_hex(rgba_string: str) -> str:
-                    if not isinstance(rgba_string, str) or rgba_string.startswith('#'):
-                        return rgba_string
-                    try:
-                        parts = rgba_string.lower().replace('rgba', '').replace('rgb', '').replace('(', '').replace(')', '')
-                        r, g, b, *_ = map(float, parts.split(','))
-                        return f'#{int(r):02x}{int(g):02x}{int(b):02x}'
-                    except (ValueError, TypeError):
-                        return "#000000"
-
-                plot_settings = {
-                    'decimal_places': int(decimals),
-                    'use_differential': use_diff,
-                    'style': style,
-                    'show_legend': s_leg,
-                    'show_params': s_par,
-                    'maxfev': int(maxfev),
-                    'axis_labels': {
-                        'x_label': x_label,
-                        'biomass_label': bio_label,
-                        'substrate_label': sub_label,
-                        'product_label': prod_label
+                download_file = gr.File(label="Archivo descargado")
+            
+            # --- TAB 4: API ---
+            with gr.TabItem("🔌 API"):
+                gr.Markdown("""
+                ## Documentación de la API
+                
+                La API REST permite integrar el análisis de cinéticas en aplicaciones externas
+                y agentes de IA.
+                
+                ### Endpoints disponibles:
+                
+                #### 1. `GET /api/models`
+                Retorna la lista de modelos disponibles con su información.
+                
+                ```python
+                import requests
+                response = requests.get("http://localhost:8000/api/models")
+                models = response.json()
+                ```
+                
+                #### 2. `POST /api/analyze`
+                Analiza datos con los modelos especificados.
+                
+                ```python
+                data = {
+                    "data": {
+                        "time": [0, 1, 2, 3, 4],
+                        "biomass": [0.1, 0.3, 0.8, 1.5, 2.0],
+                        "substrate": [10, 8, 5, 2, 0.5]
                     },
-                    'legend_pos': l_pos,
-                    'params_pos': p_pos,
-                    'show_error_bars': s_err,
-                    'error_cap_size': cap,
-                    'error_line_width': lw,
-                    f'{C_BIOMASS}_point_color': rgba_to_hex(bio_pc),
-                    f'{C_BIOMASS}_line_color': rgba_to_hex(bio_lc),
-                    f'{C_BIOMASS}_marker_style': bio_ms,
-                    f'{C_BIOMASS}_line_style': bio_ls,
-                    f'{C_SUBSTRATE}_point_color': rgba_to_hex(sub_pc),
-                    f'{C_SUBSTRATE}_line_color': rgba_to_hex(sub_lc),
-                    f'{C_SUBSTRATE}_marker_style': sub_ms,
-                    f'{C_SUBSTRATE}_line_style': sub_ls,
-                    f'{C_PRODUCT}_point_color': rgba_to_hex(prod_pc),
-                    f'{C_PRODUCT}_line_color': rgba_to_hex(prod_lc),
-                    f'{C_PRODUCT}_marker_style': prod_ms,
-                    f'{C_PRODUCT}_line_style': prod_ls,
+                    "models": ["logistic", "gompertz"],
+                    "options": {"maxfev": 50000}
                 }
+                response = requests.post("http://localhost:8000/api/analyze", json=data)
+                results = response.json()
+                ```
                 
-                figures, df_ui, msg, df_export = run_analysis(file, models, mode, engine, names, plot_settings)
+                #### 3. `POST /api/predict`
+                Predice valores usando un modelo y parámetros específicos.
                 
-                # Convertir figuras a imágenes para galería
-                image_list = []
-                for fig in figures:
-                    buf = io.BytesIO()
-                    if isinstance(fig, go.Figure):
-                        buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
-                    elif isinstance(fig, plt.Figure):
-                        fig.savefig(buf, format='png', bbox_inches='tight', dpi=150)
-                        plt.close(fig)
-                    buf.seek(0)
-                    image_list.append(Image.open(buf).convert("RGB"))
+                ```python
+                data = {
+                    "model_name": "logistic",
+                    "parameters": {"X0": 0.1, "Xm": 10.0, "μm": 0.5},
+                    "time_points": [0, 1, 2, 3, 4, 5]
+                }
+                response = requests.post("http://localhost:8000/api/predict", json=data)
+                predictions = response.json()
+                ```
                 
-                return image_list, df_ui, msg, df_export, figures
+                ### Iniciar servidor API:
+                ```bash
+                uvicorn script_name:app --reload --port 8000
+                ```
+                """)
                 
-            except Exception as e:
-                print(f"--- ERROR CAPTURADO EN WRAPPER ---\n{traceback.format_exc()}")
-                return [], pd.DataFrame(), f"Error Crítico: {e}", pd.DataFrame(), []
-
-        all_inputs = [
-            file_input, model_selection_input, analysis_mode_input, plotting_engine_input, exp_names_input,
-            use_differential_input, show_params_input, show_legend_input, maxfev_input, decimal_places_input,
-            xlabel_input, ylabel_biomass_input, ylabel_substrate_input, ylabel_product_input,
-            style_input, show_error_bars_input, error_cap_size_input, error_line_width_input,
-            legend_pos_input, params_pos_input,
-            biomass_point_color_input, biomass_line_color_input, biomass_marker_style_input, biomass_line_style_input,
-            substrate_point_color_input, substrate_line_color_input, substrate_marker_style_input, substrate_line_style_input,
-            product_point_color_input, product_line_color_input, product_marker_style_input, product_line_style_input
-        ]
-        
-        all_outputs = [gallery_output, table_output, status_output, df_for_export, figures_for_export]
-        
-        simulate_btn.click(fn=simulation_wrapper, inputs=all_inputs, outputs=all_outputs)
+                # Botón para copiar comando
+                gr.Textbox(
+                    value="uvicorn bioprocess_analyzer:app --reload --port 8000",
+                    label="Comando para iniciar API",
+                    interactive=False
+                )
         
-        # Funciones de descarga
-        zip_btn.click(fn=create_zip_file, inputs=[figures_for_export], outputs=[download_output])
-        word_btn.click(
-            fn=create_word_report,
-            inputs=[figures_for_export, df_for_export, decimal_places_input],
-            outputs=[download_output]
-        )
-        pdf_btn.click(
-            fn=create_pdf_report,
-            inputs=[figures_for_export, df_for_export, decimal_places_input],
-            outputs=[download_output]
-        )
+        # --- EVENTOS ---
         
-        def export_table_to_file(df: pd.DataFrame, file_format: str) -> Optional[str]:
-            if df is None or df.empty:
-                gr.Warning("No hay datos para exportar.")
-                return None
-            suffix = ".xlsx" if file_format == "excel" else ".csv"
-            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
-                if file_format == "excel":
-                    df.to_excel(tmp.name, index=False)
-                else:
-                    df.to_csv(tmp.name, index=False, encoding='utf-8-sig')
-                return tmp.name
+        def run_analysis_wrapper(file, models, component, use_de, maxfev, exp_names, theme):
+            """Wrapper para ejecutar el análisis"""
+            try:
+                return run_analysis(file, models, component, use_de, maxfev, exp_names, 
+                                  'dark' if theme else 'light')
+            except Exception as e:
+                print(f"--- ERROR EN ANÁLISIS ---\n{traceback.format_exc()}")
+                return None, pd.DataFrame(), f"Error: {str(e)}"
         
-        excel_btn.click(
-            fn=lambda df: export_table_to_file(df, "excel"),
-            inputs=[df_for_export],
-            outputs=[download_table_output]
-        )
-        csv_btn.click(
-            fn=lambda df: export_table_to_file(df, "csv"),
-            inputs=[df_for_export],
-            outputs=[download_table_output]
+        analyze_button.click(
+            fn=run_analysis_wrapper,
+            inputs=[
+                file_input,
+                model_selection_input,
+                component_selector,
+                use_de_input,
+                maxfev_input,
+                exp_names_input,
+                theme_toggle
+            ],
+            outputs=[plot_output, results_table, status_output]
         )
         
         # Cambio de idioma
@@ -1751,17 +1327,46 @@ def create_gradio_interface() -> gr.Blocks:
         
         # Cambio de tema
         def apply_theme(is_dark):
-            return gr.Info("Tema cambiado. Los nuevos gráficos usarán el tema seleccionado.")
+            return gr.Info("Tema cambiado. Los gráficos nuevos usarán el tema seleccionado.")
         
         theme_toggle.change(
             fn=apply_theme,
             inputs=[theme_toggle],
             outputs=[]
         )
+        
+        # Funciones de descarga
+        def download_results_excel(df):
+            if df is None or df.empty:
+                gr.Warning("No hay datos para descargar")
+                return None
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
+                df.to_excel(tmp.name, index=False)
+                return tmp.name
+        
+        def download_results_json(df):
+            if df is None or df.empty:
+                gr.Warning("No hay datos para descargar")
+                return None
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tmp:
+                df.to_json(tmp.name, orient='records', indent=2)
+                return tmp.name
+        
+        download_excel.click(
+            fn=download_results_excel,
+            inputs=[results_table],
+            outputs=[download_file]
+        )
+        
+        download_json.click(
+            fn=download_results_json,
+            inputs=[results_table],
+            outputs=[download_file]
+        )
     
     return demo
 
-# --- PUNTO DE ENTRADA PRINCIPAL ---
+# --- PUNTO DE ENTRADA ---
 
 if __name__ == '__main__':
     # Lanzar aplicación Gradio