Update app.py

app.py

@@ -697,27 +697,28 @@ def reinforce_entities_with_keywords(entities, query, food_map, master_symptom_m
     return entities
 def find_best_matches_hybrid(entities, data):
     """
-    Motor de búsqueda semántico y ponderado final.
-    Reintegra el conocimiento de FOOD_TO_COMPOUND_MAP en la búsqueda de alimentos.
+    Motor de búsqueda semántico y holístico (Versión Final).
+    Crea una "nube de palabras clave" para el usuario y para cada entrada de la BD,
+    y puntúa basándose en el tamaño de su intersección.
     """
     if not entities or not data: return []
     
-    # 1. PROCESAR INPUT DEL USUARIO
-    user_symptoms_text = " ".join(entities.get("sintomas", []))
-    user_symptom_keywords = set(re.findall(r'\b\w+\b', sanitize_text(user_symptoms_text)))
+    # --- 1. CREAR LA "NUBE DE PALABRAS CLAVE DEL USUARIO" ---
+    user_symptoms_list = entities.get("sintomas", [])
+    user_foods_list = entities.get("alimentos", [])
     
-    user_foods_raw = entities.get("alimentos", [])
-    user_food_keywords_base = set(re.findall(r'\b\w+\b', sanitize_text(" ".join(user_foods_raw))))
-
-    # --- PASO CRUCIAL: REINTEGRAR EL CONOCIMIENTO EXPERTO ---
-    user_food_keywords_expanded = set(user_food_keywords_base)
-    for food in user_foods_raw:
+    # Combinar síntomas y alimentos en un solo texto
+    user_text = " ".join(user_symptoms_list) + " " + " ".join(user_foods_list)
+    user_keywords_base = set(re.findall(r'\b\w+\b', sanitize_text(user_text)))
+    
+    # Expandir con el conocimiento bioquímico de FOOD_TO_COMPOUND_MAP
+    user_keywords_expanded = set(user_keywords_base)
+    for food in user_foods_list:
         if food in FOOD_TO_COMPOUND_MAP:
-            user_food_keywords_expanded.update(FOOD_TO_COMPOUND_MAP[food])
+            user_keywords_expanded.update(FOOD_TO_COMPOUND_MAP[food])
+    
+    user_keywords = user_keywords_expanded
     
-    # Usamos la lista expandida para la búsqueda
-    user_food_keywords = user_food_keywords_expanded
-
     RARE_CONDITIONS = [
         "Porfiria Aguda Intermitente (PAI).", "Enfermedad de Refsum del Adulto.",
         "Ataxia por Gluten.", "Encefalopatía por Gluten.", "Enfermedad de Wilson.",
@@ -726,33 +727,23 @@ def find_best_matches_hybrid(entities, data):
     
     results = []
     for entry in data:
-        score_details = {'food': 0, 'symptoms': 0, 'bonus': 0}
-        
-        # 2. PROCESAR INPUT DE LA BASE DE DATOS
+        # --- 2. CREAR LA "NUBE DE PALABRAS CLAVE DE LA BASE DE DATOS" ---
         db_food_text = entry.get("compuesto_alimento", "")
-        db_food_keywords = set(re.findall(r'\b\w+\b', sanitize_text(re.sub(r'\(.*?\)', '', db_food_text))))
-        
         db_symptoms_text = " ".join(entry.get("sintomas_clave", []))
-        db_symptom_keywords = set(re.findall(r'\b\w+\b', sanitize_text(db_symptoms_text)))
-
-        # 3. COMPARACIÓN INTELIGENTE Y PUNTUACIÓN
         
-        # Puntuación de Alimento con la lista expandida
-        food_intersection = user_food_keywords.intersection(db_food_keywords)
-        if food_intersection:
-            score_details['food'] = 20
-            # Bonus por alta confianza
-            if len(food_intersection) / len(user_food_keywords.union(db_food_keywords)) > 0.1: # Umbral más bajo
-                score_details['bonus'] = 30
+        db_text = db_food_text + " " + db_symptoms_text
+        db_keywords = set(re.findall(r'\b\w+\b', sanitize_text(db_text)))
         
-        # Puntuación de Síntomas por intersección
-        symptom_intersection = user_symptom_keywords.intersection(db_symptom_keywords)
-        score_details['symptoms'] = len(symptom_intersection) * 30
+        # --- 3. PUNTUACIÓN POR INTERSECCIÓN ---
+        intersection = user_keywords.intersection(db_keywords)
         
-        # Solo considerar resultados que tengan alguna coincidencia de alimento Y síntoma
-        if score_details['food'] > 0 and score_details['symptoms'] > 0:
-            base_score = score_details['food'] + score_details['symptoms'] + score_details['bonus']
+        # Solo procesar si hay al menos una palabra en común
+        if intersection:
+            score_details = {}
+            # La puntuación base es el número de palabras clave coincidentes al cuadrado para dar más peso a coincidencias múltiples
+            base_score = (len(intersection) ** 2) * 10
             
+            # Ponderación por rareza
             condition_name = entry.get("condicion_asociada", "")
             if condition_name in RARE_CONDITIONS:
                 final_score = base_score * 0.4 
@@ -761,11 +752,13 @@ def find_best_matches_hybrid(entities, data):
 
             score_details['total'] = int(final_score)
             
-            results.append({
-                'entry': entry, 
-                'score': score_details, 
-                'matched_symptoms': list(symptom_intersection)
-            })
+            # Añadir a resultados si supera un umbral mínimo para evitar ruido
+            if score_details['total'] > 10: # Umbral bajo para permitir coincidencias débiles pero relevantes
+                results.append({
+                    'entry': entry, 
+                    'score': score_details, 
+                    'matched_keywords': list(intersection) # Guardamos las palabras coincidentes
+                })
 
     if not results: return []
     return sorted(results, key=lambda x: x['score']['total'], reverse=True)
@@ -1187,53 +1180,43 @@ if st.session_state.start_analysis:
             st.error("No se pudieron identificar alimentos o síntomas claros en tu descripción. Intenta ser más específico.")
             st.session_state.search_results = []
     
-
 if st.session_state.search_results is not None:
     results = st.session_state.search_results
     
     if not results:
         st.warning(f"No se encontraron coincidencias claras para tu caso: '{st.session_state.user_query}'. Prueba a describir los síntomas de otra manera.")
     else:
-        # --- PASO 1: DEFINIR EL DIAGNÓSTICO PRINCIPAL Y GENERAR TODO EL CONTENIDO ---
         best_match_data = results[0]
         best_match = best_match_data['entry']
         
-        # Generar análisis de IA (la parte más lenta) y guardarlo en caché
-        if 'best_match_analysis' not in st.session_state.analysis_cache:
-            with st.spinner("✍️ Generando análisis personalizado con IA... (esto puede tardar un momento)"):
+        ai_analysis_text = st.session_state.analysis_cache.get('best_match_analysis', "")
+        if not ai_analysis_text:
+             with st.spinner("✍️ Generando análisis personalizado con IA..."):
                 try:
                     analysis_text = generate_detailed_analysis(st.session_state.user_query, best_match)
                     st.session_state.analysis_cache['best_match_analysis'] = analysis_text
+                    ai_analysis_text = analysis_text
                 except Exception as e:
-                    logger.error(f"Falló la generación del análisis detallado principal: {e}")
-                    st.session_state.analysis_cache['best_match_analysis'] = "❌ Lo sentimos, no se pudo generar el análisis detallado en este momento debido a un problema con la IA."
-        
-        ai_analysis_text = st.session_state.analysis_cache['best_match_analysis']
+                    st.session_state.analysis_cache['best_match_analysis'] = "❌ No se pudo generar el análisis detallado."
+                    ai_analysis_text = st.session_state.analysis_cache['best_match_analysis']
 
-        # Generar los otros componentes de texto para el informe
-        base_report_text = generate_report_text(st.session_state.user_query, results)
         neuro_report_text = generate_neuro_report_text(st.session_state.entities, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP)
         molecular_report_text = generate_molecular_report_text(best_match, st.session_state.entities, foodb_index, FOOD_NAME_TO_FOODB_KEY, COMPOUND_SYNONYM_MAP, KNOWN_TRIGGERS_MAP)
         
-        # Unir todo en un solo string para el informe de Word
-        complete_report_string = f"{base_report_text}\n\n{ai_analysis_text}\n{neuro_report_text}\n{molecular_report_text}"
-        
-        # Generar el archivo de Word en memoria
-        word_file_buffer = generate_word_report(complete_report_string)
-
-        # --- PASO 2: CONSTRUIR LA INTERFAZ DE USUARIO CON EL CONTENIDO YA GENERADO ---
         col1, col2 = st.columns([3,1])
         with col1:
             st.success(f"Hemos encontrado {len(results)} posible(s) causa(s) relacionada(s) con tu caso.")
         with col2:
+            base_report_text = generate_report_text(st.session_state.user_query, results)
+            complete_report_string = f"{base_report_text}\n\n{ai_analysis_text}\n{neuro_report_text}\n{molecular_report_text}"
+            word_file_buffer = generate_word_report(complete_report_string)
             if word_file_buffer:
                 st.download_button(
                     label="📄 Descargar Informe (Word)", 
                     data=word_file_buffer, 
                     file_name=f"Informe_Detective_Alimentos_{datetime.now().strftime('%Y%m%d')}.docx",
                     mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                    key="download_word_report",
-                    help="Genera y descarga un informe completo en formato Word con todos los análisis."
+                    key="download_word_report"
                 )
         
         st.subheader("Análisis de Relevancia de las Coincidencias")
@@ -1244,11 +1227,10 @@ if st.session_state.search_results is not None:
             
             with col1_expander:
                 st.markdown("##### Desglose de la Puntuación de Relevancia:")
-                score_col1, score_col2, score_col3 = st.columns(3)
-                score_col1.metric("Puntos por Alimento(s)", f"{best_match_data['score']['food']}")
-                score_col2.metric("Puntos por Síntomas", f"{best_match_data['score']['symptoms']}")
-                score_col3.metric("PUNTUACIÓN TOTAL", f"{best_match_data['score']['total']}", delta="Máxima coincidencia")
-            
+                st.metric("Puntuación de Relevancia Total", f"{best_match_data['score']['total']}", delta="Máxima coincidencia")
+                if 'matched_keywords' in best_match_data and best_match_data['matched_keywords']:
+                    st.caption(f"Pistas Clave Coincidentes: {', '.join(best_match_data['matched_keywords'])}")
+
             with col2_expander:
                 with st.popover("🔬 Componentes Moleculares"):
                     st.markdown(molecular_report_text.replace("=", ""))
@@ -1265,18 +1247,16 @@ if st.session_state.search_results is not None:
                 for i, result in enumerate(results[1:5]): 
                     with st.container(border=True):
                         entry = result['entry']
-                        score = result['score']
-                        
                         st.subheader(f"{i+2}. {entry.get('condicion_asociada')}")
                         col_info, col_action = st.columns([3, 1])
                         
                         with col_info:
-                            if result.get('matched_symptoms'):
-                                st.markdown(f"**Pistas Clave (Síntomas Coincidentes):** {', '.join(result['matched_symptoms']).capitalize()}")
+                            if 'matched_keywords' in result and result['matched_keywords']:
+                                st.markdown(f"**Pistas Clave Coincidentes:** {', '.join(result['matched_keywords']).capitalize()}")
                             st.markdown(f"**Alimentos Típicos Asociados:** {entry.get('compuesto_alimento')}")
                         
                         with col_action:
-                            st.metric("Relevancia", score['total'])
+                            st.metric("Relevancia", result['score']['total'])
                             analysis_key = f"analysis_{i+2}"
                             
                             if st.button("Generar análisis", key=analysis_key, help=f"Generar análisis de IA para {entry.get('condicion_asociada')}"):
@@ -1285,10 +1265,10 @@ if st.session_state.search_results is not None:
                                         analysis_text = generate_detailed_analysis(st.session_state.user_query, entry)
                                         st.session_state.analysis_cache[analysis_key] = analysis_text
                                     except Exception as e:
-                                        st.session_state.analysis_cache[analysis_key] = f"❌ Error al generar análisis para {entry.get('condicion_asociada')}."
+                                        st.session_state.analysis_cache[analysis_key] = f"❌ Error al generar análisis."
                         
                         if analysis_key in st.session_state.analysis_cache:
                             st.info(st.session_state.analysis_cache[analysis_key])
                     
                     if i < len(results[1:5]) - 1:
-                        st.markdown("---")
+                        st.markdown("---")