Update app.py

app.py

@@ -1,4 +1,4 @@
-# ====================    El Detective de Alimentos (Versión 10.1)  =====================================
+# ====================    El Detective de Alimentos (Versión 11.0)  =====================================
 # Por: JAIRO CESAR ALEXANDER E. MD DIANA MILENA SOLER MARTINEZ PSI. ESP. U JUAN N CORPAS
 
 import streamlit as st
@@ -20,7 +20,6 @@ st.set_page_config(
 )
 
 # --- CONFIGURACIÓN Y CARGA DE DATOS ---
-# (Esta sección no tiene cambios)
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger("food_detective_app")
 try:
@@ -164,16 +163,11 @@ SYMPTOM_KEYWORD_MAP = {
 }
 
 def reinforce_entities_with_keywords(entities, query, food_map, symptom_map):
-    """
-    Revisa la salida de la IA y añade alimentos Y síntomas clave si fueron omitidos.
-    Esta versión es más inteligente para evitar la doble contabilización de síntomas.
-    """
     if not entities:
         entities = {"alimentos": [], "sintomas": []}
     
     query_sanitized = sanitize_text(query)
     
-    # --- Reforzar Alimentos (Lógica existente, sin cambios) ---
     current_foods = entities.get("alimentos", [])
     current_foods_sanitized = {sanitize_text(f) for f in current_foods}
     for food_keyword in food_map.keys():
@@ -182,23 +176,17 @@ def reinforce_entities_with_keywords(entities, query, food_map, symptom_map):
             current_foods.append(food_keyword)
     entities["alimentos"] = list(set(current_foods))
 
-    # --- LÓGICA MEJORADA: Reforzar Síntomas (Evita redundancia) ---
     current_symptoms = entities.get("sintomas", [])
     if current_symptoms is None: current_symptoms = []
     
-    # Usamos una copia de la consulta para poder modificarla
     query_to_search_symptoms = query_sanitized
     
-    # Ordenamos las palabras clave de síntomas por longitud, de la más larga a la más corta
-    # Esto asegura que "dolor de cabeza" se procese antes que "dolor"
     sorted_symptom_keywords = sorted(symptom_map.keys(), key=len, reverse=True)
 
     for symptom_keyword in sorted_symptom_keywords:
-        # Si encontramos el síntoma más específico...
         if symptom_keyword in query_to_search_symptoms:
             logger.info(f"Red de seguridad (Síntoma): Añadiendo '{symptom_keyword}'.")
             current_symptoms.append(symptom_keyword)
-            # ...lo eliminamos de la cadena de búsqueda para que sus sub-partes no se vuelvan a encontrar.
             query_to_search_symptoms = query_to_search_symptoms.replace(symptom_keyword, "")
 
     entities["sintomas"] = list(set(current_symptoms))
@@ -209,22 +197,24 @@ def sanitize_text(text):
     if not text: return ""
     return re.sub(r'[.,;()]', '', text).lower().strip()
 
-def extract_and_infer_with_gemini(query, condiciones):
+def extract_and_infer_with_gemini(query):
     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 experto. Tu tarea es analizar la consulta de un usuario y extraer tres tipos de información:
-    1.  `alimentos`: Lista de alimentos consumidos.
-    2.  `sintomas`: Lista de síntomas descritos.
-    3.  `condicion_probable`: Tu mejor inferencia sobre cuál de las siguientes condiciones podría explicar la **conexión directa entre los alimentos y los síntomas mencionados**. Debes elegir la opción más lógica de la lista. Si ninguna encaja bien, puedes dejarlo en blanco.
-
-    LISTA DE CONDICIONES POSIBLES:
-    {condiciones_str}
-
-    Devuelve la respuesta ÚNICAMENTE en formato JSON estricto.
+    Eres un asistente de triaje clínico experto. Tu única tarea es analizar la consulta de un usuario y extraer dos tipos de información:
+    1.  `alimentos`: Una lista exhaustiva de todos los alimentos, bebidas o ingredientes consumidos mencionados. Incluye términos generales y específicos.
+    2.  `sintomas`: Una lista exhaustiva de todos los síntomas, sensaciones o signos clínicos descritos. Incluye términos médicos si se usan.
     
-    Ejemplo: si el usuario dice "vino tinto y dolor de cabeza", la condición probable es "Intolerancia a la Quercetina." o "Migraña.", no "Intolerancia a la Lactosa.".
-
+    Tu objetivo es la extracción precisa. No infieras, no adivines, no añadas información que no esté en el texto.
+    Devuelve la respuesta ÚNICamente en formato JSON estricto.
+    
+    Ejemplo de Consulta: "Después de comer pizza con queso y tomar vino tinto, tuve un fuerte dolor de cabeza y algo de hinchazón."
+    Ejemplo de Respuesta JSON:
+    {{
+        "alimentos": ["pizza", "queso", "vino tinto"],
+        "sintomas": ["dolor de cabeza", "hinchazón"]
+    }}
+
+    Ahora, procesa la siguiente consulta:
     Consulta: "{query}"
     """
     try:
@@ -236,7 +226,7 @@ def extract_and_infer_with_gemini(query, condiciones):
             json_text = re.search(r'\{.*\}', response.text, re.DOTALL).group(0)
         return json.loads(json_text)
     except Exception as e:
-        logger.error(f"Error en la extracción/inferencia con Gemini: {e}")
+        logger.error(f"Error en la extracción con Gemini: {e}")
         st.error(f"Hubo un problema al interpretar tu consulta con la IA.")
         return None
         
@@ -244,60 +234,57 @@ def find_best_matches_hybrid(entities, data):
     if not entities or not data: return []
     user_symptoms = set(sanitize_text(s) for s in entities.get("sintomas", []))
     user_foods = set(sanitize_text(f) for f in entities.get("alimentos", []))
-    inferred_condition_raw = sanitize_text(entities.get("condicion_probable", ""))
+    
     candidate_terms = set(user_foods)
     for food in user_foods:
         food_sanitized = sanitize_text(food)
         if food_sanitized in FOOD_TO_COMPOUND_MAP:
             candidate_terms.update(c.lower() for c in FOOD_TO_COMPOUND_MAP[food_sanitized])
-        if food_sanitized in ["vino", "vino tinto", "vino rojo"]:
-            candidate_terms.update(["histamina", "tiramina", "sulfitos"])
+
     results = []
     for entry in data:
         entry_compounds_text = sanitize_text(entry.get("compuesto_alimento", ""))
+        
         food_match = any(term in entry_compounds_text for term in candidate_terms)
+        
         if not food_match:
             continue
-        score_details = {'condition': 0, 'food': 15, 'symptoms': 0}
-        if inferred_condition_raw:
-            entry_condition_sanitized = sanitize_text(entry.get("condicion_asociada", ""))
-            is_match = (entry_condition_sanitized == inferred_condition_raw)
-            if not is_match and entry_condition_sanitized in CONDITION_SYNONYMS:
-                if inferred_condition_raw in [sanitize_text(s) for s in CONDITION_SYNONYMS.get(entry_condition_sanitized, [])]:
-                    is_match = True
-            if is_match:
-                score_details['condition'] = 100
+            
+        score_details = {'food': 20, 'symptoms': 0}
+        
         entry_symptoms_keys = set(sanitize_text(s) for s in entry.get("sintomas_clave", []))
         symptom_score = 0
         matched_symptoms = []
         for user_symptom in user_symptoms:
             for key in entry_symptoms_keys:
                 if key in user_symptom or user_symptom in key:
-                    symptom_score += 10
+                    symptom_score += 30 
                     matched_symptoms.append(key)
-                    break 
+                    break
+                    
         score_details['symptoms'] = symptom_score
-        score_details['total'] = score_details['condition'] + score_details['food'] + score_details['symptoms']
-        results.append({
-            'entry': entry, 
-            'score': score_details, 
-            'matched_symptoms': list(set(matched_symptoms))
-        })
+        score_details['total'] = score_details['food'] + score_details['symptoms']
+        
+        # Solo añadir si hay alguna coincidencia de síntomas
+        if score_details['symptoms'] > 0:
+            results.append({
+                'entry': entry, 
+                'score': score_details, 
+                'matched_symptoms': list(set(matched_symptoms))
+            })
+
     if not results: return []
     sorted_results = sorted(results, key=lambda x: x['score']['total'], reverse=True)
     return sorted_results
 
-# --- REEMPLAZA ESTA FUNCIÓN COMPLETA ---
 
 def generate_detailed_analysis(query, match):
     if not model: return "Error: El modelo de IA no está disponible."
     
-    # Comprobación de seguridad: si 'match' es inválido, no podemos continuar.
     if not match or not isinstance(match, dict):
         logger.error("Se intentó generar un análisis detallado con datos de coincidencia inválidos.")
         return "No se pudo generar el análisis detallado debido a un error interno (datos de coincidencia inválidos)."
 
-    # Preparamos una lista de síntomas clave desde nuestra base de datos para enriquecer el prompt
     sintomas_clave_texto = ", ".join(match.get("sintomas_clave", ["No especificados"]))
 
     prompt_parts = [
@@ -437,7 +424,6 @@ with st.form(key="search_form"):
 
 
 if st.session_state.start_analysis:
-    # Inmediatamente bajamos la bandera para evitar ejecuciones repetidas.
     st.session_state.start_analysis = False
     
     query_to_analyze = st.session_state.query
@@ -451,13 +437,12 @@ if st.session_state.start_analysis:
         st.error("La base de datos de alimentos no está disponible.")
     else:
         with st.spinner("🧠 Interpretando tu caso y buscando pistas con IA..."):
-            entities = extract_and_infer_with_gemini(query_to_analyze, lista_condiciones)
+            entities = extract_and_infer_with_gemini(query_to_analyze)
             entities = reinforce_entities_with_keywords(entities, query_to_analyze, FOOD_TO_COMPOUND_MAP, SYMPTOM_KEYWORD_MAP)
             st.session_state.entities = entities
         
         if entities and (entities.get("alimentos") or entities.get("sintomas")):
             info_str = f"IA identificó - Alimentos: {', '.join(entities.get('alimentos',[])) or 'Ninguno'}, 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)
@@ -466,12 +451,11 @@ if st.session_state.start_analysis:
             st.error("No se pudieron identificar alimentos o síntomas claros en tu descripción.")
             st.session_state.search_results = []
 
-# La sección de mostrar resultados permanece igual, se ejecuta si hay resultados en el estado.
 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}'.")
+        st.warning(f"No se encontraron coincidencias claras para tu caso: '{st.session_state.user_query}'. Prueba a ser más específico con los síntomas.")
     else:
         col1, col2 = st.columns([3,1])
         with col1:
@@ -495,11 +479,10 @@ if st.session_state.search_results is not None:
             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_match_data['score']['condition']}")
-                score_col2.metric("Puntos por Alimento", f"{best_match_data['score']['food']}")
-                score_col3.metric("Puntos por Síntomas", f"{best_match_data['score']['symptoms']}")
-                score_col4.metric("PUNTUACIÓN TOTAL", f"{best_match_data['score']['total']}", delta="Máxima coincidencia")
+                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")
             with col2:
                 st.write("")
                 if foodb_index: