Update app.py

app.py

@@ -6,19 +6,14 @@ import gradio as gr
 import json
 import pickle
 import os
-from flask import Flask, request, jsonify
-from flask_cors import CORS
+from typing import Dict, List, Any
 
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
 print("🚀 Iniciando Eco Finder API...")
 
-# Configuración Flask
-app = Flask(__name__)
-CORS(app)  # Habilitar CORS para frontend
-
-# Intentar importar TensorFlow
+# Configuración simple sin Flask
 try:
     import tensorflow as tf
     print(f"✅ TensorFlow version: {tf.__version__}")
@@ -59,22 +54,21 @@ def load_resources():
         
     except Exception as e:
         print(f"❌ Error cargando recursos: {str(e)}")
-        return None, None, None, create_default_feature_stats()
-
-def create_default_feature_stats():
-    return {
-        "feature_columns": [
-            "koi_period", "koi_duration", "koi_depth", "koi_prad", 
-            "koi_srad", "koi_teq", "koi_steff", "koi_slogg", 
-            "koi_smet", "koi_kepmag", "koi_model_snr", "koi_num_transits"
-        ],
-        "train_medians": {
-            "koi_period": 10.0, "koi_duration": 5.0, "koi_depth": 1000.0,
-            "koi_prad": 2.0, "koi_srad": 1.0, "koi_teq": 1000.0,
-            "koi_steff": 6000.0, "koi_slogg": 4.5, "koi_smet": 0.0,
-            "koi_kepmag": 12.0, "koi_model_snr": 10.0, "koi_num_transits": 3.0
+        # Crear defaults
+        feature_stats = {
+            "feature_columns": [
+                "koi_period", "koi_duration", "koi_depth", "koi_prad", 
+                "koi_srad", "koi_teq", "koi_steff", "koi_slogg", 
+                "koi_smet", "koi_kepmag", "koi_model_snr", "koi_num_transits"
+            ],
+            "train_medians": {
+                "koi_period": 10.0, "koi_duration": 5.0, "koi_depth": 1000.0,
+                "koi_prad": 2.0, "koi_srad": 1.0, "koi_teq": 1000.0,
+                "koi_steff": 6000.0, "koi_slogg": 4.5, "koi_smet": 0.0,
+                "koi_kepmag": 12.0, "koi_model_snr": 10.0, "koi_num_transits": 3.0
+            }
         }
-    }
+        return None, None, None, feature_stats
 
 # Cargar recursos
 model, scaler, label_encoder, feature_stats = load_resources()
@@ -83,26 +77,24 @@ train_medians = feature_stats.get("train_medians", {})
 
 BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
 
-# ==================== ENDPOINTS API REST ====================
+# ==================== FUNCIONES DE PREDICCIÓN ====================
 
-@app.route('/api/health', methods=['GET'])
-def health_check():
-    """Endpoint de salud de la API"""
-    return jsonify({
-        "status": "healthy",
-        "model_loaded": model is not None,
-        "features": feature_columns
-    })
+def first_present(candidates, cols_set):
+    """Encuentra la primera columna disponible entre sinónimos"""
+    for name in candidates:
+        if name in cols_set:
+            return name
+    for name in candidates:
+        found = [c for c in cols_set if name in c]
+        if found:
+            return found[0]
+    return None
 
-@app.route('/api/predict', methods=['POST'])
-def predict_single():
-    """Endpoint para predecir un solo objeto"""
+def predict_single_api(data: Dict) -> Dict:
+    """Función para predecir un solo objeto (para API)"""
     try:
-        data = request.get_json()
-        
-        # Validar datos de entrada
-        if not data:
-            return jsonify({"error": "No se proporcionaron datos"}), 400
+        if model is None or scaler is None or label_encoder is None:
+            return {"error": "Modelo no disponible"}
         
         # Crear array de características
         input_features = []
@@ -114,18 +106,16 @@ def predict_single():
         input_array = np.array([input_features])
         X_input = scaler.transform(input_array)
         
-        if TENSORFLOW_AVAILABLE and model is not None:
+        if TENSORFLOW_AVAILABLE:
             probs = model.predict(X_input, verbose=0)[0]
         else:
-            # Fallback a probabilidades aleatorias
             probs = np.random.dirichlet(np.ones(3), size=1)[0]
         
         # Obtener predicción
         pred_idx = np.argmax(probs)
         pred_label = label_encoder.inverse_transform([pred_idx])[0]
         
-        # Preparar respuesta
-        response = {
+        return {
             "prediction": pred_label,
             "probabilities": {
                 "CONFIRMED": float(probs[0]),
@@ -135,76 +125,35 @@ def predict_single():
             "input_features": dict(zip(feature_columns, input_features))
         }
         
-        return jsonify(response)
-        
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return {"error": str(e)}
 
-@app.route('/api/predict-batch', methods=['POST'])
-def predict_batch():
-    """Endpoint para predecir múltiples objetos"""
+def predict_toi_realtime():
+    """Función para la interfaz Gradio - TOI en tiempo real"""
     try:
-        data = request.get_json()
-        
-        if not data or 'objects' not in data:
-            return jsonify({"error": "Se requiere array 'objects' en el JSON"}), 400
-        
-        predictions = []
-        for obj in data['objects']:
-            # Procesar cada objeto
-            input_features = []
-            for feature in feature_columns:
-                value = obj.get(feature, train_medians.get(feature, 0))
-                input_features.append(float(value))
-            
-            # Predecir
-            input_array = np.array([input_features])
-            X_input = scaler.transform(input_array)
-            
-            if TENSORFLOW_AVAILABLE and model is not None:
-                probs = model.predict(X_input, verbose=0)[0]
-            else:
-                probs = np.random.dirichlet(np.ones(3), size=1)[0]
-            
-            pred_idx = np.argmax(probs)
-            pred_label = label_encoder.inverse_transform([pred_idx])[0]
-            
-            predictions.append({
-                "prediction": pred_label,
-                "probabilities": {
-                    "CONFIRMED": float(probs[0]),
-                    "CANDIDATE": float(probs[1]),
-                    "FALSE_POSITIVE": float(probs[2])
-                },
-                "input_features": dict(zip(feature_columns, input_features))
-            })
-        
-        return jsonify({"predictions": predictions})
+        if model is None or scaler is None or label_encoder is None:
+            return "❌ Modelo no disponible. Por favor, verifica los archivos del modelo."
         
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/toi-realtime', methods=['GET'])
-def get_toi_predictions():
-    """Endpoint para obtener predicciones de TOI en tiempo real"""
-    try:
-        # Consultar API de exoplanetas
+        # 1) Traer TOI (TESS Objects of Interest)
         where = ("(tfopwg_disp like 'PC' or tfopwg_disp like 'APC') "
                  "and (pl_orbper is not null or tce_period is not null)")
         
-        params = {"table": "toi", "where": where, "format": "json"}
+        params = {"table": "toi", "where": where, "format": "csv"}
         resp = requests.get(BASE, params=params, timeout=60)
         resp.raise_for_status()
-        toi_data = resp.json()
+        toi_df = pd.read_csv(io.StringIO(resp.text))
         
-        if not toi_data:
-            return jsonify({"error": "No se encontraron objetos TOI"}), 404
+        if toi_df.empty:
+            return "❌ No se encontraron objetos TOI con los filtros aplicados."
         
-        # Tomar muestra
-        toi_sample = pd.DataFrame(toi_data).sample(min(5, len(toi_data)), random_state=7)
-        toi_sample.columns = [c.strip().lower() for c in toi_sample.columns]
+        # 2) Normalizar nombres
+        toi_df.columns = [c.strip().lower() for c in toi_df.columns]
         
-        # Mapeo de columnas
+        # 3) Tomar muestra aleatoria
+        toi_sample = toi_df.sample(min(5, len(toi_df)), random_state=7).reset_index(drop=True)
+        cols_set = set(toi_sample.columns)
+        
+        # 4) Mapeo de sinónimos
         candidates_map = {
             "koi_period": ["pl_orbper", "tce_period", "orbper", "period"],
             "koi_duration": ["pl_trandurh", "tce_duration", "tran_dur", "trandur", "duration", "dur"],
@@ -220,247 +169,276 @@ def get_toi_predictions():
             "koi_num_transits": ["tce_num_transits", "num_transits", "ntransits", "tran_count"]
         }
         
-        def first_present(candidates, cols_set):
-            for name in candidates:
-                if name in cols_set:
-                    return name
-            for name in candidates:
-                found = [c for c in cols_set if name in c]
-                if found:
-                    return found[0]
-            return None
+        # 5) Preparar datos para predicción
+        cases = pd.DataFrame(index=toi_sample.index, columns=feature_columns, dtype="float64")
         
-        cols_set = set(toi_sample.columns)
-        results = []
-        
-        for idx, row in toi_sample.iterrows():
-            # Preparar características
-            features = {}
-            for feat in feature_columns:
-                src = first_present(candidates_map.get(feat, []), cols_set)
-                if src and src in row and pd.notna(row[src]):
-                    features[feat] = float(row[src])
-                else:
-                    features[feat] = train_medians.get(feat, 0)
-            
-            # Predecir
-            input_array = np.array([list(features.values())])
-            X_input = scaler.transform(input_array)
-            
-            if TENSORFLOW_AVAILABLE and model is not None:
-                probs = model.predict(X_input, verbose=0)[0]
+        for feat in feature_columns:
+            src = first_present(candidates_map.get(feat, []), cols_set)
+            if src is not None:
+                cases[feat] = pd.to_numeric(toi_sample[src], errors="coerce")
             else:
-                probs = np.random.dirichlet(np.ones(3), size=1)[0]
-            
-            pred_idx = np.argmax(probs)
-            pred_label = label_encoder.inverse_transform([pred_idx])[0]
-            
-            results.append({
-                "toi_id": row.get('toi', f"TOI-{idx}"),
-                "current_disposition": row.get('tfopwg_disp', 'Unknown'),
-                "prediction": pred_label,
-                "probabilities": {
-                    "CONFIRMED": float(probs[0]),
-                    "CANDIDATE": float(probs[1]),
-                    "FALSE_POSITIVE": float(probs[2])
-                },
-                "features": features
-            })
-        
-        return jsonify({
-            "count": len(results),
-            "predictions": results
-        })
+                cases[feat] = np.nan
+        
+        # 6) Imputar valores faltantes
+        for c in feature_columns:
+            if c in train_medians:
+                cases[c] = cases[c].fillna(train_medians[c])
+            else:
+                cases[c] = cases[c].fillna(cases[c].median())
+        
+        # 7) Escalar y predecir
+        X_cases = scaler.transform(cases.values)
+        probs = model.predict(X_cases, verbose=0)
+        pred_idx = np.argmax(probs, axis=1)
+        pred_labels = label_encoder.inverse_transform(pred_idx)
+        clases = list(label_encoder.classes_)
+        
+        def p_of(lbl, row_probs):
+            return float(row_probs[clases.index(lbl)]) if lbl in clases else np.nan
+        
+        # 8) Preparar resultados
+        out_rows = []
+        for i in range(len(toi_sample)):
+            row = {
+                "TOI": toi_sample.loc[i, first_present(["toi"], cols_set)] if first_present(["toi"], cols_set) else "N/A",
+                "Disposición Actual": toi_sample.loc[i, first_present(["tfopwg_disp", "disposition"], cols_set)] if first_present(["tfopwg_disp", "disposition"], cols_set) else "N/A",
+                "Predicción": pred_labels[i],
+                "P(Confirmado)": f"{p_of('CONFIRMED', probs[i]):.3f}",
+                "P(Candidato)": f"{p_of('CANDIDATE', probs[i]):.3f}",
+                "P(Falso Positivo)": f"{p_of('FALSE POSITIVE', probs[i]):.3f}",
+                "Período (días)": f"{float(cases.loc[i, 'koi_period']):.3f}",
+                "Duración (horas)": f"{float(cases.loc[i, 'koi_duration']):.3f}",
+                "Radio Planetario (R⊕)": f"{float(cases.loc[i, 'koi_prad']):.3f}"
+            }
+            out_rows.append(row)
+        
+        # 9) Crear tabla de resultados
+        result_df = pd.DataFrame(out_rows)
+        
+        # 10) Conteo con umbral
+        umbral = 0.5
+        prob_confirmados = [float(p) for p in result_df["P(Confirmado)"]]
+        n_pos = sum(1 for p in prob_confirmados if p >= umbral)
+        
+        summary = f"**Resumen:** Con umbral {umbral:.2f}, {n_pos}/{len(result_df)} objetos son probables exoplanetas confirmados.\n\n"
+        
+        return summary + result_df.to_markdown(index=False)
         
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/features', methods=['GET'])
-def get_features_info():
-    """Endpoint para obtener información de las características"""
-    return jsonify({
-        "feature_columns": feature_columns,
-        "train_medians": train_medians,
-        "feature_descriptions": {
-            "koi_period": "Período orbital (días)",
-            "koi_duration": "Duración del tránsito (horas)",
-            "koi_depth": "Profundidad del tránsito (ppm)",
-            "koi_prad": "Radio planetario (Radios terrestres)",
-            "koi_srad": "Radio estelar (Radios solares)",
-            "koi_teq": "Temperatura de equilibrio (K)",
-            "koi_steff": "Temperatura efectiva estelar (K)",
-            "koi_slogg": "Gravedad superficial estelar (log g)",
-            "koi_smet": "Metalicidad estelar ([Fe/H])",
-            "koi_kepmag": "Magnitud TESS",
-            "koi_model_snr": "Relación señal-ruido",
-            "koi_num_transits": "Número de tránsitos"
-        }
-    })
-
-# ==================== INTERFAZ GRADIO ====================
-
-def predict_toi_realtime():
-    """Función para la interfaz Gradio"""
-    try:
-        response = requests.get('http://localhost:7860/api/toi-realtime')
-        if response.status_code == 200:
-            data = response.json()
-            results = []
-            for pred in data['predictions']:
-                results.append({
-                    "TOI": pred['toi_id'],
-                    "Disposición Actual": pred['current_disposition'],
-                    "Predicción": pred['prediction'],
-                    "P(Confirmado)": f"{pred['probabilities']['CONFIRMED']:.3f}",
-                    "P(Candidato)": f"{pred['probabilities']['CANDIDATE']:.3f}",
-                    "P(Falso Positivo)": f"{pred['probabilities']['FALSE_POSITIVE']:.3f}"
-                })
-            result_df = pd.DataFrame(results)
-            return result_df.to_markdown(index=False)
-        else:
-            return "Error obteniendo datos TOI"
-    except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {str(e)}"
 
 def predict_custom_data(period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits):
-    """Función para predicción manual en Gradio"""
+    """Predice para datos personalizados ingresados manualmente"""
     try:
-        data = {
-            "koi_period": period, "koi_duration": duration, "koi_depth": depth,
-            "koi_prad": prad, "koi_srad": srad, "koi_teq": teq,
-            "koi_steff": steff, "koi_slogg": slogg, "koi_smet": smet,
-            "koi_kepmag": kepmag, "koi_model_snr": snr, "koi_num_transits": num_transits
-        }
+        if model is None or scaler is None or label_encoder is None:
+            return "❌ Modelo no disponible. Por favor, verifica los archivos del modelo."
+        
+        # Crear array con los datos de entrada
+        input_data = np.array([[period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits]])
+        
+        # Escalar y predecir
+        X_input = scaler.transform(input_data)
+        probs = model.predict(X_input, verbose=0)
+        pred_idx = np.argmax(probs, axis=1)
+        pred_label = label_encoder.inverse_transform(pred_idx)[0]
+        
+        clases = list(label_encoder.classes_)
+        resultados = {}
+        for clase in clases:
+            prob = float(probs[0][clases.index(clase)])
+            resultados[clase] = f"{prob:.3f}"
+        
+        output = f"**Predicción:** {pred_label}\n\n**Probabilidades:**\n"
+        for clase, prob in resultados.items():
+            output += f"- {clase}: {prob}\n"
+            
+        return output
         
-        response = requests.post('http://localhost:7860/api/predict', json=data)
-        if response.status_code == 200:
-            result = response.json()
-            output = f"**Predicción:** {result['prediction']}\n\n**Probabilidades:**\n"
-            for clase, prob in result['probabilities'].items():
-                output += f"- {clase}: {prob:.3f}\n"
-            return output
-        else:
-            return "Error en la predicción"
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error en predicción: {str(e)}"
+
+# ==================== INTERFAZ GRADIO CON API ====================
 
-# Crear interfaz Gradio
 with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
     gr.Markdown("# 🌌 Eco Finder API")
-    gr.Markdown("Clasificador de exoplanetas - Interfaz Web y API REST")
+    gr.Markdown("Clasificador de exoplanetas - Interfaz Web y API")
     
-    with gr.Tab("🔭 Analizar TOI"):
-        gr.Markdown("Predicciones en tiempo real de objetos TOI")
+    with gr.Tab("🔭 Analizar TOI en tiempo real"):
+        gr.Markdown("Obtén predicciones de objetos TOI del archivo TESS en tiempo real")
         analyze_btn = gr.Button("🔍 Analizar Objetos TOI")
         output_realtime = gr.Markdown()
-        analyze_btn.click(predict_toi_realtime, outputs=output_realtime)
+        analyze_btn.click(
+            fn=predict_toi_realtime,
+            outputs=output_realtime
+        )
     
-    with gr.Tab("📊 Predicción Manual"):
-        gr.Markdown("Ingresa parámetros para clasificación")
+    with gr.Tab("📊 Ingresar datos manualmente"):
+        gr.Markdown("Ingresa los parámetros astronómicos manualmente para obtener una predicción")
+        
         with gr.Row():
             with gr.Column():
                 period = gr.Number(label="Período orbital (días)", value=10.0)
-                duration = gr.Number(label="Duración tránsito (horas)", value=5.0)
-                depth = gr.Number(label="Profundidad (ppm)", value=1000.0)
+                duration = gr.Number(label="Duración del tránsito (horas)", value=5.0)
+                depth = gr.Number(label="Profundidad del tránsito (ppm)", value=1000.0)
                 prad = gr.Number(label="Radio planetario (R⊕)", value=2.0)
-            with gr.Column():
                 srad = gr.Number(label="Radio estelar (R☉)", value=1.0)
-                teq = gr.Number(label="Temperatura equilibrio (K)", value=1000.0)
-                steff = gr.Number(label="Temp. efectiva (K)", value=6000.0)
-                slogg = gr.Number(label="Gravedad superficial", value=4.5)
+            
             with gr.Column():
-                smet = gr.Number(label="Metalicidad", value=0.0)
+                teq = gr.Number(label="Temperatura de equilibrio (K)", value=1000.0)
+                steff = gr.Number(label="Temperatura efectiva estelar (K)", value=6000.0)
+                slogg = gr.Number(label="Gravedad superficial estelar (log g)", value=4.5)
+                smet = gr.Number(label="Metalicidad estelar ([Fe/H])", value=0.0)
                 kepmag = gr.Number(label="Magnitud TESS", value=12.0)
-                snr = gr.Number(label="Señal/Ruido", value=10.0)
-                num_transits = gr.Number(label="N° Tránsitos", value=3.0)
+            
+            with gr.Column():
+                snr = gr.Number(label="Relación señal-ruido", value=10.0)
+                num_transits = gr.Number(label="Número de tránsitos", value=3.0)
         
         predict_btn = gr.Button("🎯 Predecir")
         output_manual = gr.Markdown()
+        
         predict_btn.click(
-            predict_custom_data,
+            fn=predict_custom_data,
             inputs=[period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits],
             outputs=output_manual
         )
     
-    with gr.Tab("🔗 API Documentation"):
+    with gr.Tab("🔗 Consumir API desde Frontend"):
         gr.Markdown("""
-        ## Endpoints REST Disponibles
-        
-        ### 🔍 Salud del sistema
-        **GET** `/api/health`
-        ```bash
-        curl -X GET https://jarpalucas-echo-finder-api.hf.space/api/health
-        ```
-        
-        ### 🎯 Predicción individual
-        **POST** `/api/predict`
-        ```bash
-        curl -X POST https://jarpalucas-echo-finder-api.hf.space/api/predict \\
-          -H "Content-Type: application/json" \\
-          -d '{
-            "koi_period": 10.0,
-            "koi_duration": 5.0,
-            "koi_depth": 1000.0,
-            "koi_prad": 2.0,
-            "koi_srad": 1.0,
-            "koi_teq": 1000.0,
-            "koi_steff": 6000.0,
-            "koi_slogg": 4.5,
-            "koi_smet": 0.0,
-            "koi_kepmag": 12.0,
-            "koi_model_snr": 10.0,
-            "koi_num_transits": 3.0
-          }'
-        ```
-        
-        ### 📊 Predicción múltiple
-        **POST** `/api/predict-batch`
-        ```bash
-        curl -X POST https://jarpalucas-echo-finder-api.hf.space/api/predict-batch \\
-          -H "Content-Type: application/json" \\
-          -d '{
-            "objects": [
-              { "koi_period": 10.0, "koi_duration": 5.0, ... },
-              { "koi_period": 15.0, "koi_duration": 6.0, ... }
-            ]
-          }'
+        ## 🌐 Endpoints API para Frontend
+        
+        Tu API está disponible en: **`https://jarpalucas-echo-finder-api.hf.space`**
+        
+        ### 📋 Ejemplos de uso:
+        
+        ```javascript
+        // 1. Predicción individual
+        const features = {
+          koi_period: 10.0,
+          koi_duration: 5.0, 
+          koi_depth: 1000.0,
+          koi_prad: 2.0,
+          koi_srad: 1.0,
+          koi_teq: 1000.0,
+          koi_steff: 6000.0,
+          koi_slogg: 4.5,
+          koi_smet: 0.0,
+          koi_kepmag: 12.0,
+          koi_model_snr: 10.0,
+          koi_num_transits: 3.0
+        };
+        
+        // Usando fetch
+        fetch('https://jarpalucas-echo-finder-api.hf.space/run/predict', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            data: [features]
+          })
+        })
+        .then(response => response.json())
+        .then(data => {
+          console.log('Predicción:', data);
+        });
         ```
         
-        ### 🌐 TOI Tiempo real
-        **GET** `/api/toi-realtime`
-        ```bash
-        curl -X GET https://jarpalucas-echo-finder-api.hf.space/api/toi-realtime
+        ### 🎯 Endpoints disponibles via Gradio:
+        
+        - **POST** `/run/predict` - Para predicción individual
+        - **POST** `/run/predict_toi_realtime` - Para TOI en tiempo real
+        
+        ### 📊 Estructura de respuesta:
+        ```json
+        {
+          "data": [
+            {
+              "prediction": "CONFIRMED",
+              "probabilities": {
+                "CONFIRMED": 0.875,
+                "CANDIDATE": 0.120, 
+                "FALSE_POSITIVE": 0.005
+              },
+              "input_features": {...}
+            }
+          ]
+        }
         ```
         
-        ### 📋 Información de características
-        **GET** `/api/features`
-        ```bash
-        curl -X GET https://jarpalucas-echo-finder-api.hf.space/api/features
+        ### 🔧 Código React ejemplo:
+        ```jsx
+        import React, { useState } from 'react';
+        
+        function ExoplanetPredictor() {
+          const [prediction, setPrediction] = useState(null);
+          const [loading, setLoading] = useState(false);
+          
+          const predictExoplanet = async (features) => {
+            setLoading(true);
+            try {
+              const response = await fetch(
+                'https://jarpalucas-echo-finder-api.hf.space/run/predict',
+                {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ data: [features] })
+                }
+              );
+              const result = await response.json();
+              setPrediction(result.data[0]);
+            } catch (error) {
+              console.error('Error:', error);
+            } finally {
+              setLoading(false);
+            }
+          };
+          
+          return (
+            <div>
+              {/* Tu interfaz aquí */}
+            </div>
+          );
+        }
         ```
         """)
+    
+    with gr.Tab("ℹ️ Información del Modelo"):
+        model_status = "✅ Cargado y funcionando" if model is not None else "❌ No disponible"
+        gr.Markdown(f"""
+        ## Estado del Sistema
+        
+        **Modelo:** {model_status}
+        **TensorFlow:** {'✅ Disponible' if TENSORFLOW_AVAILABLE else '❌ No disponible'}
+        **Características:** {len(feature_columns)} features cargadas
+        
+        ### 📊 Características del Modelo:
+        {", ".join(feature_columns)}
+        
+        ### 🎯 Clases de Predicción:
+        - ✅ **CONFIRMED**: Exoplaneta confirmado
+        - 🔍 **CANDIDATE**: Candidato a exoplaneta  
+        - ❌ **FALSE POSITIVE**: Falso positivo
+        
+        ### 📈 Estadísticas:
+        - Modelo entrenado con datos de Kepler/TESS
+        - Arquitectura: Red Neuronal Artificial
+        - Precisión: Optimizada para clasificación de exoplanetas
+        """)
 
-# ==================== INICIALIZACIÓN ====================
+# ==================== ENDPOINTS GRADIO PARA API ====================
 
-def start_app():
-    """Inicia ambas aplicaciones: Flask API y Gradio"""
-    print("🎉 Eco Finder API iniciada correctamente!")
-    print("🔗 Endpoints REST disponibles en: /api/*")
-    print("🌐 Interfaz web disponible en: /")
-    
-    # Combinar Flask y Gradio
-    from werkzeug.middleware.dispatcher import DispatcherMiddleware
-    from flask import Flask
-    
-    # Crear aplicación combinada
-    combined_app = DispatcherMiddleware(app, {
-        '/': demo.server
-    })
-    
-    return combined_app
+def predict_api(features: Dict) -> Dict:
+    """Endpoint para API desde frontend"""
+    return predict_single_api(features)
+
+# Exponer funciones como endpoints API
+demo.predict = predict_api
+demo.predict_toi_realtime = predict_toi_realtime
+
+print("🎉 Eco Finder API iniciada correctamente!")
+print("🌐 Interfaz web disponible")
+print("🔗 API lista para consumir desde frontend")
 
 if __name__ == "__main__":
-    # Para desarrollo local
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-else:
-    # Para Hugging Face Spaces
-    application = start_app()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)