Update app.py

app.py

@@ -1,6 +1,5 @@
-# ====================    Buscador de Intolerancias Alimentarias Basado en Síntomas  =====================================
-# Adaptado por la IA para un nuevo objetivo de análisis de casos clínicos.
-# Idea original y estructura de JAIRO ALEXANDER ERASO MD y DIANA MILENA SOLER MARTINEZ Psc.
+# ====================    Buscador de Intolerancias Alimentarias (Versión Híbrida)  =====================================
+# Implementa un motor de búsqueda híbrido que combina la extracción de entidades y la inferencia de la IA.
 
 import streamlit as st
 import google.generativeai as genai
@@ -12,7 +11,7 @@ import re
 
 st.set_page_config(
     page_title="Asistente de Bienestar Digestivo",
-    page_icon="🍎", # El ícono para la pestaña del navegador
+    page_icon="🍎",
     layout="wide"
 )
 
@@ -22,11 +21,9 @@ logger = logging.getLogger("food_intolerance_app")
 
 # --- CONFIGURACIÓN DE GEMINI ---
 try:
-    # Para Streamlit Community Cloud, usa st.secrets
     if 'GEMINI_API_KEY' in st.secrets:
         GEMINI_API_KEY = st.secrets['GEMINI_API_KEY']
     else:
-        # Para desarrollo local, usa variables de entorno
         GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 
     if not GEMINI_API_KEY:
@@ -56,59 +53,72 @@ model = get_gemini_model()
 
 @st.cache_data
 def load_data():
-    """Carga la base de datos de alimentos e intolerancias."""
+    """Carga la base de datos enriquecida y extrae la lista de condiciones."""
     try:
-        # Asegúrate de que el archivo se llame 'alimentos.json' y esté en una carpeta 'DATOS'
-        path_alimentos = os.path.join('DATOS', 'alimentos.json') 
+        path_alimentos = os.path.join('DATOS', 'alimentos_enriquecido.json') 
 
         with open(path_alimentos, 'r', encoding='utf-8') as f:
             data_alimentos = json.load(f)
+        
+        # Extraer una lista única de todas las condiciones posibles para guiar a la IA
+        lista_condiciones = sorted(list(set(item['condicion_asociada'] for item in data_alimentos)))
 
-        logger.info(f"✅ Base de datos de alimentos cargada con {len(data_alimentos)} registros.")
-        return data_alimentos
+        logger.info(f"✅ Base de datos enriquecida cargada con {len(data_alimentos)} registros.")
+        return data_alimentos, lista_condiciones
 
     except FileNotFoundError:
-        st.error("❌ Error: No se encontró el archivo 'alimentos.json' en la carpeta 'DATOS'.")
-        return None
+        st.error("❌ Error: No se encontró el archivo 'alimentos_enriquecido.json'. Asegúrate de haber ejecutado el script de enriquecimiento.")
+        return None, None
     except json.JSONDecodeError:
-        st.error("❌ Error: El archivo 'alimentos.json' tiene un formato incorrecto.")
-        return None
+        st.error("❌ Error: El archivo 'alimentos_enriquecido.json' tiene un formato incorrecto.")
+        return None, None
 
-alimentos_data = load_data()
+alimentos_data, lista_condiciones = load_data()
 
-# Mapeo de alimentos comunes a los compuestos/intolerancias del JSON.
-# Este diccionario es crucial y debe expandirse.
+# Mapeo expandido de alimentos a compuestos.
 FOOD_TO_COMPOUND_MAP = {
-    "pan": ["Gluten"], "trigo": ["Gluten"], "cebada": ["Gluten"], "centeno": ["Gluten"], "pasta": ["Gluten"], "galletas": ["Gluten"],
-    "leche": ["Caseína", "Lactosa"], "queso": ["Caseína", "Lactosa"], "yogur": ["Caseína", "Lactosa"], "mantequilla": ["Caseína", "Lactosa"],
-    "manzana": ["Salicilatos"], "almendras": ["Salicilatos"], "uvas": ["Salicilatos"],
-    "azucar": ["Azúcar"], "dulces": ["Azúcar"], "refrescos": ["Azúcar"], "gaseosas": ["Azúcar"]
+    "pan": ["gluten"], "trigo": ["gluten"], "harina de trigo": ["gluten"], "cebada": ["gluten"], "centeno": ["gluten"], "pasta": ["gluten"], "galletas": ["gluten"], "avena": ["gluten"],
+    "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"],
+    "manzana": ["salicilatos", "fructosa"], "almendras": ["salicilatos"], "uvas": ["salicilatos"], "vino tinto": ["histamina", "tiramina", "sulfitos"], "vino rojo": ["histamina", "tiramina", "sulfitos"],
+    "azucar": ["azúcar", "fructosa"], "dulces": ["azúcar"], "refrescos": ["azúcar", "fructosa"], "gaseosas": ["azúcar", "fructosa"],
+    "embutidos": ["histamina", "tiramina", "nitritos"], "carne": ["alfa-gal", "proteínas"]
 }
 
-# --- LÓGICA DE BÚSQUEDA Y ANÁLISIS ---
+# --- LÓGICA DE BÚSQUEDA Y ANÁLISIS (ENFOQUE HÍBRIDO) ---
 
-def extract_entities_with_gemini(query):
-    """Usa Gemini para extraer alimentos y síntomas de la consulta del usuario."""
+def extract_and_infer_with_gemini(query, condiciones):
+    """Usa Gemini para extraer alimentos, síntomas E INFERIR una condición probable."""
     if not model: return None
-    system_prompt = f"""
-    Eres un experto en procesar textos clínicos. Tu tarea es analizar la consulta de un usuario y extraer dos tipos de entidades: alimentos consumidos y síntomas experimentados.
-    Debes devolver la respuesta ÚNICAMENTE en formato JSON, con las claves "alimentos" y "sintomas".
-    Normaliza los síntomas a términos médicos o comunes. Por ejemplo, "se me hincha el estómago" debería ser "hinchazón abdominal". "Mente nublada" debería ser "niebla mental".
     
+    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`: Una lista de los alimentos que el usuario menciona haber consumido.
+    2.  `sintomas`: Una lista de los síntomas que el usuario describe, normalizados a un término común (ej: "hinchazón abdominal", "dolor de cabeza").
+    3.  `condicion_probable`: Tu mejor inferencia sobre cuál de las siguientes condiciones podría explicar los síntomas del usuario. Elige solo una de la lista.
+
+    LISTA DE CONDICIONES POSIBLES:
+    {condiciones_str}
+
+    Devuelve la respuesta ÚNICAMENTE en formato JSON. Si no puedes inferir una condición, deja el campo como un string vacío "".
+
     Ejemplo 1:
-    Consulta: "Cuando como mucho pan se me hincha el estomago, me da niebla mental y siento fatiga."
+    Consulta: "Cuando como mucho pan con harina de trigo se me hincha el estomago y siento fatiga."
     Respuesta:
     {{
-      "alimentos": ["pan"],
-      "sintomas": ["hinchazón abdominal", "niebla mental", "fatiga"]
+      "alimentos": ["pan", "harina de trigo"],
+      "sintomas": ["hinchazón abdominal", "fatiga"],
+      "condicion_probable": "Enfermedad Celíaca (Clásica)."
     }}
     
     Ejemplo 2:
-    Consulta: "Después de tomar leche, mi hijo tiene diarrea y se queja de dolor de barriga."
+    Consulta: "me duele la cabeza cada vez que tomo vino rojo"
     Respuesta:
     {{
-      "alimentos": ["leche"],
-      "sintomas": ["diarrea", "dolor abdominal"]
+      "alimentos": ["vino rojo"],
+      "sintomas": ["dolor de cabeza"],
+      "condicion_probable": "Intolerancia a la Histamina (Histaminosis)."
     }}
 
     Ahora, analiza la siguiente consulta:
@@ -116,96 +126,88 @@ def extract_entities_with_gemini(query):
     """
     try:
         response = model.generate_content(system_prompt)
-        # Limpiar y parsear la respuesta JSON del texto que puede venir con Markdown
         json_text_match = re.search(r'```json\s*(\{.*?\})\s*```', response.text, re.DOTALL)
         if json_text_match:
             json_text = json_text_match.group(1)
-        else: # Si no encuentra el formato Markdown, busca un JSON simple
+        else:
             json_text = re.search(r'\{.*\}', response.text, re.DOTALL).group(0)
-            
         return json.loads(json_text)
     except Exception as e:
-        logger.error(f"Error extrayendo entidades con Gemini: {e}")
+        logger.error(f"Error en la extracción/inferencia con Gemini: {e}")
         st.error(f"Hubo un problema al interpretar tu consulta con la IA. Error: {e}")
         return None
 
-def find_best_matches(entities, data):
-    """Encuentra las mejores coincidencias en la base de datos basadas en las entidades extraídas."""
+def find_best_matches_hybrid(entities, data):
+    """Motor de búsqueda híbrido con puntuación ponderada."""
     if not entities or not data: return []
     
-    user_symptoms = set([s.lower() for s in entities.get("sintomas", [])])
-    user_foods = [f.lower() for f in entities.get("alimentos", [])]
-    
-    # Traducir alimentos a compuestos
+    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 = entities.get("condicion_probable", "").lower().strip()
+
     candidate_compounds = set()
     for food in user_foods:
         if food in FOOD_TO_COMPOUND_MAP:
-            candidate_compounds.update(FOOD_TO_COMPOUND_MAP[food])
+            candidate_compounds.update(c.lower() for c in FOOD_TO_COMPOUND_MAP[food])
 
     scores = {}
     for index, entry in enumerate(data):
         score = 0
-        entry_compound = entry.get("Compuesto / Alimento Intolerante", "").split('(')[0].strip().lower()
-        entry_symptoms = entry.get("Posibles Síntomas (Presentación Clínica Representativa)", "").lower()
-        
-        # Puntuar por coincidencia de compuesto
-        if entry_compound in candidate_compounds:
-            score += 10 # Puntuación alta por coincidencia directa
         
-        # Puntuar por coincidencia de síntomas
-        for symptom in user_symptoms:
-            if symptom in entry_symptoms:
-                score += 5
+        # Ponderación 1: Coincidencia de Condición (la más importante)
+        entry_condition = entry.get("condicion_asociada", "").lower().strip()
+        if inferred_condition and inferred_condition == entry_condition:
+            score += 15
+
+        # Ponderación 2: Coincidencia de Alimentos/Compuestos
+        entry_compounds_text = entry.get("compuesto_alimento", "").lower()
+        if any(food in entry_compounds_text for food in user_foods) or any(comp in entry_compounds_text for comp in candidate_compounds):
+            score += 8
+            
+        # Ponderación 3: Coincidencia de Síntomas
+        entry_symptoms_keys = set(s.lower().strip() for s in entry.get("sintomas_clave", []))
+        matching_symptoms = user_symptoms.intersection(entry_symptoms_keys)
+        score += len(matching_symptoms) * 4 # Cada síntoma coincidente suma
         
         if score > 0:
             scores[index] = score
             
-    # Ordenar por puntuación descendente
-    sorted_matches_indices = sorted(scores, key=scores.get, reverse=True)
-    
-    # Devolver los objetos completos de las mejores coincidencias
+    if not scores: return []
+
+    sorted_matches_indices = sorted(scores.keys(), key=scores.get, reverse=True)
     return [data[i] for i in sorted_matches_indices]
 
 def generate_detailed_analysis(query, match):
-    """Usa Gemini para generar una explicación detallada y amigable para el usuario."""
+    """Genera la explicación final para el usuario (sin cambios necesarios aquí)."""
+    # Esta función ya es robusta y no necesita cambios.
     if not model: return "Error: El modelo de IA no está disponible."
-    
     prompt = f"""
     Eres un asistente de IA experto en nutrición y bienestar, diseñado para ayudar a las personas a entender posibles intolerancias alimentarias. Tu tono debe ser claro, empático y educativo.
+    Un usuario ha descrito el siguiente caso: "{query}"
+    Basado en esto, nuestro sistema ha encontrado una posible coincidencia con:
+    - **Compuesto Intolerante:** {match.get("compuesto_alimento")}
+    - **Síntomas Comunes:** {match.get("sintomas_clinicos")}
+    - **Condición Asociada:** {match.get("condicion_asociada")}
+    - **Mecanismo Fisiológico:** {match.get("mecanismo_fisiologico")}
+    - **Recomendaciones Generales:** {match.get("recomendaciones_examenes")}
 
-    Un usuario ha descrito el siguiente caso:
-    "{query}"
-
-    Basado en este caso, nuestro sistema ha encontrado una posible coincidencia con la siguiente intolerancia:
-    - **Compuesto Intolerante:** {match.get("Compuesto / Alimento Intolerante")}
-    - **Síntomas Comunes:** {match.get("Posibles Síntomas (Presentación Clínica Representativa)")}
-    - **Enfermedades Asociadas:** {match.get("Enfermedades Asociadas")}
-    - **Mecanismo Fisiológico:** {match.get("Mecanismo de Acción / Fisiología Alterada")}
-    - **Recomendaciones Generales:** {match.get("Recomendaciones Médicas / Exámenes Confirmatorios")}
-
-    **Tu Tarea:**
-    Redacta una respuesta completa para el usuario. La respuesta debe estar estructurada en las siguientes secciones (usa los títulos en negrita y formato Markdown):
-
-    1.  **Posible Causa:** Comienza resumiendo por qué sus síntomas podrían estar relacionados con este compuesto, vinculando directamente su caso con la información proporcionada.
-    2.  **¿Qué podría estar pasando en tu cuerpo?:** Explica el "Mecanismo Fisiológico" en términos sencillos que cualquiera pueda entender.
-    3.  **Condiciones Relacionadas:** Menciona las "Enfermedades Asociadas", aclarando que son asociaciones y no un diagnóstico.
-    4.  **Pasos a Seguir y Recomendaciones:** Presenta las "Recomendaciones" como sugerencias generales, enfatizando la importancia de la supervisión profesional.
-    5.  **Descargo de Responsabilidad Médico:** Incluye OBLIGATORIAMENTE un párrafo final claro y visible que indique que esta es una herramienta informativa y NO un diagnóstico médico, y que debe consultar a un profesional de la salud.
-
-    Mantén un lenguaje accesible y evita el alarmismo. El objetivo es informar y guiar, no diagnosticar.
+    **Tu Tarea:** Redacta una respuesta completa y estructurada para el usuario usando Markdown:
+    1.  **Posible Causa:** Resume por qué sus síntomas podrían estar relacionados con esta condición.
+    2.  **¿Qué podría estar pasando en tu cuerpo?:** Explica el "Mecanismo Fisiológico" en términos sencillos.
+    3.  **Pasos a Seguir y Recomendaciones:** Presenta las "Recomendaciones" como sugerencias, enfatizando la supervisión profesional. Menciona otros alimentos a tener en cuenta del campo "compuesto_alimento".
+    4.  **Descargo de Responsabilidad Médico:** Incluye OBLIGATORIAMENTE un párrafo final claro y visible que indique que NO es un diagnóstico médico y que debe consultar a un profesional.
     """
     try:
         response = model.generate_content(prompt)
         return response.text
     except Exception as e:
         logger.error(f"Error generando análisis detallado con Gemini: {e}")
-        return "No se pudo generar el análisis detallado. Por favor, inténtalo de nuevo."
+        return "No se pudo generar el análisis detallado."
 
 # --- INTERFAZ DE USUARIO (UI) ---
 st.title("🍎 Asistente de Bienestar Digestivo")
 st.markdown("Explora la posible relación entre lo que comes y cómo te sientes.")
 
-# Manejo de estado
 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 = ""
 
@@ -221,20 +223,25 @@ if submitted:
     if not query:
         st.warning("Por favor, describe lo que sientes y lo que comiste.")
     elif alimentos_data is None:
-        st.error("La base de datos de alimentos no está disponible. No se puede continuar.")
+        st.error("La base de datos de alimentos no está disponible.")
     else:
         st.session_state.user_query = query
-        with st.spinner("🧠 Interpretando tu caso con IA..."):
-            entities = extract_entities_with_gemini(query)
+        with st.spinner("🧠 Interpretando tu caso y buscando pistas con IA..."):
+            entities = extract_and_infer_with_gemini(query, lista_condiciones)
         
         if entities and (entities.get("alimentos") or entities.get("sintomas")):
-            st.info(f"IA identificó - Alimentos: {', '.join(entities.get('alimentos',[])) or 'Ninguno'}, Síntomas: {', '.join(entities.get('sintomas',[])) or 'Ninguno'}")
-            with st.spinner("🔬 Buscando posibles causas en la base de conocimiento..."):
-                results = find_best_matches(entities, alimentos_data)
+            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 en la base de conocimiento..."):
+                results = find_best_matches_hybrid(entities, alimentos_data)
                 st.session_state.search_results = results
         else:
             st.error("No se pudieron identificar alimentos o síntomas claros en tu descripción. Intenta ser un poco más específico.")
-            st.session_state.search_results = [] # Resetear a lista vacía
+            st.session_state.search_results = []
 
 if st.session_state.search_results is not None:
     st.button("Realizar nueva consulta", on_click=clear_search_state)
@@ -244,21 +251,19 @@ if st.session_state.search_results is not None:
     if not results:
         st.warning(f"No se encontraron coincidencias claras en nuestra base de datos para tu caso: '{st.session_state.user_query}'.")
     else:
-        st.success(f"Hemos encontrado {len(results)} posible(s) causa(s) relacionada(s) con tu caso.")
+        st.success(f"Hemos encontrado {len(results)} posible(s) causa(s) relacionada(s) con tu caso. Aquí está el análisis de la más probable:")
         
-        # Tomar solo el mejor resultado para el análisis detallado
         best_match = results[0]
         
-        with st.expander(f"**Principal Coincidencia: {best_match.get('Compuesto / Alimento Intolerante')}**", expanded=True):
+        with st.expander(f"**Principal Coincidencia: {best_match.get('condicion_asociada')}**", expanded=True):
             with st.spinner("✍️ Generando un análisis detallado con IA..."):
                 detailed_analysis = generate_detailed_analysis(st.session_state.user_query, best_match)
                 st.markdown(detailed_analysis)
 
-        # Opcional: Mostrar otros resultados menos probables
         if len(results) > 1:
             with st.expander("Otras posibles coincidencias (menos probables)"):
                 for result in results[1:]:
-                    st.subheader(f"{result.get('Compuesto / Alimento Intolerante')}")
-                    st.write(f"**Síntomas asociados:** {result.get('Posibles Síntomas (Presentación Clínica Representativa)')}")
-                    st.write(f"**Mecanismo:** {result.get('Mecanismo de Acción / Fisiología Alterada')}")
+                    st.subheader(f"{result.get('condicion_asociada')}")
+                    st.write(f"**Compuestos/Alimentos:** {result.get('compuesto_alimento')}")
+                    st.write(f"**Síntomas Clínicos:** {result.get('sintomas_clinicos')}")
                     st.markdown("---")