Update app.py

app.py

@@ -684,15 +684,13 @@ def find_best_matches_hybrid(entities, data):
 
 @retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
 
-def find_best_foodb_match(user_foods_es, foodb_index_keys, food_name_map):
+def find_best_foodb_matches(user_foods_es, foodb_index_keys, food_name_map, limit=3):
     """
-    Encuentra la mejor y única coincidencia de alimento en la base de datos de FoodB
-    utilizando un algoritmo de "embudo de especificidad".
+    Encuentra una lista de las mejores coincidencias de alimentos en FoodB, priorizando la especificidad.
     """
     if not user_foods_es:
-        return None
+        return []
 
-    # 1. Traducir y ordenar los términos de búsqueda del más al menos específico
     search_terms_en = set()
     for food_es in user_foods_es:
         for key_es, value_en_list in food_name_map.items():
@@ -700,35 +698,28 @@ def find_best_foodb_match(user_foods_es, foodb_index_keys, food_name_map):
                 search_terms_en.update(value_en_list)
     
     if not search_terms_en:
-        return None
+        return []
         
     sorted_terms = sorted(list(search_terms_en), key=len, reverse=True)
-
-    # 2. Búsqueda por prioridades (Embudo de Especificidad)
     
-    # Prioridad 1: Coincidencia Perfecta
+    found_matches = []
+    
+    # Búsqueda por prioridades
     for term in sorted_terms:
+        # Prioridad 1: Coincidencia perfecta
         for key in foodb_index_keys:
-            if term == key.lower():
-                logger.info(f"Coincidencia Perfecta encontrada para '{term}': {key}")
-                return key
-
-    # Prioridad 2: Coincidencia de Inicio de Palabra
-    for term in sorted_terms:
+            if term == key.lower() and key not in found_matches:
+                found_matches.append(key)
+        # Prioridad 2: Coincidencia de inicio
         for key in foodb_index_keys:
-            if key.lower().startswith(term):
-                logger.info(f"Coincidencia de Inicio encontrada para '{term}': {key}")
-                return key
-
-    # Prioridad 3: Coincidencia General (contiene)
-    for term in sorted_terms:
+            if key.lower().startswith(term) and key not in found_matches:
+                found_matches.append(key)
+        # Prioridad 3: Coincidencia general
         for key in foodb_index_keys:
-            if term in key.lower():
-                logger.info(f"Coincidencia General encontrada para '{term}': {key}")
-                return key
-    
-    logger.warning(f"No se encontró ninguna coincidencia molecular para los términos: {sorted_terms}")
-    return None # No se encontró ninguna coincidencia
+            if term in key.lower() and key not in found_matches:
+                found_matches.append(key)
+
+    return found_matches[:limit]
     
 def generate_detailed_analysis(query, match):
     if not model: return "Error: El modelo de IA no está disponible."
@@ -920,81 +911,49 @@ if st.session_state.search_results is not None:
 
                 st.write("") 
                 if foodb_index:
-                    with st.popover("🔬 Componentes Moleculares Relevantes"):
+                    with st.popover("🔬 Componentes Moleculares del Diagnóstico"):
                         
-                        REMEDIAL_PREFIXES = ("anti", "preventive", "remedy", "treatment", "inhibitor", "anxiolytic", "analgesic")
-
-                        st.info("Compuestos en el alimento más relevante que podrían estar relacionados con tus síntomas.")
+                        st.info("Análisis de los compuestos en los alimentos mencionados que están directamente implicados en el diagnóstico principal.")
                         
                         user_foods_mentioned = st.session_state.entities.get("alimentos", [])
-                        user_symptoms_es = st.session_state.entities.get("sintomas", [])
                         
-                        if not user_foods_mentioned or not user_symptoms_es:
-                            st.warning("Se necesita al menos un alimento y un síntoma para el análisis molecular.")
+                        if not user_foods_mentioned:
+                            st.warning("No se identificó un alimento específico para buscar.")
                         else:
-                            best_food_match_key = find_best_foodb_match(user_foods_mentioned, foodb_index.keys(), FOOD_NAME_TO_FOODB_KEY)
+                            # 1. IDENTIFICAR LOS COMPUESTOS OBJETIVO DEL DIAGNÓSTICO
+                            target_compounds_text = best_match.get("compuesto_alimento", "").lower()
+                            # Extraer palabras clave del texto (ej. "purinas", "histamina")
+                            target_keywords = set(re.findall(r'\b\w+\b', re.sub(r'\(.*?\)', '', target_compounds_text)))
+
+                            # 2. ENCONTRAR LOS ALIMENTOS MÁS RELEVANTES
+                            best_food_matches = find_best_foodb_matches(user_foods_mentioned, foodb_index.keys(), FOOD_NAME_TO_FOODB_KEY)
 
-                            if not best_food_match_key:
+                            if not best_food_matches:
                                 st.warning("No se encontraron datos moleculares para los alimentos específicos mencionados.")
                             else:
-                                st.subheader(f"Análisis de: {best_food_match_key.capitalize()}")
-                                
-                                compounds_data = foodb_index[best_food_match_key]
-                                symptom_keywords_en = {kw for sym in user_symptoms_es if sym in MASTER_SYMPTOM_MAP for kw in MASTER_SYMPTOM_MAP[sym].get('keywords_en', [])}
-
-                                causative_compounds = []
-                                remedial_compounds = []
-
-                                for item in compounds_data:
-                                    compound_name = item['compound']
-                                    effects_en = item.get("effects", [])
+                                found_any_data = False
+                                for food_key in best_food_matches:
+                                    compounds_data = foodb_index.get(food_key, [])
                                     
-                                    # --- LÓGICA DE PRIORIDAD ---
-                                    # 1. ¿Es un desencadenante conocido para ESTE síntoma?
-                                    is_known_trigger = False
-                                    if compound_name in KNOWN_TRIGGERS_MAP:
-                                        if any(symptom in KNOWN_TRIGGERS_MAP[compound_name] for symptom in user_symptoms_es):
-                                            causative_compounds.append(item)
-                                            is_known_trigger = True
-                                    
-                                    if is_known_trigger:
-                                        continue # Si ya es un culpable, no lo analizamos más
-
-                                    # 2. Si no, analizar efectos para causas o remedios
-                                    is_causative = False
-                                    is_remedial = False
-                                    for effect in effects_en:
-                                        if any(keyword in effect.lower() for keyword in symptom_keywords_en):
-                                            if effect.lower().startswith(REMEDIAL_PREFIXES):
-                                                is_remedial = True
-                                            else:
-                                                is_causative = True
-                                    
-                                    if is_causative:
-                                        causative_compounds.append(item)
-                                    elif is_remedial:
-                                        remedial_compounds.append(item)
-
-                                # 3. Mostrar los resultados de forma priorizada
-                                if causative_compounds:
-                                    st.markdown("###### 🔬 Posibles Compuestos Desencadenantes:")
-                                    for item in causative_compounds[:5]:
-                                        st.write(f"**Compuesto:** {item['compound']}")
-                                        # Mostramos por qué es un desencadenante conocido, o los efectos relevantes
-                                        if item['compound'] in KNOWN_TRIGGERS_MAP:
-                                            st.write(f"**Efectos Relevantes:** Desencadenante conocido de {', '.join([s for s in user_symptoms_es if s in KNOWN_TRIGGERS_MAP[item['compound']]])}")
-                                        else:
-                                            relevant_effects = [eff for eff in item['effects'] if any(kw in eff.lower() and not eff.lower().startswith(REMEDIAL_PREFIXES) for kw in symptom_keywords_en)]
-                                            st.write(f"**Efectos Relevantes:** {', '.join(relevant_effects)}")
-                                elif remedial_compounds:
-                                    st.markdown("###### 💊 Compuestos con Efectos Potencialmente Beneficiosos:")
-                                    st.caption("No se encontraron compuestos desencadenantes directos en la base de datos.")
-                                    for item in remedial_compounds[:5]:
-                                        st.write(f"**Compuesto:** {item['compound']}")
-                                        relevant_effects = [eff for eff in item['effects'] if any(kw in eff.lower() and eff.lower().startswith(REMEDIAL_PREFIXES) for kw in symptom_keywords_en)]
-                                        st.write(f"**Efectos Relevantes:** {', '.join(relevant_effects)}")
-                                else:
-                                    st.write("No se encontraron compuestos relevantes para tus síntomas en este alimento.")
+                                    # 3. BUSCAR LOS COMPUESTOS OBJETIVO EN CADA ALIMENTO
+                                    relevant_compounds = []
+                                    for item in compounds_data:
+                                        compound_name_lower = item['compound'].lower()
+                                        # Comprobar si el nombre del compuesto está relacionado con los objetivos
+                                        if any(keyword in compound_name_lower for keyword in target_keywords):
+                                            relevant_compounds.append(item)
+
+                                    if relevant_compounds:
+                                        found_any_data = True
+                                        with st.container(border=True):
+                                            st.subheader(f"Análisis de: {food_key.capitalize()}")
+                                            st.markdown("###### 🔬 Compuestos Relevantes para el Diagnóstico:")
+                                            for item in relevant_compounds[:5]:
+                                                st.write(f"**Compuesto:** {item['compound']}")
+                                                st.caption(f"Este compuesto está directamente relacionado con '{best_match.get('condicion_asociada')}'.")
+                                
+                                if not found_any_data:
+                                    st.warning(f"No se encontraron los compuestos específicos de '{best_match.get('condicion_asociada')}' en los alimentos analizados en la base de datos FoodB.")
             
             st.markdown("---")