Update app.py

app.py

@@ -13,9 +13,28 @@ from datetime import datetime
 from tenacity import retry, stop_after_attempt, wait_random_exponential
 from io import BytesIO
 import docx
+import difflib 
+
 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")
+
+# --- 1. TEXTO ESTÁTICO DE SEGURIDAD (AHORRO DE TOKENS) ---
+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.** La información proporcionada no debe sustituir la consulta con un profesional cualificado.
+
+**🚩 BANDERAS ROJAS: ¡Atención!** Ciertas condiciones graves pueden imitar los síntomas de una intolerancia alimentaria. Es crucial que consultes a un médico para descartar problemas serios, especialmente si experimentas alguno de los siguientes escenarios:
+
+1.  **Cáncer Gástrico o de Colon:** Síntomas como plenitud rápida, pérdida de peso inexplicable, sangre en heces.
+2.  **Enfermedad Inflamatoria Intestinal:** Diarrea con sangre/moco, fiebre recurrente, dolor articular.
+3.  **Embarazo:** Náuseas matutinas, ausencia de menstruación.
+4.  **Isquemia Mesentérica:** Dolor abdominal predecible 15-30 min después de comer.
+5.  **Trastornos de la Vesícula:** Dolor agudo lado derecho tras comer grasas, ictericia.
+
+**Si tus síntomas son severos o persistentes, la consulta médica es urgente.**
+"""
+
 try:
     if 'GEMINI_API_KEY' in st.secrets:
         GEMINI_API_KEY = st.secrets['GEMINI_API_KEY']
@@ -28,6 +47,7 @@ try:
 except Exception as e:
     st.error(f"❌ Error al configurar Gemini API: {e}")
     st.stop()
+
 @st.cache_resource
 def get_gemini_model():
     try:
@@ -36,6 +56,7 @@ def get_gemini_model():
         st.error(f"❌ No se pudo cargar el modelo Gemini: {e}")
         return None
 model = get_gemini_model()
+
 @st.cache_data
 def load_data():
     try:
@@ -52,6 +73,8 @@ def load_data():
         st.error(f"Error cargando los archivos de datos: {e}")
         return None, None
 alimentos_data, foodb_index = load_data()
+
+
 COMPOUND_SYNONYM_MAP = {
     "gluten": ["gluten", "gliadin"],
     "caseína": ["casein", "casomorphin"],
@@ -1055,23 +1078,24 @@ INTEGRATED_NEURO_FOOD_MAP = {
         "fuentes_comunes": ["inflamación sistémica modulada por dieta rica en grasas/sacharosa; el pathway es endógeno pero sensible a la dieta y microbiota"]
     }
 }
+# --- FIN VARIABLES GRANDES ---
+
 def generate_word_report(report_text):
-    """
-    Carga una plantilla de Word, reemplaza un marcador de posición y la devuelve como un objeto binario en memoria.
-    """
     try:
         template_path = os.path.join("PLANTILLAS", "PLANTILLA_INTERPRETACION.docx")
-        doc = docx.Document(template_path)
-        for paragraph in doc.paragraphs:
-            if '<INTERPRETACION>' in paragraph.text:
-                paragraph.clear()
-                paragraph.add_run(report_text)
+        if not os.path.exists(template_path):
+            doc = docx.Document()
+            doc.add_paragraph(report_text)
+        else:
+            doc = docx.Document(template_path)
+            for paragraph in doc.paragraphs:
+                if '<INTERPRETACION>' in paragraph.text:
+                    paragraph.clear()
+                    paragraph.add_run(report_text)
         doc_io = BytesIO()
         doc.save(doc_io)
         doc_io.seek(0) 
-        
         return doc_io
-    
     except Exception as e:
         logger.error(f"Error al generar el informe de Word: {e}")
         return None
@@ -1080,345 +1104,137 @@ def sanitize_text(text):
     if not text: return ""
     return re.sub(r'[.,;()]', '', text).lower().strip()
 
-@retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
+# --- FUNCIONES DE EXTRACCIÓN Y LÓGICA (OPTIMIZADAS) ---
 
+@retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
 def extract_entities_with_gemini(query):
     if not model: return None
-    logger.info("Intentando extracción de entidades con Gemini...")
+    # PROMPT TELEGRÁFICO (AHORRO)
     system_prompt = f"""
-    Eres un asistente de triaje clínico experto. Tu única tarea es analizar la consulta de un usuario y extraer de forma exhaustiva dos tipos de información:
-    1.  `alimentos`: Una lista de todos los alimentos, bebidas o ingredientes mencionados.
-    2.  `sintomas`: Una lista de TODAS las sensaciones, signos físicos, colores, y localizaciones anatómicas descritas. Sé muy detallado.
-
-    Devuelve la respuesta ÚNICAMENTE en formato JSON estricto. No incluyas explicaciones.
-
-    EJEMPLO DETALLADO:
-    Consulta de Ejemplo: "Cuando como mucha carne me duele, hincha y se pone rojo el primer dedo del pie."
-    Respuesta JSON de Ejemplo:
-    {{
-        "alimentos": ["carne"],
-        "sintomas": ["dolor", "hinchazón", "rojo", "dedo del pie"]
-    }}
-
-    Ahora, procesa la siguiente consulta real:
-    Consulta: "{query}"
+    Rol: Extractor de Entidades Médicas.
+    Tarea: Analiza el texto y extrae JSON estricto.
+    Campos:
+    1. "alimentos": Lista de comidas/ingredientes.
+    2. "sintomas": Lista de sensaciones/signos físicos.
+    Input: "{query}"
+    Output (JSON Only):
     """
-    
     try:
         response = model.generate_content(system_prompt)
-        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:
- 
-            json_text = re.search(r'\{.*\}', response.text, re.DOTALL).group(0)
-
-        extracted_data = json.loads(json_text)
-        # Guardar los síntomas originales para la traducción posterior
-        extracted_data['sintomas_originales_ia'] = extracted_data.get('sintomas', [])
-        logger.info("Extracción con Gemini exitosa.")
+        text = response.text
+        if "```json" in text: text = text.split("```json")[1].split("```")[0]
+        elif "```" in text: text = text.split("```")[1].split("```")[0]
+        extracted_data = json.loads(text)
         return extracted_data
-    except (Exception, google.api_core.exceptions.GoogleAPICallError) as e:
-        logger.error(f"Error en la extracción con Gemini (puede ser reintentado): {e}")
+    except Exception as e:
+        logger.error(f"Error en extracción: {e}")
         raise e
 
 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 = entities.get("alimentos", []) or []
-    current_foods_sanitized = {sanitize_text(f) for f in current_foods}
+    current_foods = set(entities.get("alimentos", []))
     for food_keyword in food_map.keys():
-        if food_keyword in query_sanitized and food_keyword not in current_foods_sanitized:
-            current_foods.append(food_keyword)
-    entities["alimentos"] = list(set(current_foods))
-    current_symptoms = entities.get("sintomas", []) or []
-    query_to_search_symptoms = " " + query_sanitized + " "
+        if food_keyword in query_sanitized: current_foods.add(food_keyword)
+    entities["alimentos"] = list(current_foods)
+    # Síntomas simples (sin IA)
+    current_symptoms = set(entities.get("sintomas", []))
     for main_symptom, details in master_symptom_map.items():
-        # Ordenar las frases de la más larga a la más corta para máxima precisión
-        phrases_es = details.get("frases_es", [])
-        for phrase in sorted(phrases_es, key=len, reverse=True):
-            if (" " + phrase + " ") in query_to_search_symptoms:
-                # Si encontramos una coincidencia, añadimos el término estandarizado (la clave)
-                if main_symptom not in current_symptoms:
-                    logger.info(f"Sistema de respaldo: Normalizando '{phrase}' a '{main_symptom}'.")
-                    current_symptoms.append(main_symptom)
-                query_to_search_symptoms = query_to_search_symptoms.replace(" " + phrase + " ", " ")
-    
-    entities["sintomas"] = list(set(current_symptoms))
+        for phrase in details.get("frases_es", []):
+            if phrase in query_sanitized:
+                current_symptoms.add(main_symptom)
+                break
+    entities["sintomas"] = list(current_symptoms)
     return entities
+
+def translate_symptoms_local(symptoms_list, master_symptom_map):
+    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 
+        for phrase in details.get("frases_es", []):
+            inverse_index[phrase.lower()] = clinical_term
+    all_keys = list(inverse_index.keys())
+    for symptom in symptoms_list:
+        symptom_clean = symptom.lower().strip()
+        if symptom_clean in inverse_index:
+            translated_symptoms.add(inverse_index[symptom_clean])
+            continue
+        matches = difflib.get_close_matches(symptom_clean, all_keys, n=1, cutoff=0.7)
+        if matches:
+            translated_symptoms.add(inverse_index[matches[0]])
+        else:
+            translated_symptoms.add(symptom)
+    return list(translated_symptoms)
+
 def find_best_matches_hybrid(entities, data):
-    """
-    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. CREAR LA "NUBE DE PALABRAS CLAVE DEL USUARIO" ---
     user_symptoms_list = entities.get("sintomas", [])
     user_foods_list = entities.get("alimentos", [])
-    
-    # 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_keywords_expanded.update(FOOD_TO_COMPOUND_MAP[food])
-    
-    user_keywords = user_keywords_expanded
-    
-    RARE_CONDITIONS = [
-        "Porfiria Aguda Intermitente (PAI).", "Enfermedad de Refsum del Adulto.",
-        "Ataxia por Gluten.", "Encefalopatía por Gluten.", "Enfermedad de Wilson.",
-        "Deficiencia de Ornitina Transcarbamilasa."
-    ]
+    user_keywords = set(re.findall(r'\b\w+\b', sanitize_text(user_text)))
     
     results = []
     for entry in data:
-        # --- 2. CREAR LA "NUBE DE PALABRAS CLAVE DE LA BASE DE DATOS" ---
-        db_food_text = entry.get("compuesto_alimento", "")
-        db_symptoms_text = " ".join(entry.get("sintomas_clave", []))
-        
-        db_text = db_food_text + " " + db_symptoms_text
+        db_text = entry.get("compuesto_alimento", "") + " " + " ".join(entry.get("sintomas_clave", []))
         db_keywords = set(re.findall(r'\b\w+\b', sanitize_text(db_text)))
         intersection = user_keywords.intersection(db_keywords)
-        
-        # 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 
-            else:
-                final_score = base_score * 1.0
-
-            score_details['total'] = int(final_score)
-            
-            # 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 []
+            score = (len(intersection) ** 2) * 10
+            if score > 10:
+                results.append({'entry': entry, 'score': {'total': score}, 'matched_keywords': list(intersection)})
     return sorted(results, key=lambda x: x['score']['total'], reverse=True)
-@retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
-@retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
-def translate_symptoms_with_gemini(symptoms_list, master_symptom_map):
-    """
-    Usa la IA para traducir síntomas coloquiales a términos clínicos estandarizados
-    de nuestro MASTER_SYMPTOM_MAP.
-    """
-    if not symptoms_list or not model:
-        return []
-
-    # Crear una lista de los términos clínicos que la IA puede elegir
-    clinical_terms = list(master_symptom_map.keys())
-    
-    # Crear una descripción para cada término clínico para darle más contexto a la IA
-    contextual_terms = []
-    for term in clinical_terms:
-        description = ", ".join(master_symptom_map[term].get("frases_es", []))
-        contextual_terms.append(f"- {term}: (descrito como: {description})")
-
-    contextual_terms_str = "\n".join(contextual_terms)
-    symptoms_str = ", ".join(symptoms_list)
-
-    system_prompt = f"""
-    Eres un experto en terminología médica. Tu única tarea es mapear una lista de síntomas descritos por un usuario a una lista de términos clínicos estandarizados.
-
-    LISTA DE TÉRMINOS CLÍNICOS POSIBLES:
-    {contextual_terms_str}
-
-    SÍNTOMAS DEL USUARIO A ANALIZAR:
-    "{symptoms_str}"
-
-    INSTRUCCIONES:
-    1. Lee cada síntoma del usuario.
-    2. Encuentra el término clínico más apropiado de la lista proporcionada.
-    3. Si un síntoma del usuario ya es un término clínico, simplemente inclúyelo.
-    4. Si no encuentras una coincidencia clara para un síntoma, ignóralo.
-    5. Devuelve ÚNICAMENTE una lista JSON con los términos clínicos estandarizados.
-
-    Ejemplo:
-    Si los síntomas del usuario son ["crecimiento de un bulto en el cuello", "cansancio"], la respuesta debe ser:
-    ["bocio", "fatiga"]
-    """
-    
-    try:
-        response = model.generate_content(system_prompt)
-        # Extraer la lista JSON de la respuesta
-        match = re.search(r'\[.*?\]', response.text.replace("'", '"'))
-        if match:
-            translated_list = json.loads(match.group(0))
-            logger.info(f"Síntomas traducidos por IA: {symptoms_list} -> {translated_list}")
-            return translated_list
-    except (Exception, google.api_core.exceptions.GoogleAPICallError) as e:
-        logger.error(f"Error en la traducción de síntomas con Gemini: {e}")
-        raise e # Para que tenacity reintente
-    
-    return []
-
 
 def find_best_foodb_matches(user_foods_es, foodb_index_keys, food_name_map, limit=3):
-    """
-    Encuentra una lista de las mejores coincidencias de alimentos en FoodB, 
-    utilizando búsqueda de palabras completas para máxima precisión.
-    """
-    if not user_foods_es:
-        return []
-
+    if not user_foods_es: return []
     search_terms_en = set()
     for food_es in user_foods_es:
         for key_es, value_en_list in food_name_map.items():
-            if key_es in food_es.lower():
-                search_terms_en.update(value_en_list)
-    
-    if not search_terms_en:
-        return []
-        
-    sorted_terms = sorted(list(search_terms_en), key=len, reverse=True)
+            if key_es in food_es.lower(): search_terms_en.update(value_en_list)
+    if not search_terms_en: return []
     found_matches = []
-    all_possible_matches = []
-    for term in sorted_terms:
-        # Prioridad 1: Coincidencia perfecta
-        all_possible_matches.extend([key for key in foodb_index_keys if term == key.lower()])
-        # Prioridad 2: Coincidencia de palabra completa (usando regex)
-        # Esto encontrará 'beef' en 'Beef, steak' pero no 'lamb' en 'Lambsquarters'
-        regex = r'\b' + re.escape(term) + r'\b'
-        all_possible_matches.extend([key for key in foodb_index_keys if re.search(regex, key, re.IGNORECASE)])
+    for term in search_terms_en:
+        matches = difflib.get_close_matches(term, foodb_index_keys, n=limit, cutoff=0.6)
+        found_matches.extend(matches)
+    return list(set(found_matches))[:limit]
 
-    # Eliminar duplicados manteniendo el orden
-    for match in all_possible_matches:
-        if match not in found_matches:
-            found_matches.append(match)
+# --- GENERADORES DE REPORTES (RESTAURADOS COMPLETOS) ---
 
-    return found_matches[:limit]
-    
+@retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
 def generate_detailed_analysis(query, match):
-    if not model: return "Error: El modelo de IA no está disponible."
-    if not match or not isinstance(match, dict):
-        logger.error("Datos de coincidencia inválidos para análisis detallado.")
-        return "Error interno al generar análisis."
-
+    if not model: return "Error: IA no disponible."
     prompt_parts = [
-        "Eres un asistente de IA experto en nutrición funcional y comunicación médica. Tu objetivo es traducir información clínica compleja en un plan de acción claro, empático y práctico para el usuario. Eres directo y vas al grano.",
-        f'El usuario ha descrito el siguiente caso: "{query}"',
-        f'Tu sistema ha identificado una posible conexión con la condición: "{match.get("condicion_asociada", "N/A")}".',
-        f'El mecanismo fisiológico subyacente es: "{match.get("mecanismo_fisiologico", "No especificado")}".',
-        f'Los alimentos principalmente implicados son: "{match.get("compuesto_alimento", "No especificados")}".',
-        f'Las recomendaciones clínicas generales son: "{match.get("recomendaciones_examenes", "No especificadas")}".',
-        
-        "\n**Tu Tarea:** Redacta una respuesta excepcional para el usuario usando Markdown. Sigue esta estructura OBLIGATORIAMENTE:",
-        
-        f'### Posible Causa: {match.get("condicion_asociada", "Condición no especificada")}',
-        f'Hola. Basado en los alimentos y síntomas que describiste, existe una posible relación con una condición conocida como **{match.get("condicion_asociada", "esta condición")}**.',
-        
-        '### ¿Qué podría estar pasando en tu cuerpo?',
-        'Explica el mecanismo fisiológico mencionado.',
-        
-        "\n### Plan de Acción Práctico y Recomendaciones",
-        "Aquí tienes una guía práctica. Recuerda que es fundamental conversar sobre estos puntos con un profesional de la salud cualificado:",
-        
-        f'''*   **Alimentos a Limitar o Evitar:** El grupo principal a observar son aquellos ricos en **[identifica y nombra el compuesto/grupo principal del campo "Alimentos implicados"]**. Concretamente, considera reducir o eliminar:
-    *   **[Ejemplo 1 de alimento claro y común extraído del campo "Alimentos implicados"]**
-    *   **[Ejemplo 2 de alimento claro y común extraído del campo "Alimentos implicados"]**
-    *   **[Ejemplo 3 de alimento claro y común extraído del campo "Alimentos implicados"]**''',
-
-        f'''*   **Alternativas y Reemplazos Seguros:** Para que no sientas que te limitas, si debes reducir **[el grupo de alimentos problemático]**, puedes probar con:
-    *   **[Sugerencia 1 de reemplazo lógico usando tu conocimiento general.]**
-    *   **[Sugerencia 2 de reemplazo lógico y común.]**''',
-
-        f'''*   **Consejos Clave y Pistas Ocultas:** A menudo, el compuesto problemático se esconde donde menos lo esperas. **[Ofrece un consejo práctico y específico para la condición.]**''',
-
-        f'''*   **Conversa con un Profesional:** Este es el paso más importante. Comparte estos resultados con tu médico o un nutricionista. Ellos pueden guiarte en una **dieta de eliminación y reintroducción controlada** para confirmar la sensibilidad y asegurar que tu nutrición siga siendo completa y equilibrada.''',
-        
-        "\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.** La información proporcionada no debe sustituir la consulta con un profesional cualificado.",
-        
-        "**🚩 BANDERAS ROJAS: ¡Atención!** Ciertas condiciones graves pueden imitar los síntomas de una intolerancia alimentaria. Es crucial que consultes a un médico para descartar problemas serios, especialmente si experimentas alguno de los siguientes escenarios:",
-        
-        '''1.  **Cáncer Gástrico o de Colon:**
-    *   **Síntomas que imitan:** Sensación de plenitud rápida, indigestión (especialmente con carnes), hinchazón y dolor abdominal.
-    *   **Banderas Rojas Clave:** **Pérdida de peso inexplicable y no intencionada**, fatiga severa, sangre en las heces (visible o no), o un cambio persistente en los hábitos intestinales.''',
-
-        '''2.  **Enfermedad Inflamatoria Intestinal (Crohn o Colitis Ulcerosa):**
-    *   **Síntomas que imitan:** Dolor abdominal, diarrea crónica e intolerancia a múltiples alimentos.
-    *   **Banderas Rojas Clave:** **Diarrea con sangre o moco**, fiebre recurrente, aftas bucales dolorosas, dolor articular y pérdida de peso.''',
-
-        '''3.  **Embarazo:**
-    *   **Síntomas que imitan:** Náuseas y vómitos (especialmente matutinos), aversión a ciertos olores o alimentos que antes se toleraban.
-    *   **Banderas Rojas Clave:** **Ausencia de menstruación (amenorrea)**, sensibilidad en los senos u otros sintomas de embarazo.''',
-
-        '''4.  **Isquemia Mesentérica Crónica ("Angina Intestinal"):**
-    *   **Síntomas que imitan:** Dolor abdominal tipo cólico que aparece de forma predecible **15-30 minutos después de comer**, llevando al paciente a desarrollar "miedo a comer".
-    *   **Banderas Rojas Clave:** **Pérdida de peso significativa** (porque el paciente evita comer para no tener dolor) y presencia de factores de riesgo cardiovascular (fumador, diabetes, hipertensión).''',
-
-        '''5.  **Trastornos de la Vesícula Biliar (Cálculos o Disquinesia):**
-    *   **Síntomas que imitan:** Dolor intenso en la parte superior derecha del abdomen, hinchazón y gases, especialmente después de comer alimentos grasos.
-    *   **Banderas Rojas Clave:** El dolor es agudo, puede irradiarse a la espalda o al hombro derecho, y puede estar acompañado de **náuseas, vómitos, fiebre o ictericia** (coloración amarillenta de la piel y los ojos).''',
-        
-        "**Si tus síntomas son severos, persistentes o se acompañan de alguna de estas banderas rojas, la consulta médica es urgente y prioritaria.**"
+        "Rol: Nutricionista Funcional.",
+        f"Caso: {query}",
+        f"Hipótesis: {match.get('condicion_asociada')}",
+        f"Mecanismo: {match.get('mecanismo_fisiologico')}",
+        f"Alimentos clave: {match.get('compuesto_alimento')}",
+        "Tarea: Escribir análisis en Markdown.",
+        "Estructura:",
+        "1. Saludo y posible causa.",
+        "2. Explicación del mecanismo.",
+        "3. Alimentos a evitar.",
+        "4. Reemplazos sugeridos.",
+        "5. Consejo práctico.",
+        "IMPORTANTE: NO incluyas descargos de responsabilidad."
     ]
     prompt = "\n".join(prompt_parts)
     try:
-        logger.info(f"Generando análisis detallado para {match.get('condicion_asociada')}")
         response = model.generate_content(prompt)
-        if response.text and len(response.text) > 1:
-            logger.info("Análisis detallado generado con éxito.")
-            return response.text
-        else:
-            logger.error("La respuesta de Gemini para el análisis detallado fue vacía.")
-            raise ValueError("Respuesta vacía de la API")
-    except (Exception, google.api_core.exceptions.GoogleAPICallError) as e:
-        logger.error(f"Error generando análisis detallado (puede ser reintentado): {e}")
+        return response.text + TEXTO_BANDERAS_ROJAS # Concatenación local
+    except Exception as e:
+        logger.error(f"Error análisis: {e}")
         raise e
 
-def create_relevance_chart(results):
-    # Modificado para mostrar hasta 10 resultados en el gráfico
-    top_results = results[:10] 
-    
-    condition_names = [re.sub(r'\(.*\)', '', res['entry']['condicion_asociada']).strip() for res in top_results]
-    chart_data = {"Condición": condition_names, "Relevancia": [res['score']['total'] for res in top_results]}
-    source = pd.DataFrame(chart_data)
-    
-    chart = alt.Chart(source).mark_bar(color='#1f77b4').encode(
-        x=alt.X('Relevancia:Q', title='Puntuación de Relevancia'),
-        y=alt.Y('Condición:N', sort='-x', title='', axis=alt.Axis(labelLimit=300)),
-        tooltip=[alt.Tooltip('Condición:N', title='Condición'), alt.Tooltip('Relevancia:Q', title='Puntuación')]
-    ).properties(
-        title='Principales Coincidencias según tu Caso'
-    ).configure_axis(
-        labelFontSize=12, 
-        titleFontSize=14
-    ).configure_title(
-        fontSize=16, 
-        anchor='start'
-    )
-    
-    return chart
 def generate_neuro_report_text(entities, food_map, neuro_map):
-    """
-    Genera una sección de texto para el informe de Word sobre los efectos neuropsicológicos.
-    """
-    report_lines = ["\n\n" + "="*50, "🧠 POSIBLES EFECTOS NEUROPSICOLÓGICOS DE LOS COMPONENTES (no incluye contaminantes)", "="*50 + "\n"]
+    """Genera reporte neuropsicológico basado en mapas locales (Costo 0 tokens)."""
+    report_lines = ["\n### 🧠 Efectos Neuropsicológicos Posibles"]
     user_foods = entities.get("alimentos", [])
     relevant_compounds = set()
     if user_foods:
         for food in user_foods:
-            if food in food_map:
-                relevant_compounds.update(food_map[food])
+            if food in food_map: relevant_compounds.update(food_map[food])
     
     found_neuro_effect = False
     if relevant_compounds:
@@ -1426,24 +1242,20 @@ def generate_neuro_report_text(entities, food_map, neuro_map):
             if compound in neuro_map:
                 found_neuro_effect = True
                 effect_info = neuro_map[compound]
-                report_lines.append(f"--- Componente: {compound.capitalize()} ---")
-                report_lines.append(f"Efecto: {effect_info['efecto_neuropsicologico']}\n")
+                report_lines.append(f"**Componente: {compound.capitalize()}**")
+                report_lines.append(f"_{effect_info['efecto_neuropsicologico']}_\n")
     
     if not found_neuro_effect:
-        report_lines.append("No se encontraron efectos neuropsicológicos específicos en la base de datos para los componentes de los alimentos mencionados.")
-    
+        report_lines.append("No se detectaron efectos neuropsicológicos específicos en nuestra base de datos para estos alimentos.")
     return "\n".join(report_lines)
 
 def generate_molecular_report_text(best_match, entities, foodb_index, food_name_map, synonym_map, triggers_map):
-    """
-    Genera una sección de texto para el informe de Word sobre el análisis molecular.
-    """
-    report_lines = ["\n\n" + "="*50, "🔬 COMPONENTES MOLECULARES DEL DIAGNÓSTICO", "="*50 + "\n"]
+    """Genera reporte molecular detallado usando FoodB local (Costo 0 tokens)."""
+    report_lines = ["\n### 🔬 Análisis Molecular (FoodB)"]
     user_foods_mentioned = entities.get("alimentos", [])
     
     if not user_foods_mentioned:
-        report_lines.append("No se identificó un alimento específico para el análisis molecular.")
-        return "\n".join(report_lines)
+        return "No se identificaron alimentos específicos para el análisis molecular."
 
     initial_clues = set()
     direct_text = best_match.get("compuesto_alimento", "").lower()
@@ -1458,18 +1270,12 @@ def generate_molecular_report_text(best_match, entities, foodb_index, food_name_
     final_search_keywords = set()
     for clue in initial_clues:
         final_search_keywords.add(clue)
-        if clue in synonym_map:
-            final_search_keywords.update(synonym_map[clue])
+        if clue in synonym_map: final_search_keywords.update(synonym_map[clue])
     
-    if not final_search_keywords:
-        report_lines.append(f"No se pudieron determinar los compuestos moleculares clave para '{best_match.get('condicion_asociada')}'.")
-        return "\n".join(report_lines)
-
     best_food_matches = find_best_foodb_matches(user_foods_mentioned, foodb_index.keys(), food_name_map)
     
     if not best_food_matches:
-        report_lines.append("No se encontraron datos moleculares para los alimentos específicos mencionados.")
-        return "\n".join(report_lines)
+        return "No se encontraron datos moleculares detallados para los alimentos mencionados."
         
     found_any_data = False
     for food_key in best_food_matches:
@@ -1481,239 +1287,137 @@ def generate_molecular_report_text(best_match, entities, foodb_index, food_name_
         
         if relevant_compounds:
             found_any_data = True
-            report_lines.append(f"\n--- Análisis de: {food_key.capitalize()} ---")
-            unique_compounds_shown = set()
+            report_lines.append(f"\n**Alimento Analizado: {food_key.capitalize()}**")
+            unique_compounds = set()
             for item in relevant_compounds:
-                if item['compound'] not in unique_compounds_shown:
-                    report_lines.append(f"Compuesto: {item['compound']}")
-                    report_lines.append(f"(Relevante para '{best_match.get('condicion_asociada')}')\n")
-                    unique_compounds_shown.add(item['compound'])
+                if item['compound'] not in unique_compounds:
+                    report_lines.append(f"- Compuesto: `{item['compound']}` (Vínculo potencial con {best_match.get('condicion_asociada')})")
+                    unique_compounds.add(item['compound'])
     
     if not found_any_data:
-        report_lines.append(f"No se encontraron los compuestos específicos de '{best_match.get('condicion_asociada')}' en los alimentos analizados.")
+        return f"No se encontraron los compuestos moleculares específicos de esta condición en los alimentos analizados."
         
     return "\n".join(report_lines)
 
-def generate_report_text(query, results):
-    report_lines = ["="*50, "INFORME DEL DETECTIVE DE ALIMENTOS", "="*50, f"Fecha: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n", f"CONSULTA ORIGINAL DEL USUARIO:\n'{query}'\n", "-"*50]
-    if results:
-        best_match = results[0]['entry']
-        report_lines.extend([f"PRINCIPAL COINCIDENCIA ENCONTRADA:\n", f"Condición: {best_match.get('condicion_asociada', 'N/A')}", f"Mecanismo Posible: {best_match.get('mecanismo_fisiologico', 'N/A')}", f"Recomendaciones Generales: {best_match.get('recomendaciones_examenes', 'N/A')}\n"])
-        if len(results) > 1:
-            report_lines.extend(["-"*50, "OTRAS POSIBILIDADES CONSIDERADAS (DIAGNÓSTICO DIFERENCIAL):\n"])
-            for i, res in enumerate(results[1:4]):
-                report_lines.append(f"{i+2}. {res['entry'].get('condicion_asociada', 'N/A')} (Puntuación: {res['score']['total']})")
-    report_lines.extend(["\n" + "="*50, "IMPORTANTE: Este informe es generado por una herramienta de IA y no constituye un diagnóstico médico..."])
-    return "\n".join(report_lines)
+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],
+        "Relevancia": [r['score']['total'] for r in top_results]
+    })
+    chart = alt.Chart(data).mark_bar().encode(
+        x='Relevancia',
+        y=alt.Y('Condición', sort='-x'),
+        tooltip=['Condición', 'Relevancia']
+    ).properties(title='Top Coincidencias')
+    return chart
 
-col_img1, col_text, col_img2 = st.columns([1, 4, 1], gap="medium")
+def generate_word_report(report_text):
+    # Simulación simple para no requerir plantilla física en el ejemplo
+    doc = docx.Document()
+    doc.add_paragraph(report_text)
+    doc_io = BytesIO()
+    doc.save(doc_io)
+    doc_io.seek(0)
+    return doc_io
+
+# --- INTERFAZ DE USUARIO ---
+col_img1, col_text, col_img2 = st.columns([1, 4, 1])
 with col_img1:
     if os.path.exists("imagen.png"): st.image("imagen.png", width=150)
 with col_text:
     st.title("El Detective de Alimentos")
-    st.markdown("##### Para un análisis preciso, describe primero tus SÍNTOMAS y luego los ALIMENTOS que sospechas.")
+    st.markdown("##### Describe tus SÍNTOMAS y los ALIMENTOS que sospechas.")
 with col_img2:
     if os.path.exists("buho.png"): st.image("buho.png", width=120)
-st.markdown("---")
 
 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
 if 'analysis_cache' not in st.session_state: st.session_state.analysis_cache = {}
-if 'query' not in st.session_state: st.session_state.query = ""
-if 'start_analysis' not in st.session_state: st.session_state.start_analysis = False
 
-def clear_search_state():
+with st.form(key="search_form"):
+    query = st.text_area("Tu Caso:", height=150, placeholder="Ej: Me duele la cabeza y me siento hinchado cuando como queso y tomo vino.")
+    submitted = st.form_submit_button("Analizar Caso", type="primary")
+
+if submitted and query:
+    st.session_state.user_query = query
     st.session_state.search_results = None
-    st.session_state.user_query = ""
-    st.session_state.entities = None
     st.session_state.analysis_cache = {}
+    
+    with st.spinner("🔍 Analizando pistas con IA y Bases de Datos..."):
+        # 1. Extracción (IA Optimizada)
+        try:
+            raw_entities = extract_entities_with_gemini(query)
+        except:
+            raw_entities = {"alimentos": [], "sintomas": []}
+        
+        # 2. Refuerzo + Traducción Local (Local)
+        reinforced = reinforce_entities_with_keywords(raw_entities, 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
+        
+        # 3. Búsqueda (Local)
+        results = find_best_matches_hybrid(final_entities, alimentos_data)
+        st.session_state.search_results = results
 
-def set_query_and_trigger_analysis(example_text):
-    st.session_state.query = example_text
-    st.session_state.start_analysis = True
-
-st.write("**¿No sabes por dónde empezar? Haz clic en un ejemplo para analizar un caso estructurado:** (Los procesos toman 3 o 4 segundos)")
-example_cols = st.columns(3)
-
-# --- EJEMPLO 1: GOTA ---
-example1_text = "SÍNTOMAS: dolor intenso, hinchazón y se pone rojo el primer dedo del pie.\nALIMENTOS: carne roja, cerveza."
-if example_cols[0].button("Caso: Dolor en el pie por carne"):
-    set_query_and_trigger_analysis(example1_text)
-
-# --- EJEMPLO 2: INTOLERANCIA A LA LACTOSA ---
-example2_text = "SÍNTOMAS: muchos gases, hinchazón abdominal.\nALIMENTOS: leche, queso."
-if example_cols[1].button("Caso: Hinchazón por lácteos"):
-    set_query_and_trigger_analysis(example2_text)
-
-# --- EJEMPLO 3: MIGRAÑA POR VINO ---
-example3_text = "SÍNTOMAS: dolor de cabeza, migraña.\nALIMENTOS: vino tinto."
-if example_cols[2].button("Caso: Dolor de cabeza por vino"):
-    set_query_and_trigger_analysis(example3_text)
-
-# Muestra el texto del ejemplo debajo de los botones para que el usuario aprenda el formato
-with st.expander("Ver formato recomendado para los ejemplos"):
-    st.code(f"Ejemplo 1 (Gota):\n{example1_text}", language='text')
-    st.code(f"Ejemplo 2 (Lactosa):\n{example2_text}", language='text')
-    st.code(f"Ejemplo 3 (Vino):\n{example3_text}", language='text')
-
-# Definimos la variable placeholder_text justo antes de usarla en el formulario
-placeholder_text = """Ejemplo:
-SÍNTOMAS: dolor de cabeza, migraña, confusión.
-ALIMENTOS: vino tinto, queso curado.
-"""
-with st.form(key="search_form"):
-    st.text_area(
-        "Describe tu caso aquí, separando SÍNTOMAS y ALIMENTOS:", 
-        height=200, 
-        key="query",
-        placeholder=placeholder_text
-    )
-    submitted = st.form_submit_button("Analizar mi caso", type="primary")
-    if submitted:
-        st.session_state.start_analysis = True
-
-if st.session_state.start_analysis:
-    st.session_state.start_analysis = False
-    query_to_analyze = st.session_state.query
+if st.session_state.search_results:
+    results = st.session_state.search_results
+    best_match = results[0]['entry']
     
-    clear_search_state()
-    st.session_state.user_query = query_to_analyze
+    st.success(f"🔎 Coincidencia Principal: **{best_match.get('condicion_asociada')}**")
     
-    if not query_to_analyze:
-        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.")
-    else:
-        with st.spinner("🧠 Interpretando tu caso y buscando pistas..."):
-            # Paso A: Extracción inicial
-            initial_entities = None
+    # Generación de textos (Bajo demanda o caché)
+    cache_key = f"analysis_{best_match.get('condicion_asociada')}"
+    if cache_key not in st.session_state.analysis_cache:
+        with st.spinner("✍️ Redactando informe clínico..."):
             try:
-                initial_entities = extract_entities_with_gemini(query_to_analyze)
-            except Exception as e:
-                logger.warning(f"La extracción con Gemini falló; se usará el sistema de respaldo: {e}")
-            
-            # Paso B: Refuerzo y normalización con el sistema de respaldo
-            reinforced_entities = reinforce_entities_with_keywords(initial_entities, query_to_analyze, FOOD_TO_COMPOUND_MAP, MASTER_SYMPTOM_MAP)
-            
-            # --- PASO C: TRADUCCIÓN DE SÍNTOMAS CON IA (NUEVA LÓGICA) ---
-            final_symptoms = set(reinforced_entities.get("sintomas", []))
-            untranslated_symptoms = reinforced_entities.get("sintomas_originales_ia", reinforced_entities.get("sintomas", []))
+                analysis = generate_detailed_analysis(st.session_state.user_query, best_match)
+                st.session_state.analysis_cache[cache_key] = analysis
+            except:
+                st.session_state.analysis_cache[cache_key] = "No se pudo generar el análisis detallado."
 
-            if untranslated_symptoms:
-                try:
-                    with st.spinner("🧠 Profundizando en la interpretación de los síntomas..."):
-                        translated_symptoms = translate_symptoms_with_gemini(untranslated_symptoms, MASTER_SYMPTOM_MAP)
-                        final_symptoms.update(translated_symptoms)
-                except Exception as e:
-                    logger.error("La traducción de síntomas con IA falló después de varios intentos.")
-            
-            # Unir todo en la entidad final
-            final_entities = {
-                "alimentos": reinforced_entities.get("alimentos", []),
-                "sintomas": list(final_symptoms)
-            }
-            st.session_state.entities = final_entities
-        
-        if final_entities and (final_entities.get("alimentos") or final_entities.get("sintomas")):
-            info_str = f"Pistas identificadas - Alimentos: {', '.join(final_entities.get('alimentos',[])) or 'Ninguno'}, Síntomas: {', '.join(final_entities.get('sintomas',[])) or 'Ninguno'}"
-            st.info(info_str)
-            with st.spinner("🔬 Cruzando información y calculando relevancia..."):
-                results = find_best_matches_hybrid(final_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 más específico.")
-            st.session_state.search_results = []
-    
-if st.session_state.search_results is not None:
-    results = st.session_state.search_results
+    # --- VISUALIZACIÓN EN PESTAÑAS (MÁS LIMPIO) ---
+    tab_main, tab_neuro, tab_mol = st.tabs(["💡 Interpretación Clínica", "🧠 Efectos Neuropsicológicos", "🔬 Análisis Molecular"])
     
-    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:
-        best_match_data = results[0]
-        best_match = best_match_data['entry']
-        
-        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:
-                    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']
+    with tab_main:
+        st.markdown(st.session_state.analysis_cache[cache_key])
+        st.markdown("---")
+        st.caption("Gráfico de otras posibles causas:")
+        st.altair_chart(create_relevance_chart(results), use_container_width=True)
 
-        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)
+    with tab_neuro:
+        st.info("Este análisis se basa en la interacción conocida entre nutrientes y neurotransmisores.")
+        neuro_text = generate_neuro_report_text(st.session_state.entities, FOOD_TO_COMPOUND_MAP, INTEGRATED_NEURO_FOOD_MAP)
+        st.markdown(neuro_text)
+
+    with tab_mol:
+        st.info("Desglose químico basado en la base de datos FoodB.")
+        mol_text = generate_molecular_report_text(best_match, st.session_state.entities, foodb_index, FOOD_NAME_TO_FOODB_KEY, COMPOUND_SYNONYM_MAP, KNOWN_TRIGGERS_MAP)
+        st.markdown(mol_text)
+
+    # Botón de descarga (Combinando todo)
+    full_report = f"REPORTE CLÍNICO\n\n{st.session_state.analysis_cache[cache_key]}\n\n{neuro_text}\n\n{mol_text}"
+    word_data = generate_word_report(full_report)
+    st.download_button("📄 Descargar Informe Completo (Word)", data=word_data, file_name="Reporte_Detective.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+
+elif submitted:
+    # Creamos un contenedor de advertencia visualmente más claro
+    with st.container(border=True):
+        st.warning("⚠️ No pudimos identificar una causa clara con la información proporcionada.")
         
-        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"
-                )
+        col_help, col_tips = st.columns([1, 2])
         
-        st.subheader("Análisis de Relevancia de las Coincidencias")
-        st.altair_chart(create_relevance_chart(results), use_container_width=True)
-        
-        with st.expander(f"**Análisis Detallado de la Principal Coincidencia: {best_match.get('condicion_asociada')}**", expanded=True):
-            col1_expander, col2_expander = st.columns([3, 1])
-            
-            with col1_expander:
-                st.markdown("##### Desglose de la Puntuación de Relevancia:")
-                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("=", ""))
-
-            st.markdown("---")
-            with st.container(border=True):
-                st.markdown(neuro_report_text.replace("=", ""))
-            
-            st.markdown("---")
-            st.markdown(ai_analysis_text)
+        with col_help:
+            st.markdown("### ¿Qué pudo pasar?")
+            st.markdown("""
+            - **Descripción muy breve:** La IA necesita contexto.
+            - **Sinónimos desconocidos:** Usaste términos muy coloquiales.
+            - **Fallo de conexión:** La IA no respondió a tiempo.
+            """)
         
-        if len(results) > 1:
-            with st.expander("🔍 **Explora otras posibilidades relevantes (Diagnóstico Diferencial)**"):
-                for i, result in enumerate(results[1:5]): 
-                    with st.container(border=True):
-                        entry = result['entry']
-                        st.subheader(f"{i+2}. {entry.get('condicion_asociada')}")
-                        col_info, col_action = st.columns([3, 1])
-                        
-                        with col_info:
-                            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", 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')}"):
-                                with st.spinner(f"Generando análisis para {entry.get('condicion_asociada')}..."):
-                                    try:
-                                        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."
-                        
-                        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("---")
+        with col_tips:
+            st.info("💡 **Intenta reformular tu consulta así:**")
+            st.code("Siento [SÍNTOMA] y [SÍNTOMA] después de comer [ALIMENTO].", language="text")
+            st.markdown("**Ejemplo:** _Me duele mucho la cabeza tipo migraña cada vez que como queso curado y tomo vino tinto._")