Update app.py

app.py

@@ -1,9 +1,3 @@
-# ==============================================================================
-# EL DETECTIVE DE ALIMENTOS - EDICIÓN HÍBRIDA DE ALTA DISPONIBILIDAD
-# Desarrollado por: Jairo Alexander & Diana Milena Soler Martinez
-# Motor: Gemini 2.5 Flash Lite + FooDB.ca Graph + Fast-Path Local Engine
-# ==============================================================================
-
 import streamlit as st
 from google import genai
 from google.genai import types
@@ -13,17 +7,14 @@ import logging
 import re
 import pandas as pd
 import altair as alt
-from datetime import datetime
 from io import BytesIO
 import docx
 import difflib
 
-# --- CONFIGURACIÓN DE PÁGINA Y LOGGING ---
 st.set_page_config(page_title="El Detective de Alimentos", page_icon="🍎", layout="wide")
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger("food_detective_app")
 
-# --- TEXTO ESTÁTICO DE SEGURIDAD Y BANDERAS ROJAS ---
 TEXTO_BANDERAS_ROJAS = """
 \n### **IMPORTANTE: Descargo de Responsabilidad y Banderas Rojas**
 Este análisis es una herramienta informativa de IA y **NO es un diagnóstico médico.**
@@ -38,30 +29,33 @@ Este análisis es una herramienta informativa de IA y **NO es un diagnóstico m
 **Si tus síntomas son severos, busca ayuda médica urgente.**
 """
 
-# --- CONFIGURACIÓN DE CLIENTE GEMINI SIN CACHÉ PARA EVITAR DEAD SOCKETS ---
 def get_gemini_client():
+    api_key = None
     try:
         if 'APIkeydetective' in st.secrets:
-            APIkeydetective = st.secrets['APIkeydetective']
-        else:
-            APIkeydetective = os.getenv("APIkeydetective")
-            
-        if not APIkeydetective:
-            return None
-        
+            api_key = st.secrets['APIkeydetective']
+    except Exception:
+        api_key = None
+
+    if not api_key:
+        api_key = os.getenv("APIkeydetective")
+
+    if not api_key:
+        return None
+
+    try:
         return genai.Client(
-            api_key=APIkeydetective,
-            http_options=types.HttpOptions(timeout=5000)
+            api_key=api_key,
+            http_options=types.HttpOptions(timeout=30000)
         )
     except Exception as e:
         logger.warning(f"No se pudo instanciar Gemini Client: {e}")
         return None
 
-# --- CARGA ULTRA-RÁPIDA DE DATOS Y FOODB (CERO COPIA EN MEMORIA) ---
 @st.cache_resource
 def load_data():
     try:
-        path_alimentos = os.path.join('DATOS', 'alimentos_enriquecido.json') 
+        path_alimentos = os.path.join('DATOS', 'alimentos_enriquecido.json')
         path_foodb_index = os.path.join('DATOS', 'foodb_index_smart.json')
         data_alimentos = []
         if os.path.exists(path_alimentos):
@@ -86,19 +80,13 @@ def get_foodb_lower_map(_foodb_index):
 
 foodb_lower_map = get_foodb_lower_map(foodb_index)
 
-# --- CACHÉ GLOBAL DE APRENDIZAJE EN RAM ---
 @st.cache_resource
 def get_global_learned_cache():
     return {}
 
 global_learned_cache = get_global_learned_cache()
 
-# ==============================================================================
-# DICCIONARIOS MASTER BIOMÉDICOS Y FOODB.CA
-# ==============================================================================
-
 FOOD_TO_COMPOUND_MAP = {
-    # CEREALES Y GRANOS
     "trigo": ["gluten", "fodmaps", "lectinas", "fitatos"],
     "pan": ["gluten", "fodmaps", "lectinas"],
     "pasta": ["gluten", "fodmaps"],
@@ -112,7 +100,6 @@ FOOD_TO_COMPOUND_MAP = {
     "alforfón": ["oxalatos", "fagopirina"],
     "arroz frito": ["lectinas", "gluten", "soja", "histamina", "fodmaps", "glutamato"],
 
-    # LÁCTEOS
     "leche": ["caseína", "lactosa", "fodmaps"],
     "queso": ["tiramina", "histamina", "caseína", "lactosa"],
     "queso fresco": ["caseína", "lactosa"],
@@ -123,7 +110,6 @@ FOOD_TO_COMPOUND_MAP = {
     "crema de leche": ["caseína", "lactosa"],
     "helado": ["lactosa", "caseína", "azúcar refinado"],
 
-    # FRUTAS
     "chontaduro": ["fenoles", "fructosa", "grasas saturadas", "tiramina", "salicilatos"],
     "jugo de chontaduro": ["fenoles", "fructosa", "grasas saturadas", "tiramina", "salicilatos"],
     "chotanduro": ["fenoles", "fructosa", "grasas saturadas", "tiramina", "salicilatos"],
@@ -149,7 +135,6 @@ FOOD_TO_COMPOUND_MAP = {
     "higo": ["histamina", "fructosa", "salicilatos"],
     "cholado": ["fructosa", "lactosa", "histamina", "azúcar refinado", "salicilatos", "fenoles"],
 
-    # VERDURAS Y TUBÉRCULOS
     "tomate": ["histamina", "solanina", "salicilatos", "glutamato"],
     "salsa de tomate": ["histamina", "solanina", "salicilatos", "glutamato"],
     "patata": ["solanina", "oxalatos", "lectinas"],
@@ -169,11 +154,9 @@ FOOD_TO_COMPOUND_MAP = {
     "calabaza": ["salicilatos", "fodmaps"],
     "zanahoria": ["salicilatos"],
 
-    # FERMENTADOS
     "kimchi": ["histamina", "tiramina", "sulfitos", "fodmaps"],
     "kombucha": ["histamina", "alcohol", "fructosa"],
 
-    # LEGUMBRES
     "frijol": ["lectinas", "fitatos", "fodmaps", "saponinas"],
     "frijoles": ["lectinas", "fitatos", "fodmaps", "saponinas"],
     "lentejas": ["lectinas", "fitatos", "fodmaps"],
@@ -182,7 +165,6 @@ FOOD_TO_COMPOUND_MAP = {
     "tofu": ["soja", "lectinas", "fitatos"],
     "arvejas": ["fodmaps", "lectinas"],
 
-    # FRUTOS SECOS Y SEMILLAS
     "almendras": ["oxalatos", "salicilatos", "fitatos", "histamina"],
     "leche de almendras": ["oxalatos", "salicilatos"],
     "nueces": ["histamina", "oxalatos", "salicilatos", "taninos"],
@@ -194,7 +176,6 @@ FOOD_TO_COMPOUND_MAP = {
     "semillas de chía": ["fitatos", "oxalatos"],
     "ajonjolí": ["fitatos", "oxalatos"],
 
-    # BEBIDAS Y ESTIMULANTES
     "café": ["cafeína", "salicilatos", "oxalatos"],
     "té": ["cafeína", "taninos", "oxalatos", "salicilatos"],
     "té negro": ["cafeína", "taninos", "oxalatos", "salicilatos"],
@@ -218,7 +199,6 @@ FOOD_TO_COMPOUND_MAP = {
     "carne roja": ["purinas"],
     "pollo": ["purinas", "histamina"],
 
-    # CONDIMENTOS
     "pimienta": ["capsaicina", "salicilatos"],
     "chile": ["capsaicina", "salicilatos", "solanina"],
     "ají": ["capsaicina", "salicilatos", "solanina"],
@@ -439,12 +419,9 @@ MASTER_SYMPTOM_MAP = {
     }
 }
 
-# ==============================================================================
-# FUNCIONES DE SEGURO LÓGICO, BÚSQUEDA FLEXIBLE Y EXTRACCIÓN
-# ==============================================================================
-
 def sanitize_text(text):
-    if not text: return ""
+    if not text:
+        return ""
     return re.sub(r'[.,;()¿?¡!:"\'\-]', ' ', text).lower().strip()
 
 STOPWORDS_ES = {
@@ -464,37 +441,34 @@ def extract_keywords(text):
     words = re.findall(r'\b\w+\b', sanitize_text(text))
     return set(w for w in words if w not in STOPWORDS_ES and len(w) > 2)
 
-# --- BUSCADOR UNIVERSAL CON CORRECTOR DIFUSO DE ERRATAS (difflib) ---
 def get_compounds_for_food(food_name, food_map):
-    if not food_name: return []
+    if not food_name:
+        return []
+
     food_clean = food_name.lower().strip()
-    
-    # 1. Coincidencia exacta
+
     if food_clean in food_map:
         return food_map[food_clean]
-        
-    # 2. Limpieza de Plurales
+
     for suffix in ["es", "s"]:
         if food_clean.endswith(suffix):
             norm = food_clean[:-len(suffix)]
             if norm in food_map:
                 return food_map[norm]
 
-    # 3. CORRECTOR DIFUSO DE ERRATAS (Corrige "vino tino" -> "vino tinto", "chotanduro" -> "chontaduro")
     fuzzy_matches = difflib.get_close_matches(food_clean, list(food_map.keys()), n=1, cutoff=0.6)
     if fuzzy_matches:
         logger.info(f"💡 Errata corregida automáticamente: '{food_clean}' -> '{fuzzy_matches[0]}'")
         return food_map[fuzzy_matches[0]]
 
-    # 4. Búsqueda por subcadena en el diccionario
     matched_compounds = set()
     for key, compounds in food_map.items():
         if key in food_clean or food_clean in key:
             matched_compounds.update(compounds)
+
     if matched_compounds:
         return list(matched_compounds)
 
-    # 5. Corrección difusa por palabras individuales dentro de frases largas
     inferred = set()
     words = food_clean.split()
     for word in words:
@@ -506,18 +480,23 @@ def get_compounds_for_food(food_name, food_map):
     if inferred:
         return list(inferred)
 
-    # 6. INFERENCIA UNIVERSAL DE CLASES PARA ALIMENTOS NO REGISTRADOS
-    if any(w in food_clean for w in ["vino", "cerveza", "licor", "trago", "bebida"]):
-        return ["histamina", "tiramina", "sulfitos", "alcohol", "taninos"]
-    elif any(w in food_clean for w in ["carne", "cerdo", "res", "pollo", "pavo", "cordero"]):
-        return ["histamina", "purinas", "proteínas"]
+    if any(w in food_clean for w in ["carne", "cerdo", "res", "pollo", "pavo", "cordero", "pato", "chicharrón", "tocino"]):
+        inferred.update(["histamina", "purinas", "proteínas"])
+    elif any(w in food_clean for w in ["pescado", "atún", "marisco", "camarón", "sardina", "langostino", "pulpo"]):
+        inferred.update(["histamina", "purinas", "albúmina"])
     elif any(w in food_clean for w in ["jugo", "zumo", "batido", "fruta", "licuado"]):
-        return ["fructosa", "salicilatos", "histamina", "fenoles"]
-    elif any(w in food_clean for w in ["queso", "leche", "crema", "yogur"]):
-        return ["caseína", "lactosa", "histamina", "tiramina"]
+        inferred.update(["fructosa", "salicilatos", "histamina", "fenoles"])
+    elif any(w in food_clean for w in ["queso", "leche", "crema", "yogur", "mantequilla"]):
+        inferred.update(["caseína", "lactosa", "histamina", "tiramina"])
+    elif any(w in food_clean for w in ["pan", "galleta", "pasta", "harina", "bizcocho", "tortilla"]):
+        inferred.update(["gluten", "fodmaps"])
+    elif any(w in food_clean for w in ["frijol", "lenteja", "garbanzo", "legumbre", "soja"]):
+        inferred.update(["lectinas", "fitatos", "fodmaps", "saponinas"])
+    elif any(w in food_clean for w in ["salsa", "sazonador", "aderezo", "caldo", "adobo"]):
+        inferred.update(["glutamato", "histamina", "sulfitos"])
+
+    return list(inferred)
 
-    return []
-    
 def validar_seguro_logico(entry, user_foods, user_query, food_compound_map):
     if not user_foods:
         return True
@@ -525,7 +504,6 @@ def validar_seguro_logico(entry, user_foods, user_query, food_compound_map):
     user_query_clean = user_query.lower() if user_query else ""
     texto_condicion = (entry.get("condicion_asociada", "") + " " + entry.get("compuesto_alimento", "")).lower()
 
-    # 1. EVALUAR SEGUROS POR CATEGORÍA DE CONDICIONES MÉDICAS
     for category, rules in MEDICAL_CONDITION_SAFEGUARDS.items():
         if any(trig in texto_condicion for trig in rules["condition_triggers"]):
             tiene_contexto = any(req_kw in user_query_clean for req_kw in rules["required_user_keywords"])
@@ -533,7 +511,6 @@ def validar_seguro_logico(entry, user_foods, user_query, food_compound_map):
                 logger.info(f"🚩 SEGURO LÓGICO ACTIVADO [{category.upper()}]: Se descartó '{entry.get('condicion_asociada')}' por falta de síntomas/contexto clínico.")
                 return False
 
-    # 2. EVALUAR SEGUROS BIOQUÍMICOS POR COMPUESTOS ESTRICTOS
     user_compounds = set()
     for food in user_foods:
         comps = get_compounds_for_food(food, food_compound_map)
@@ -554,8 +531,9 @@ def validar_seguro_logico(entry, user_foods, user_query, food_compound_map):
 
 def extract_entities_with_gemini(query):
     gemini_client = get_gemini_client()
-    if not gemini_client: return {"alimentos": [], "sintomas": []}
-    
+    if not gemini_client:
+        return {"alimentos": [], "sintomas": []}
+
     system_prompt = f"""
     Rol: Extractor Médico JSON experto en nutrición y síntomas.
     Tarea: Analiza el texto del usuario y extrae un JSON estricto con dos claves:
@@ -571,21 +549,25 @@ def extract_entities_with_gemini(query):
             contents=system_prompt
         )
         text = response.text
-        if "```json" in text: text = text.split("```json")[1].split("```")[0]
-        elif "```" in text: text = text.split("```")[1].split("```")[0]
+        if "```json" in text:
+            text = text.split("```json")[1].split("```")[0]
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0]
         return json.loads(text)
     except Exception as e:
         logger.warning(f"Extracción por IA no disponible ({e}). Se usará extracción directa por palabras clave.")
         return {"alimentos": [], "sintomas": []}
 
 def reinforce_entities_with_keywords(entities, query, food_map, master_symptom_map):
-    if not entities: entities = {"alimentos": [], "sintomas": []}
+    if not entities:
+        entities = {"alimentos": [], "sintomas": []}
     query_sanitized = sanitize_text(query)
     current_foods = set(entities.get("alimentos", []))
     for food_keyword in food_map.keys():
-        if food_keyword in query_sanitized: current_foods.add(food_keyword)
+        if food_keyword in query_sanitized:
+            current_foods.add(food_keyword)
     entities["alimentos"] = list(current_foods)
-    
+
     current_symptoms = set(entities.get("sintomas", []))
     for main_symptom, details in master_symptom_map.items():
         for phrase in details.get("frases_es", []):
@@ -596,14 +578,15 @@ def reinforce_entities_with_keywords(entities, query, food_map, master_symptom_m
     return entities
 
 def translate_symptoms_local(symptoms_list, master_symptom_map):
-    if not symptoms_list: return []
+    if not symptoms_list:
+        return []
     translated_symptoms = set()
     inverse_index = {}
     for clinical_term, details in master_symptom_map.items():
-        inverse_index[clinical_term.lower()] = clinical_term 
+        inverse_index[clinical_term.lower()] = clinical_term
         for phrase in details.get("frases_es", []):
             inverse_index[phrase.lower()] = clinical_term
-    
+
     for symptom in symptoms_list:
         symptom_clean = symptom.lower().strip()
         if symptom_clean in inverse_index:
@@ -613,11 +596,13 @@ def translate_symptoms_local(symptoms_list, master_symptom_map):
     return list(translated_symptoms)
 
 def find_best_matches_hybrid(entities, data, user_query="", food_compound_map=None):
-    if not entities or not data: return []
+    if not entities or not data:
+        return []
     user_symptoms_list = entities.get("sintomas", [])
     user_foods_list = entities.get("alimentos", [])
 
-    if not user_foods_list: return []
+    if not user_foods_list:
+        return []
 
     expanded_foods = list(user_foods_list)
     if food_compound_map:
@@ -657,130 +642,7 @@ def build_local_hypothesis(entities, food_compound_map, neuro_map):
         return None
 
     symptom_text = " ".join(user_symptoms).lower()
-    headache_keywords = ["dolor de cabeza", "migraña", "cefalea", "jaqueca"]
-    insomnia_keywords = ["insomnio", "no puedo dormir", "sueño", "desvelado"]
-    
-    es_dolor_cabeza = any(k in symptom_text for k in headache_keywords)
-    es_insomnio = any(k in symptom_text for k in insomnia_keywords)
-
-    candidates = []
-    for food in user_foods:
-        comps = get_compounds_for_food(food, food_compound_map)
-        for compound in comps:
-            info = neuro_map.get(compound)
-            if not info:
-                continue
-            candidates.append({"alimento": food, "compuesto": compound, "efecto": info['efecto_neuropsicologico']})
-
-    if not candidates:
-        return None
-
-    compuestos_unicos = sorted(set(c['compuesto'] for c in candidates))
-    alimentos_unicos = sorted(set(c['alimento'] for c in candidates))
-    compuestos_str = ", ".join(compuestos_unicos)
-    alimentos_str = ", ".join(alimentos_unicos)
-
-    if es_dolor_cabeza:
-        condicion = f"Cefalea o migraña por aminas vasoactivas / compuestos ({compuestos_str}) en {alimentos_str}"
-    elif es_insomnio:
-        condicion = f"Alteración del sueño / insomnio por respuesta a {compuestos_str} presente en {alimentos_str}"
-    else:
-        condicion = f"Sensibilidad o intolerancia a {compuestos_str} presente en {alimentos_str}"
-
-    mecanismo = " | ".join(sorted(set(c['efecto'] for c in candidates)))
-
-    return {
-        "condicion_asociada": condicion,
-        "mecanismo_fisiologico": mecanismo,
-        "compuesto_alimento": f"{alimentos_str} ({compuestos_str})",
-        "sintomas_clave": user_symptoms,
-        "es_hipotesis_local": True
-    }
-
-
-def get_compounds_for_food(food_name, food_map):
-    """
-    Buscador e Inferidor Universal de Compuestos (Definitivo):
-    1. Coincidencia exacta.
-    2. Normalización de plurales.
-    3. Corrector difuso de errores de tipeo (difflib).
-    4. Búsqueda por subcadena en el diccionario.
-    5. Inferencia universal por familia biomédica para alimentos no registrados.
-    """
-    if not food_name: 
-        return []
-        
-    food_clean = food_name.lower().strip()
-    
-    # 1. Coincidencia exacta
-    if food_clean in food_map:
-        return food_map[food_clean]
-        
-    # 2. Normalización de Plurales
-    for suffix in ["es", "s"]:
-        if food_clean.endswith(suffix):
-            norm = food_clean[:-len(suffix)]
-            if norm in food_map:
-                return food_map[norm]
-
-    # 3. Corrección difusa de erratas de tipeo ("vino tino" -> "vino tinto", "chotanduro" -> "chontaduro")
-    fuzzy_matches = difflib.get_close_matches(food_clean, list(food_map.keys()), n=1, cutoff=0.6)
-    if fuzzy_matches:
-        return food_map[fuzzy_matches[0]]
-
-    # 4. Búsqueda por subcadena dentro del diccionario
-    matched_compounds = set()
-    for key, compounds in food_map.items():
-        if key in food_clean or food_clean in key:
-            matched_compounds.update(compounds)
-            
-    if matched_compounds:
-        return list(matched_compounds)
-
-    # 5. Inferencia difusa por palabras individuales en nombres compuestos
-    inferred = set()
-    words = food_clean.split()
-    for word in words:
-        if len(word) > 3:
-            sub_fuzzy = difflib.get_close_matches(word, list(food_map.keys()), n=1, cutoff=0.7)
-            if sub_fuzzy:
-                inferred.update(food_map[sub_fuzzy[0]])
-
-    if inferred:
-        return list(inferred)
-
-    # 6. INFERENCIA UNIVERSAL POR FAMILIA BIOLÓGICA (Alimentos raros o no registrados)
-    if any(w in food_clean for w in ["carne", "cerdo", "res", "pollo", "pavo", "cordero", "pato", "chicharrón", "tocino"]):
-        inferred.update(["histamina", "purinas", "proteínas"])
-    elif any(w in food_clean for w in ["pescado", "atún", "marisco", "camarón", "sardina", "langostino", "pulpo"]):
-        inferred.update(["histamina", "purinas", "albúmina"])
-    elif any(w in food_clean for w in ["jugo", "zumo", "batido", "fruta", "licuado"]):
-        inferred.update(["fructosa", "salicilatos", "histamina", "fenoles"])
-    elif any(w in food_clean for w in ["queso", "leche", "crema", "yogur", "mantequilla"]):
-        inferred.update(["caseína", "lactosa", "histamina", "tiramina"])
-    elif any(w in food_clean for w in ["pan", "galleta", "pasta", "harina", "bizcocho", "tortilla"]):
-        inferred.update(["gluten", "fodmaps"])
-    elif any(w in food_clean for w in ["frijol", "lenteja", "garbanzo", "legumbre", "soja"]):
-        inferred.update(["lectinas", "fitatos", "fodmaps", "saponinas"])
-    elif any(w in food_clean for w in ["salsa", "sazonador", "aderezo", "caldo", "adobo"]):
-        inferred.update(["glutamato", "histamina", "sulfitos"])
-
-    return list(inferred)
-
-def build_local_hypothesis(entities, food_compound_map, neuro_map):
-    """
-    Generador Local Definitivo de Hipótesis:
-    Construye respuestas clínicas estructuradas clasificando los síntomas en 4 grandes
-    sistemas orgánicos (Neurología, Dermatología, Insomnio, Gastroenterología).
-    """
-    user_foods = entities.get("alimentos", [])
-    user_symptoms = entities.get("sintomas", [])
-    if not user_foods or not user_symptoms:
-        return None
 
-    symptom_text = " ".join(user_symptoms).lower()
-    
-    # Categorización clínica por sistemas de síntomas
     es_dermatologico = any(k in symptom_text for k in ["piel", "rasca", "picazón", "picazon", "manchas", "urticaria", "erupción", "erupcion", "alergia", "ronchas", "granitos"])
     es_cefalea = any(k in symptom_text for k in ["dolor de cabeza", "migraña", "cefalea", "jaqueca", "dolor", "cabeza"])
     es_insomnio = any(k in symptom_text for k in ["insomnio", "no puedo dormir", "sueño", "desvelado", "desvelo", "despierto"])
@@ -794,11 +656,10 @@ def build_local_hypothesis(entities, food_compound_map, neuro_map):
             effect = info.get('efecto_neuropsicologico', f'Sustancia bioactiva ({compound}) con impacto inmunológico o metabolico en {food}')
             candidates.append({"alimento": food, "compuesto": compound, "efecto": effect})
 
-    # Si no hay candidatos bioquímicos específicos, genera la hipótesis con la familia inferida
     if not candidates:
         alimentos_str = ", ".join(user_foods).capitalize()
         sintomas_str = ", ".join(user_symptoms)
-        
+
         if es_cefalea:
             condicion_fallback = f"Cefalea o Migraña Alimentaria relacionada con {alimentos_str}"
         elif es_insomnio:
@@ -823,7 +684,6 @@ def build_local_hypothesis(entities, food_compound_map, neuro_map):
     compuestos_str = ", ".join(compuestos_unicos)
     alimentos_str = ", ".join(alimentos_unicos).capitalize()
 
-    # Construcción sintáctica por sistema afectado
     if es_cefalea:
         condicion = f"Cefalea o Migraña Vasoactiva asociada a {compuestos_str} en {alimentos_str}"
     elif es_dermatologico:
@@ -846,19 +706,16 @@ def build_local_hypothesis(entities, food_compound_map, neuro_map):
     }
 
 def generate_ai_hypothesis_on_the_fly(query, entities):
-    """
-    Agente Rescatador Universal por IA:
-    Sintetiza una hipótesis clínica para CUALQUIER caso, alimento o síntoma no registrado localmente.
-    """
     gemini_client = get_gemini_client()
-    if not gemini_client: return None
-    
+    if not gemini_client:
+        return None
+
     foods = entities.get('alimentos', [])
     symptoms = entities.get('sintomas', [])
-    
+
     foods_text = ", ".join(foods) if foods else "alimentos mencionados en la consulta"
     symptoms_text = ", ".join(symptoms) if symptoms else "síntomas expresados por el paciente"
-    
+
     prompt = (
         "Rol: Médico Especialista en Nutrición Funcional e Inmunología de Alimentos.\n"
         f'Consulta del paciente: "{query}"\n'
@@ -877,17 +734,20 @@ def generate_ai_hypothesis_on_the_fly(query, entities):
             contents=prompt
         )
         raw = response.text.strip()
-        if "```json" in raw: raw = raw.split("```json")[1].split("```")[0]
-        elif "```" in raw: raw = raw.split("```")[1].split("```")[0]
+        if "```json" in raw:
+            raw = raw.split("```json")[1].split("```")[0]
+        elif "```" in raw:
+            raw = raw.split("```")[1].split("```")[0]
         data = json.loads(raw.strip())
         data["es_hipotesis_local"] = True
         return data
     except Exception as e:
         logger.error(f"Error en Agente Rescatador Universal de IA: {e}")
         return None
-        
+
 def find_best_foodb_matches(user_foods_es, _foodb_index, _foodb_lower_map, food_name_map, limit=3):
-    if not user_foods_es or not _foodb_index: return []
+    if not user_foods_es or not _foodb_index:
+        return []
 
     search_terms_en = set()
     for food_es in user_foods_es:
@@ -896,7 +756,8 @@ def find_best_foodb_matches(user_foods_es, _foodb_index, _foodb_lower_map, food_
             if key_es in food_es_clean or food_es_clean in key_es:
                 search_terms_en.update(value_en_list)
 
-    if not search_terms_en: return []
+    if not search_terms_en:
+        return []
 
     found_matches = []
     for term in search_terms_en:
@@ -907,7 +768,8 @@ def find_best_foodb_matches(user_foods_es, _foodb_index, _foodb_lower_map, food_
         for k_lower, orig_key in _foodb_lower_map.items():
             if term_lower in k_lower:
                 found_matches.append(orig_key)
-                if len(found_matches) >= limit: break
+                if len(found_matches) >= limit:
+                    break
 
     seen = set()
     unique = []
@@ -918,41 +780,37 @@ def find_best_foodb_matches(user_foods_es, _foodb_index, _foodb_lower_map, food_
 
     return unique[:limit]
 
-# ==============================================================================
-# GENERADORES DE INFORMES (LOCAL, IA Y MOLECULAR CON FOODB)
-# ==============================================================================
-
 def generate_local_fallback_analysis(query, match, entities, food_compound_map, neuro_map):
     saludo = "### 📋 Informe de Análisis Clínico-Nutricional (Modo Local / Alta Disponibilidad)\n"
     hipotesis = f"**Hipótesis Probable:** Es muy probable que tus síntomas estén relacionados con **{match.get('condicion_asociada', 'una sensibilidad a compuestos alimentarios')}**.\n"
-    
+
     user_foods = entities.get("alimentos", [])
     user_symptoms = entities.get("sintomas", [])
-    
+
     compuestos_detectados = set()
     for food in user_foods:
         comps = get_compounds_for_food(food, food_compound_map)
         if comps:
             compuestos_detectados.update(comps)
-            
+
     compuestos_str = ", ".join(sorted(list(compuestos_detectados))) if compuestos_detectados else match.get('compuesto_alimento', 'compuestos bioactivos')
-    
+
     causa = f"\n### 🧬 Causa e Identificación Molecular\nLos síntomas descritos (**{', '.join(user_symptoms)}**) tras el consumo de **{', '.join(user_foods)}** están asociados a la presencia de sustancias biológicamente activas como **{compuestos_str}**.\n"
-    
+
     detalles_compuestos = []
     for comp in compuestos_detectados:
         if comp in neuro_map:
             detalles_compuestos.append(f"- **{comp.capitalize()}**: {neuro_map[comp]['efecto_neuropsicologico']}")
-            
+
     if detalles_compuestos:
         causa += "\n**Mecanismo bioquímico e impacto neurológico:**\n" + "\n".join(detalles_compuestos) + "\n"
     elif match.get('mecanismo_fisiologico'):
         causa += f"\n**Mecanismo fisiológico:** {match.get('mecanismo_fisiologico')}\n"
 
     evitar = f"\n### 🛑 Alimentos a Moderar o Evitar\n- **Alimentos evaluados:** {', '.join(user_foods).capitalize()}\n- Alimentos ricos en **{compuestos_str}** o productos derivados que compartan los mismos componentes desencadenantes.\n"
-    
+
     alternativas = "\n### 💡 Sugerencias y Alternativas\n- Llevar un diario de síntomas registrando alimentos, hora de consumo y aparición de molestias.\n- Reducir temporalmente la ingesta del alimento sospechoso para evaluar la remisión del síntoma.\n- Consultar con un nutricionista funcional o médico especialista si las molestias persisten.\n"
-    
+
     consejo_texto = None
     for comp in compuestos_detectados:
         comp_clean = comp.lower().strip()
@@ -967,7 +825,7 @@ def generate_local_fallback_analysis(query, match, entities, food_compound_map,
         consejo_texto = CONSEJO_GENERICO_DEFAULT
 
     consejo = f"\n### 📌 Consejo Práctico Final\n{consejo_texto}\n"
-    
+
     return saludo + hipotesis + causa + evitar + alternativas + consejo + TEXTO_BANDERAS_ROJAS
 
 def generate_detailed_analysis(query, match, entities=None, food_compound_map=None, neuro_map=None):
@@ -977,7 +835,7 @@ def generate_detailed_analysis(query, match, entities=None, food_compound_map=No
         return global_learned_cache[cache_lookup_key]
 
     gemini_client = get_gemini_client()
-    
+
     if not gemini_client:
         local_report = generate_local_fallback_analysis(query, match, entities, food_compound_map, neuro_map)
         global_learned_cache[cache_lookup_key] = local_report
@@ -1030,25 +888,25 @@ def generate_neuro_report_text(entities, food_map, neuro_map):
     report_lines = ["\n### 🧠 Efectos Neuropsicológicos Posibles"]
     user_foods = entities.get("alimentos", [])
     relevant_compounds = set()
-    
+
     if user_foods:
         for food in user_foods:
             comps = get_compounds_for_food(food, food_map)
             relevant_compounds.update(comps)
-    
+
     found_neuro_effect = False
     if relevant_compounds:
         for compound in sorted(list(relevant_compounds)):
             if compound in neuro_map:
                 found_neuro_effect = True
                 report_lines.append(f"**{compound.capitalize()}**: _{neuro_map[compound]['efecto_neuropsicologico']}_")
-    
-    if not found_neuro_effect: 
+
+    if not found_neuro_effect:
         report_lines.append("No se detectaron efectos neuropsicológicos específicos directos en nuestra base de datos para los alimentos ingresados.")
-        
+
     return "\n".join(report_lines)
 
-def generate_molecular_report_text(best_match, entities, _foodb_index, _foodb_lower_map, food_name_map, synonym_map, food_compound_map, neuro_map):
+def generate_molecular_report_text(best_match, entities, _foodb_index, _foodb_lower_map, food_name_map, food_compound_map, neuro_map):
     report_lines = ["\n### 🔬 Análisis Molecular y Efectos Bioactivos"]
     user_foods = entities.get("alimentos", [])
     if not user_foods:
@@ -1071,21 +929,22 @@ def generate_molecular_report_text(best_match, entities, _foodb_index, _foodb_lo
         best_food_matches = find_best_foodb_matches(user_foods, _foodb_index, _foodb_lower_map, food_name_map)
         for food_key in best_food_matches:
             compounds = _foodb_index.get(food_key, [])
-            if not compounds: continue
+            if not compounds:
+                continue
             found_any = True
             report_lines.append(f"\n**{food_key.capitalize()}** (Compuestos y efectos fisiológicos en FooDB):")
-            
+
             for item in compounds[:5]:
                 if isinstance(item, dict):
                     comp_name = item.get('compound', 'N/A')
                     effects = item.get('effects', [])
-                    
+
                     eff_translated = []
                     for eff in effects[:4]:
                         eff_clean = str(eff).lower().strip()
                         eff_es = FOODB_EFFECTS_TRANSLATION.get(eff_clean, eff_clean)
                         eff_translated.append(eff_es)
-                        
+
                     eff_str = f" — *Efectos registrados: {', '.join(eff_translated)}*" if eff_translated else ""
                     report_lines.append(f"- **{comp_name}**{eff_str}")
                 else:
@@ -1119,7 +978,7 @@ def generate_word_report(report_text):
 
         doc_io = BytesIO()
         doc.save(doc_io)
-        doc_io.seek(0) 
+        doc_io.seek(0)
         return doc_io.getvalue()
     except Exception as e:
         logger.error(f"Error al generar informe Word: {e}")
@@ -1128,17 +987,13 @@ def generate_word_report(report_text):
 def create_relevance_chart(results):
     top_results = results[:10]
     data = pd.DataFrame({
-        "Condición": [re.sub(r'\(.*\)', '', r['entry']['condicion_asociada']).strip() for r in top_results],
+        "Condición": [re.sub(r'\(.*\)', '', r['entry'].get('condicion_asociada', '')).strip() for r in top_results],
         "Relevancia": [r['score']['total'] for r in top_results]
     })
     return alt.Chart(data).mark_bar().encode(
         x='Relevancia', y=alt.Y('Condición', sort='-x'), tooltip=['Condición', 'Relevancia']
     ).properties(title='Top Coincidencias')
 
-# ==============================================================================
-# INICIALIZACIÓN DE ESTADO PERSISTENTE Y UI STREAMLIT
-# ==============================================================================
-
 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 = ""
 if 'entities' not in st.session_state: st.session_state.entities = None
@@ -1157,8 +1012,8 @@ with col_img2:
 
 with st.form(key="search_form", clear_on_submit=False):
     query_input = st.text_area(
-        "Tu Caso:", 
-        height=150, 
+        "Tu Caso:",
+        height=150,
         placeholder="Ej: Si tomo mucho jugo de chontaduro no puedo dormir.",
         key="input_query_text"
     )
@@ -1172,25 +1027,21 @@ if submitted:
         st.session_state.analysis_cache = {}
         st.session_state.search_results = None
         st.session_state.entities = None
-        
+
         with st.spinner("🔍 Analizando pistas con Gemini..."):
-            # PASO 1: Extracción con Gemini
             raw_entities = extract_entities_with_gemini(current_query)
             reinforced = reinforce_entities_with_keywords(raw_entities, current_query, FOOD_TO_COMPOUND_MAP, MASTER_SYMPTOM_MAP)
             final_symptoms = translate_symptoms_local(reinforced.get("sintomas", []), MASTER_SYMPTOM_MAP)
             final_entities = {"alimentos": reinforced.get("alimentos", []), "sintomas": final_symptoms}
             st.session_state.entities = final_entities
-            
-            # PASO 2A: Búsqueda Local en JSON
+
             results = find_best_matches_hybrid(final_entities, alimentos_data, current_query, FOOD_TO_COMPOUND_MAP)
 
-            # PASO 2B: Hipótesis por Diccionarios Locales
             if not results:
                 local_hypothesis = build_local_hypothesis(final_entities, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP)
                 if local_hypothesis:
                     results = [{'entry': local_hypothesis, 'score': {'total': 50}, 'matched_keywords': []}]
 
-            # PASO 2C: PUENTE DE IA (Si el alimento no está en la BD, Gemini crea la hipótesis)
             if not results:
                 ai_hypothesis = generate_ai_hypothesis_on_the_fly(current_query, final_entities)
                 if ai_hypothesis:
@@ -1200,16 +1051,15 @@ if submitted:
     else:
         st.warning("⚠️ Por favor describe tus síntomas o alimentos consumidos antes de analizar.")
 
-# --- DISPLAY DE RESULTADOS OPTIMIZADO ---
 if st.session_state.has_searched:
     results = st.session_state.search_results
-    
+
     if results and len(results) > 0:
         best_match = results[0]['entry']
         st.success(f"🔎 Coincidencia Principal: **{best_match.get('condicion_asociada')}**")
-        
+
         cache_key = f"analysis_{hash(st.session_state.user_query)}_{best_match.get('condicion_asociada')}"
-        
+
         if cache_key not in st.session_state.analysis_cache:
             with st.spinner("✍️ Redactando informe..."):
                 analysis = generate_detailed_analysis(
@@ -1217,12 +1067,12 @@ if st.session_state.has_searched:
                     st.session_state.entities, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP
                 )
                 st.session_state.analysis_cache[cache_key] = analysis
-                
+
                 full_report = f"REPORTE\n\n{analysis}"
                 st.session_state.word_bytes_cache[cache_key] = generate_word_report(full_report)
 
         tab_main, tab_neuro, tab_mol = st.tabs(["💡 Interpretación Clínica", "🧠 Efectos Neuropsicológicos", "🔬 Análisis Molecular"])
-        
+
         with tab_main:
             st.markdown(st.session_state.analysis_cache[cache_key])
             if len(results) > 1:
@@ -1234,7 +1084,7 @@ if st.session_state.has_searched:
         with tab_mol:
             st.markdown(generate_molecular_report_text(
                 best_match, st.session_state.entities, foodb_index, foodb_lower_map,
-                FOOD_NAME_TO_FOODB_KEY, COMPOUND_SYNONYM_MAP, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP
+                FOOD_NAME_TO_FOODB_KEY, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP
             ))
 
         word_bytes = st.session_state.word_bytes_cache.get(cache_key)