Update app.py

app.py

@@ -1,5 +1,5 @@
-# ====================    El Detective de Alimentos (Versión 4.0 - Transparencia con Gráficos)  =====================================
-# Mejoras: Gráfico de relevancia de resultados, desglose de puntuación y motor de búsqueda modificado.
+# ====================    El Detective de Alimentos (Versión 5.0 - con Profundización Científica)  =====================================
+# Mejoras: Integración de la base de datos FoodB para una capa de evidencia bioquímica.
 
 import streamlit as st
 import google.generativeai as genai
@@ -9,7 +9,7 @@ import json
 import logging
 import re
 import pandas as pd
-import altair as alt # <-- LIBRERÍA NUEVA
+import altair as alt
 
 st.set_page_config(
     page_title="El Detective de Alimentos",
@@ -17,7 +17,7 @@ st.set_page_config(
     layout="wide"
 )
 
-# ... (El código de configuración de Gemini y carga de datos no cambia) ...
+# ... (El código de configuración de Gemini no cambia) ...
 # Configurar logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger("food_detective_app")
@@ -40,7 +40,7 @@ except Exception as e:
     st.error(f"❌ Error al configurar Gemini API: {e}")
     logger.error(f"Error al configurar Gemini API: {e}")
     st.stop()
-
+    
 @st.cache_resource
 def get_gemini_model():
     """Carga el modelo generativo de Gemini."""
@@ -54,79 +54,62 @@ def get_gemini_model():
 
 model = get_gemini_model()
 
+
+# --- FUNCIÓN DE CARGA DE DATOS MODIFICADA ---
 @st.cache_data
 def load_data():
     """
-    Carga la base de datos principal y la enriquece con el conocimiento dual.
+    Carga todas las bases de conocimiento: datos enriquecidos y el índice de FoodB.
     """
     try:
         path_alimentos = os.path.join('DATOS', 'alimentos_enriquecido.json') 
-        path_dual = os.path.join('DATOS', 'conocimiento_dual.json')
+        path_foodb_index = os.path.join('DATOS', 'foodb_index.json')
 
         with open(path_alimentos, 'r', encoding='utf-8') as f:
             data_alimentos = json.load(f)
         
-        # Cargar el conocimiento dual (si existe)
-        conocimiento_dual = {}
-        if os.path.exists(path_dual):
-            with open(path_dual, 'r', encoding='utf-8') as f:
-                data_dual = json.load(f)
-            # Crear un diccionario para un acceso rápido
-            for item in data_dual:
-                key = item['condicion_asociada']
-                conocimiento_dual[key] = {
-                    'efecto_benefico': item.get('efecto_benefico'),
-                    'contexto_negativo': item.get('contexto_negativo')
-                }
-            logger.info(f"✅ Conocimiento dual cargado con {len(conocimiento_dual)} registros.")
-
-        # Fusionar los datos
-        for entry in data_alimentos:
-            key = entry['condicion_asociada']
-            if key in conocimiento_dual:
-                entry['efecto_benefico'] = conocimiento_dual[key]['efecto_benefico']
-                entry['contexto_negativo'] = conocimiento_dual[key]['contexto_negativo']
-        
         lista_condiciones = sorted(list(set(item['condicion_asociada'] for item in data_alimentos)))
 
-        logger.info(f"✅ Base de datos principal enriquecida y fusionada.")
-        return data_alimentos, lista_condiciones
+        # Cargar el índice de FoodB (si existe)
+        foodb_index = {}
+        if os.path.exists(path_foodb_index):
+            with open(path_foodb_index, 'r', encoding='utf-8') as f:
+                foodb_index = json.load(f)
+            logger.info(f"✅ Índice científico de FoodB cargado con {len(foodb_index)} alimentos.")
+        else:
+            logger.warning("Advertencia: No se encontró 'foodb_index.json'. La funcionalidad de profundización científica estará desactivada.")
+            
+        logger.info(f"✅ Base de datos principal cargada con {len(data_alimentos)} registros.")
+        return data_alimentos, lista_condiciones, foodb_index
 
     except FileNotFoundError as e:
         st.error(f"❌ Error: No se encontró el archivo '{e.filename}'. Asegúrate de que está en la carpeta 'DATOS'.")
-        return None, None
+        return None, None, None
     except json.JSONDecodeError as e:
         st.error(f"❌ Error: Un archivo JSON tiene un formato incorrecto: {e}")
-        return None, None
-alimentos_data, lista_condiciones = load_data()
+        return None, None, None
+
+alimentos_data, lista_condiciones, foodb_index = load_data()
+
 
-# DICCIONARIO DE TRADUCCIÓN AMPLIADO (v3.1)
+# ... (El resto de diccionarios y funciones de búsqueda no cambian) ...
 FOOD_TO_COMPOUND_MAP = {
-    # Gluten
     "pan": ["gluten"], "trigo": ["gluten"], "harina de trigo": ["gluten"], "cebada": ["gluten"], 
     "centeno": ["gluten"], "pasta": ["gluten"], "galletas": ["gluten"], "avena": ["gluten"], "pizza": ["gluten"], "torta": ["gluten"],
-    # Lácteos
     "leche": ["lácteos", "caseína", "lactosa"], "queso": ["lácteos", "caseína", "lactosa", "histamina", "tiramina"], 
     "yogur": ["lácteos", "caseína", "lactosa"], "mantequilla": ["lácteos", "caseína", "lactosa"], "crema": ["lácteos"], "helado": ["lácteos"],
-    # Fenoles y Salicilatos
     "manzana": ["salicilatos", "fructosa"], "almendras": ["salicilatos", "arginina"], "uvas": ["salicilatos"], "pasas": ["salicilatos"], 
     "naranja": ["salicilatos"], "brócoli": ["salicilatos", "goitrógenos", "fodmaps"], "cúrcuma": ["salicilatos"],
-    # Azúcares y Fructosa
     "azucar": ["azúcar", "fructosa"], "dulces": ["azúcar"], "refrescos": ["azúcar", "fructosa"], "gaseosas": ["azúcar", "fructosa"],
     "miel": ["fructosa", "fodmaps"], "jarabe de maiz": ["fructosa"],
-    # Aminas (Histamina, Tiramina)
     "vino tinto": ["histamina", "tiramina", "sulfitos"], "vino rojo": ["histamina", "tiramina", "sulfitos"],
     "cerveza": ["histamina", "tiramina", "purinas", "gluten"], "chocolate": ["cafeína", "tiramina", "níquel", "arginina"],
     "embutidos": ["histamina", "tiramina", "nitritos"], "pescado enlatado": ["histamina"], "tomate": ["histamina", "solaninas", "ácidos"],
-    # FODMAPs
     "aguacate": ["fodmaps", "polioles"], "cebolla": ["fodmaps"], "ajo": ["fodmaps"], "legumbres": ["fodmaps", "gos"],
-    # Otros
     "carne": ["alfa-gal", "proteínas", "purinas", "hierro"], "carnes rojas": ["purinas", "alfa-gal", "hierro"],
     "mariscos": ["purinas", "sulfitos", "alérgenos", "yodo"], "huevo": ["alérgenos"], "soya": ["alérgenos"],
     "café": ["cafeína", "ácidos"], "nueces": ["arginina", "salicilatos", "níquel"]
 }
-
-# NUEVO DICCIONARIO DE SINÓNIMOS DE CONDICIONES
 CONDITION_SYNONYMS = {
     "síndrome del intestino irritable (sii).": [
         "intolerancia a los fodmaps", 
@@ -136,23 +119,16 @@ CONDITION_SYNONYMS = {
     "gota / hiperuricemia.": ["acido urico aumentado"],
     "intolerancia a la lactosa.": ["déficit de lactasa"],
     "enfermedad celíaca (clásica).": ["dermatitis herpetiforme"]
-    # Puedes añadir más sinónimos aquí en el futuro
 }
 
-
-# --- LÓGICA DE BÚSQUEDA Y ANÁLISIS ---
-
-# ... (La función extract_and_infer_with_gemini no cambia) ...
 def extract_and_infer_with_gemini(query, condiciones):
     """Extrae entidades e infiere una condición probable."""
     if not model: return None
     condiciones_str = "\n".join([f"- {c}" for c in condiciones])
     system_prompt = f"""
     Eres un asistente de triaje clínico. Analiza la consulta, extrae 'alimentos', 'sintomas' (normalizados) y la 'condicion_probable' más relevante de la lista proporcionada. Devuelve solo un JSON. Si no puedes inferir una condición, déjalo como un string vacío.
-
     LISTA DE CONDICIONES POSIBLES:
     {condiciones_str}
-
     Consulta: "{query}"
     """
     try:
@@ -168,43 +144,28 @@ def extract_and_infer_with_gemini(query, condiciones):
         st.error(f"Hubo un problema al interpretar tu consulta con la IA.")
         return None
 
-# --- FUNCIÓN DE BÚSQUEDA MODIFICADA ---
 def find_best_matches_hybrid(entities, data):
-    """
-    Motor de búsqueda híbrido (v4.1) con manejo de sinónimos de condiciones.
-    """
+    """Motor de búsqueda híbrido (v4.1) con manejo de sinónimos de condiciones."""
     if not entities or not data: return []
-    
     user_symptoms = set(s.lower().strip() for s in entities.get("sintomas", []))
     user_foods = set(f.lower().strip() for f in entities.get("alimentos", []))
     inferred_condition_raw = entities.get("condicion_probable", "").lower().strip()
-
     candidate_terms = set(user_foods)
     for food in user_foods:
         if food in FOOD_TO_COMPOUND_MAP:
             candidate_terms.update(c.lower() for c in FOOD_TO_COMPOUND_MAP[food])
-
     results = []
     for index, entry in enumerate(data):
         score_details = {'condition': 0, 'food': 0, 'symptoms': 0, 'total': 0}
-        
-        # --- PONDERACIÓN 1: COINCIDENCIA DE CONDICIÓN (CON SINÓNIMOS) ---
         entry_condition = entry.get("condicion_asociada", "").lower().strip()
-        
-        # Comprobación directa
         if inferred_condition_raw and inferred_condition_raw == entry_condition:
             score_details['condition'] = 100
-        # Comprobación de sinónimos
         elif inferred_condition_raw and entry_condition in CONDITION_SYNONYMS:
             if inferred_condition_raw in CONDITION_SYNONYMS[entry_condition]:
                 score_details['condition'] = 100
-
-        # --- PONDERACIÓN 2: COINCIDENCIA DE ALIMENTOS/COMPUESTOS ---
         entry_compounds_text = entry.get("compuesto_alimento", "").lower()
         if any(term in entry_compounds_text for term in candidate_terms):
             score_details['food'] = 20
-            
-        # --- PONDERACIÓN 3: COINCIDENCIA DE SÍNTOMAS ---
         entry_symptoms_keys = set(s.lower().strip() for s in entry.get("sintomas_clave", []))
         symptom_score = 0
         for user_symptom in user_symptoms:
@@ -213,23 +174,18 @@ def find_best_matches_hybrid(entities, data):
                     symptom_score += 5
                     break
         score_details['symptoms'] = symptom_score
-        
         total_score = sum(score_details.values())
         if total_score > 0:
             score_details['total'] = total_score
             results.append({'entry': entry, 'score': score_details})
-            
     if not results: return []
-
     sorted_results = sorted(results, key=lambda x: x['score']['total'], reverse=True)
     return sorted_results
 
-# ... (La función generate_detailed_analysis no cambia) ...
 def generate_detailed_analysis(query, match):
     """Genera la explicación final, manejando la información de dualidad si existe."""
+    # (Esta función no necesita cambios)
     if not model: return "Error: El modelo de IA no está disponible."
-    
-    # Construcción del prompt dinámico
     prompt_parts = [
         "Eres un asistente de IA experto en nutrición personalizada. Tu tono es empático, claro y muy educativo. NO actúas como un médico, sino como un guía informativo.",
         f'El usuario ha descrito el siguiente caso: "{query}"',
@@ -238,37 +194,28 @@ def generate_detailed_analysis(query, match):
         f'- Mecanismo: {match.get("mecanismo_fisiologico")}',
         f'- Recomendaciones: {match.get("recomendaciones_examenes")}',
         f'- Alimentos Implicados: {match.get("compuesto_alimento")}',
-        
         "\n**Tu Tarea:** Redacta una respuesta excepcional para el usuario usando Markdown. Sigue esta estructura OBLIGATORIAMENTE:",
-        
         f'### Posible Causa: {match.get("condicion_asociada")}',
         f'Hola. Entiendo que te preocupa lo que sientes. Basado en los síntomas y alimentos que mencionaste, existe una posible relación con una condición conocida como **{match.get("condicion_asociada")}**.',
-        
         f'### ¿Qué podría estar pasando en tu cuerpo?',
         f'Explica el siguiente mecanismo en términos muy sencillos, usando una analogía si es posible: "{match.get("mecanismo_fisiologico")}"'
     ]
-    
-    # --- Lógica para añadir la sección de dualidad ---
     if match.get("efecto_benefico") and match.get("contexto_negativo"):
         prompt_parts.append(
             "\n### El Doble Filo de Estos Alimentos\n"
             f'**Para la mayoría de las personas:** Resume por qué estos alimentos son generalmente buenos, basándote en: "{match.get("efecto_benefico")}"\n'
             f'**Sin embargo, en ciertos contextos:** Explica por qué pueden ser problemáticos para el usuario, basándote en: "{match.get("contexto_negativo")}"'
         )
-
     prompt_parts.extend([
         "\n### Pasos a Seguir y Recomendaciones",
         "Aquí te dejo algunas recomendaciones generales. Es fundamental que las converses con un profesional de la salud:",
         f'*   **[Punto 1 de las recomendaciones, reformulado como un consejo práctico basado en "{match.get("recomendaciones_examenes")}"]**',
         f'*   **[Punto 2 de las recomendaciones, enfocado en los exámenes si los hay, basado en "{match.get("recomendaciones_examenes")}"]**',
         f'*   **Atención a otros alimentos:** Ten en cuenta que, además de lo que mencionaste, otros alimentos implicados en esta condición son: **[menciona 2-3 ejemplos del campo "{match.get("compuesto_alimento")}"]**.',
-        
         "\n### **IMPORTANTE: Descargo de Responsabilidad**",
         "Este análisis es una herramienta informativa y de orientación basada en inteligencia artificial. **NO es un diagnóstico médico.** La información proporcionada no debe sustituir la consulta, el diagnóstico o el tratamiento de un médico o profesional de la salud cualificado. Consulta siempre a un experto para evaluar tu caso particular."
     ])
-    
     prompt = "\n".join(prompt_parts)
-
     try:
         response = model.generate_content(prompt)
         return response.text
@@ -276,36 +223,23 @@ def generate_detailed_analysis(query, match):
         logger.error(f"Error generando análisis detallado con Gemini: {e}")
         return "No se pudo generar el análisis detallado."
         
-# --- NUEVA FUNCIÓN PARA CREAR EL GRÁFICO ---
 def create_relevance_chart(results):
     """Crea un gráfico de barras de Altair legible para visualizar la relevancia."""
-    # Preparar los datos para el gráfico (tomamos los 5 mejores)
     top_results = results[:5]
-    
-    # Limpiamos los nombres para que no sean excesivamente largos en el gráfico
     condition_names = []
     for res in top_results:
-        # Quitamos paréntesis y acortamos si es necesario para el display
         name = re.sub(r'\(.*\)', '', res['entry']['condicion_asociada']).strip()
         condition_names.append(name)
-
     chart_data = {
         "Condición": condition_names,
         "Relevancia": [res['score']['total'] for res in top_results]
     }
     source = pd.DataFrame(chart_data)
-
-    # Crear el gráfico
     chart = alt.Chart(source).mark_bar(color='#1f77b4').encode(
         x=alt.X('Relevancia:Q', title='Puntuación de Relevancia'),
         y=alt.Y('Condición:N', sort='-x', title='Posible Condición', 
-                axis=alt.Axis(
-                    labelLimit=300  # <-- ¡ESTA ES LA LÍNEA CLAVE! Aumenta el espacio para las etiquetas.
-                )),
-        tooltip=[
-            alt.Tooltip('Condición:N', title='Condición'),
-            alt.Tooltip('Relevancia:Q', title='Puntuación')
-        ]
+                axis=alt.Axis(labelLimit=300)),
+        tooltip=[alt.Tooltip('Condición:N', title='Condición'), alt.Tooltip('Relevancia:Q', title='Puntuación')]
     ).properties(
         title='Principales Coincidencias según tu Caso'
     ).configure_axis(
@@ -313,12 +247,22 @@ def create_relevance_chart(results):
         titleFontSize=14
     ).configure_title(
         fontSize=16,
-        anchor='start' # Alinea el título a la izquierda, se ve más profesional
+        anchor='start'
     )
     return chart
 
-    
-# --- INTERFAZ DE USUARIO (UI) ---
+# --- NUEVA FUNCIÓN AUXILIAR ---
+def extract_foods_from_string(food_string):
+    """Extrae una lista de alimentos de la cadena 'compuesto_alimento'."""
+    # Quita el texto en paréntesis al principio
+    main_part = re.sub(r'^\w+\s*\(.*?\)\s*', '', food_string)
+    # Quita el texto en paréntesis al final
+    foods_part = re.sub(r'\(.*\)', '', main_part).strip()
+    # Divide por comas y limpia los espacios
+    return [food.strip().lower() for food in foods_part.split(',') if food.strip()]
+
+
+# --- INTERFAZ DE USUARIO (UI) MODIFICADA ---
 col_img, col_text = st.columns([1, 4], gap="medium")
 with col_img:
     if os.path.exists("imagen.png"):
@@ -328,7 +272,6 @@ with col_text:
     st.markdown("##### Describe lo que sientes y lo que comiste para descubrir posibles intolerancias.")
 st.markdown("---")
 
-# --- LÓGICA PRINCIPAL DE LA APLICACIÓN ---
 if 'search_results' not in st.session_state: st.session_state.search_results = None
 if 'user_query' not in st.session_state: st.session_state.user_query = ""
 
@@ -337,7 +280,7 @@ def clear_search_state():
     st.session_state.user_query = ""
 
 with st.form(key="search_form"):
-    query = st.text_area("Describe tu caso aquí:", height=150, placeholder="Ej: Cuando como mucho pan se me hincha el estomago y me salen ampollas en los codos")
+    query = st.text_area("Describe tu caso aquí:", height=150, placeholder="Ej: Cuando como mucha carne me duele el dedo gordo del pie...")
     submitted = st.form_submit_button("Analizar mi caso", type="primary")
 
 if submitted:
@@ -351,12 +294,12 @@ if submitted:
             entities = extract_and_infer_with_gemini(query, lista_condiciones)
         
         if entities and (entities.get("alimentos") or entities.get("sintomas")):
+            # ... (código de info_str sin cambios) ...
             info_str = f"IA identificó - Alimentos: {', '.join(entities.get('alimentos',[])) or 'Ninguno'}"
             info_str += f", Síntomas: {', '.join(entities.get('sintomas',[])) or 'Ninguno'}"
             if entities.get("condicion_probable"):
                 info_str += f", Condición Probable: {entities.get('condicion_probable')}"
             st.info(info_str)
-
             with st.spinner("🔬 Cruzando información y calculando relevancia..."):
                 results = find_best_matches_hybrid(entities, alimentos_data)
                 st.session_state.search_results = results
@@ -375,22 +318,47 @@ if st.session_state.search_results is not None:
     else:
         st.success(f"Hemos encontrado {len(results)} posible(s) causa(s) relacionada(s) con tu caso.")
         
-        # --- SECCIÓN DEL GRÁFICO NUEVA ---
         st.subheader("Análisis de Relevancia de las Coincidencias")
         chart = create_relevance_chart(results)
         st.altair_chart(chart, use_container_width=True)
 
-        best_match = results[0]['entry']
-        best_score = results[0]['score']
+        best_match_data = results[0]
+        best_match = best_match_data['entry']
+        best_score = best_match_data['score']
 
         with st.expander(f"**Análisis Detallado de la Principal Coincidencia: {best_match.get('condicion_asociada')}**", expanded=True):
-            # Mostramos el desglose de la puntuación
-            st.markdown("##### Desglose de la Puntuación de Relevancia:")
-            col1, col2, col3, col4 = st.columns(4)
-            col1.metric("Puntos por Condición", f"{best_score['condition']}")
-            col2.metric("Puntos por Alimento", f"{best_score['food']}")
-            col3.metric("Puntos por Síntomas", f"{best_score['symptoms']}")
-            col4.metric("PUNTUACIÓN TOTAL", f"{best_score['total']}", delta="Máxima coincidencia")
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.markdown("##### Desglose de la Puntuación de Relevancia:")
+                score_col1, score_col2, score_col3, score_col4 = st.columns(4)
+                score_col1.metric("Puntos por Condición", f"{best_score['condition']}")
+                score_col2.metric("Puntos por Alimento", f"{best_score['food']}")
+                score_col3.metric("Puntos por Síntomas", f"{best_score['symptoms']}")
+                score_col4.metric("PUNTUACIÓN TOTAL", f"{best_score['total']}", delta="Máxima coincidencia")
+            
+            # --- NUEVO POPOVER PARA PROFUNDIZACIÓN CIENTÍFICA ---
+            with col2:
+                st.write("") # Espacio para alinear
+                if foodb_index:
+                    with st.popover("🔬 Evidencia Bioquímica"):
+                        st.markdown("##### Componentes y Efectos Moleculares (Datos de FoodB.ca)")
+                        alimentos_a_buscar = extract_foods_from_string(best_match.get("compuesto_alimento", ""))
+                        if not alimentos_a_buscar:
+                            st.write("No se encontraron alimentos específicos para analizar en la base de datos científica.")
+                        else:
+                            found_data = False
+                            for alimento in alimentos_a_buscar[:3]: # Limitamos a los 3 primeros para no sobrecargar
+                                if alimento in foodb_index:
+                                    found_data = True
+                                    with st.container(border=True):
+                                        st.subheader(f"Análisis de: {alimento.capitalize()}")
+                                        for item in foodb_index[alimento][:5]: # Limitamos a 5 compuestos por alimento
+                                            st.write(f"**Compuesto:** {item['compound']}")
+                                            st.write(f"**Efectos reportados:** {', '.join(item['effects'])}")
+                                            st.markdown("---")
+                            if not found_data:
+                                st.write(f"No se encontraron datos moleculares para '{', '.join(alimentos_a_buscar)}' en la base de datos de FoodB.")
+
             st.markdown("---")
             
             with st.spinner("✍️ Generando un análisis personalizado con IA..."):
@@ -399,6 +367,7 @@ if st.session_state.search_results is not None:
 
         if len(results) > 1:
             with st.expander("Otras posibles coincidencias (ordenadas por relevancia)"):
+                # ... (código para mostrar otras coincidencias no cambia) ...
                 for result in results[1:]:
                     entry = result['entry']
                     score = result['score']