Upload 2 files

app.py

@@ -0,0 +1,342 @@
+# app.py (Versão Híbrida Final com Bi-Encoder e Cross-Encoder)
+import pandas as pd
+from flask import Flask, render_template, request, jsonify
+import os
+import sys
+import traceback
+import subprocess
+# Importa as duas classes de modelos necessárias
+from sentence_transformers import SentenceTransformer, CrossEncoder
+import csv
+from collections import defaultdict
+import datetime
+import re
+from huggingface_hub import InferenceClient, HfApi
+from huggingface_hub.utils import HfHubHTTPError
+import atexit
+import json
+from hashlib import sha1
+
+# --- Variáveis e Constantes de Feedback ---
+USER_FEEDBACK_FILE = 'user_feedback.csv'
+USER_BEST_MATCHES_COUNTS = {}
+USER_FEEDBACK_THRESHOLD = 10
+FEEDBACK_CSV_COLUMNS = ['timestamp', 'query_original', 'query_normalized', 'tuss_code_submitted', 'tuss_code_raw_input', 'tuss_description_associated', 'rol_names_associated', 'feedback_type']
+
+# --- Configuração do Cliente da IA ---
+api_key = os.environ.get("USUARIO_KEY")
+if not api_key:
+    print("--- [AVISO CRÍTICO] Secret 'USUARIO_KEY' não encontrado. As chamadas para a IA irão falhar. ---")
+    client_ia = None
+else:
+    client_ia = InferenceClient(
+        provider="novita",
+        api_key=api_key,
+    )
+    print("--- [SUCESSO] Cliente de Inferência da IA configurado com a chave correta. ---")
+
+# --- SEÇÃO DE PERSISTÊNCIA ---
+HF_TOKEN = os.environ.get("HF_TOKEN") 
+REPO_ID = "tuliodisanto/Buscador_Rol_vs.2_IA"
+
+if not HF_TOKEN:
+    print("--- [AVISO CRÍTICO] Secret 'HF_TOKEN' não encontrado. Os arquivos não serão salvos no repositório. ---")
+    hf_api = None
+else:
+    hf_api = HfApi(token=HF_TOKEN)
+    print(f"--- [SUCESSO] Cliente da API do Hugging Face configurado para o repositório: {REPO_ID}. ---")
+
+DATA_HAS_CHANGED = False
+
+# --- Funções de Feedback ---
+def normalize_text_for_feedback(text):
+    if pd.isna(text): return ""
+    try:
+        from enhanced_search_v2 import normalize_text as es_normalize_text
+        return es_normalize_text(str(text).strip())
+    except ImportError:
+        import unidecode
+        return unidecode.unidecode(str(text).lower().strip())
+
+def load_user_feedback():
+    global USER_BEST_MATCHES_COUNTS
+    USER_BEST_MATCHES_COUNTS = {}
+    feedback_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), USER_FEEDBACK_FILE)
+    if not os.path.exists(feedback_file_path):
+        with open(feedback_file_path, 'w', newline='', encoding='utf-8') as f: csv.writer(f).writerow(FEEDBACK_CSV_COLUMNS)
+        return
+    try:
+        with open(feedback_file_path, 'r', encoding='utf-8') as f:
+            reader = csv.reader(f)
+            try:
+                header = next(reader)
+                if [col.strip() for col in header] != FEEDBACK_CSV_COLUMNS:
+                    print(f"--- [AVISO] Cabeçalho do {USER_FEEDBACK_FILE} incorreto.")
+                    return
+            except StopIteration:
+                return
+
+            for row in reader:
+                if len(row) == len(FEEDBACK_CSV_COLUMNS):
+                    row_dict = dict(zip(FEEDBACK_CSV_COLUMNS, row))
+                    query_norm, tuss_code = row_dict.get('query_normalized', ''), row_dict.get('tuss_code_submitted', '')
+                    if query_norm and tuss_code:
+                        if query_norm not in USER_BEST_MATCHES_COUNTS: USER_BEST_MATCHES_COUNTS[query_norm] = {}
+                        USER_BEST_MATCHES_COUNTS[query_norm][tuss_code] = USER_BEST_MATCHES_COUNTS[query_norm].get(tuss_code, 0) + 1
+        print(f"--- [SUCESSO] Feedback de usuário carregado/sincronizado. ---")
+    except Exception as e: print(f"--- [ERRO] Falha ao carregar feedback: {e} ---"); traceback.print_exc()
+
+# --- Execução de Scripts e Importações ---
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+try:
+    from enhanced_search_v2 import load_and_prepare_database, load_correction_corpus, load_general_dictionary, search_procedure_with_log
+    print("--- [SUCESSO] Módulo 'enhanced_search_v2.py' importado. ---")
+except Exception as e: print(f"--- [ERRO CRÍTICO] Não foi possível importar 'enhanced_search_v2.py': {e} ---"); traceback.print_exc(); sys.exit(1)
+
+app = Flask(__name__)
+
+# --- Carregamento dos Dados e Modelos ---
+# CORREÇÃO 1: Preparar as variáveis para receber todos os 7 valores de load_and_prepare_database
+DF_ORIGINAL, DF_NORMALIZED, FUZZY_CORPUS, BM25_MODEL, DB_WORD_SET, doc_freq, tuss_map = (None, None, None, None, set(), {}, {})
+CORRECTION_CORPUS, NORMALIZED_CORRECTION_CORPUS = [], []
+PORTUGUESE_WORD_SET = set()
+SEMANTIC_MODEL = None      # Bi-Encoder
+CROSS_ENCODER_MODEL = None # Cross-Encoder
+
+try:
+    # Carregamento dos dados
+    db_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'rol_procedures_database.csv')
+    # CORREÇÃO 1 (continuação): Desempacotar os 7 valores retornados pela função
+    DF_ORIGINAL, DF_NORMALIZED, FUZZY_CORPUS, BM25_MODEL, DB_WORD_SET, doc_freq, tuss_map = load_and_prepare_database(db_path)
+    
+    dict_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'Dic.csv')
+    CORRECTION_CORPUS, NORMALIZED_CORRECTION_CORPUS = load_correction_corpus(dict_path, column_name='Termo_Correto')
+    general_dict_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dicionario_ptbr.txt')
+    PORTUGUESE_WORD_SET = load_general_dictionary(general_dict_path)
+    load_user_feedback()
+
+    # Carregamento dos dois modelos semânticos
+    print("\n--- [SETUP] Carregando modelo Bi-Encoder (Etapa 1 de reordenação)... ---")
+    bi_encoder_model_name = 'sentence-transformers/all-MiniLM-L6-v2'
+    SEMANTIC_MODEL = SentenceTransformer(bi_encoder_model_name, device='cpu')
+    print(f"--- [SUCESSO] Modelo Bi-Encoder '{bi_encoder_model_name}' carregado. ---")
+
+    print("\n--- [SETUP] Carregando modelo Cross-Encoder (Etapa 2 de reordenação)... ---")
+    cross_encoder_model_name = 'cross-encoder/ms-marco-MiniLM-L-6-v2'
+    CROSS_ENCODER_MODEL = CrossEncoder(cross_encoder_model_name, device='cpu')
+    print(f"--- [SUCESSO] Modelo Cross-Encoder '{cross_encoder_model_name}' carregado. ---")
+
+except Exception as e:
+    print(f"--- [ERRO CRÍTICO] Falha fatal durante o setup: {e} ---"); traceback.print_exc(); sys.exit(1)
+
+# --- Rotas da Aplicação ---
+@app.route('/')
+def index(): return render_template('index.html')
+
+@app.route('/favicon.ico')
+def favicon(): return '', 204
+
+@app.route('/search', methods=['POST'])
+def search():
+    try:
+        data = request.get_json()
+        query = data.get('query', '').strip()
+        
+        # CORREÇÃO 2: Reordenar os argumentos da função. Todos os posicionais primeiro, depois os de palavra-chave.
+        results = search_procedure_with_log(
+            query, 
+            DF_ORIGINAL, 
+            DF_NORMALIZED, 
+            FUZZY_CORPUS,
+            (CORRECTION_CORPUS, NORMALIZED_CORRECTION_CORPUS), 
+            PORTUGUESE_WORD_SET,
+            BM25_MODEL,
+            DB_WORD_SET, 
+            doc_freq,          # <-- Novo argumento posicional
+            tuss_map,          # <-- Novo argumento posicional
+            limit_per_layer=10, 
+            semantic_model=SEMANTIC_MODEL,
+            cross_encoder_model=CROSS_ENCODER_MODEL,
+            user_best_matches_counts=USER_BEST_MATCHES_COUNTS, 
+            user_feedback_threshold=USER_FEEDBACK_THRESHOLD
+        )
+        return jsonify(results)
+    except Exception as e:
+        print("--- [ERRO FATAL DURANTE A BUSCA] ---"); traceback.print_exc()
+        return jsonify({"error": "Ocorreu um erro interno no motor de busca."}), 500
+
+@app.route('/submit_feedback', methods=['POST'])
+def submit_feedback_route():
+    global DATA_HAS_CHANGED
+    try:
+        data = request.get_json()
+        query, tuss_code_submitted = data.get('query'), data.get('tuss_code')
+        if not query or not tuss_code_submitted: 
+            return jsonify({"status": "error", "message": "Dados incompletos."}), 400
+        
+        file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), USER_FEEDBACK_FILE)
+        with open(file_path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            query_normalized = normalize_text_for_feedback(query)
+            
+            tuss_descriptions, rol_names = [], []
+            if DF_ORIGINAL is not None:
+                matching_rows = DF_ORIGINAL[DF_ORIGINAL['Codigo_TUSS'].astype(str) == tuss_code_submitted]
+                if not matching_rows.empty:
+                    tuss_descriptions = matching_rows['Descricao_TUSS'].unique().tolist()
+                    rol_names = matching_rows['Procedimento_Rol'].unique().tolist()
+            tuss_desc_assoc = " | ".join(filter(None, tuss_descriptions)) or 'Não encontrado'
+            rol_names_assoc = " | ".join(filter(None, rol_names)) or 'Não encontrado'
+            
+            writer.writerow([datetime.datetime.now().isoformat(), query, query_normalized, tuss_code_submitted, '', tuss_desc_assoc, rol_names_assoc, 'confirm_result'])
+        
+        DATA_HAS_CHANGED = True
+        print(f"--- [DADOS] '{USER_FEEDBACK_FILE}' foi modificado. Commit agendado para o desligamento. ---")
+
+        load_user_feedback()
+
+        return jsonify({"status": "success", "message": "Feedback recebido!"}), 200
+    except Exception as e: 
+        print("--- [ERRO NO SUBMIT_FEEDBACK] ---"); traceback.print_exc();
+        return jsonify({"status": "error", "message": "Erro interno."}), 500
+
+@app.route('/get_tuss_info', methods=['GET'])
+def get_tuss_info():
+    tuss_code_prefix = request.args.get('tuss_prefix', '').strip()
+    if not tuss_code_prefix: return jsonify([])
+    suggestions = []
+    if DF_ORIGINAL is not None and not DF_ORIGINAL.empty:
+        filtered_df = DF_ORIGINAL[DF_ORIGINAL['Codigo_TUSS'].astype(str).str.startswith(tuss_code_prefix)]
+        tuss_grouped = filtered_df.groupby('Codigo_TUSS').agg(tuss_descriptions=('Descricao_TUSS', lambda x: list(x.unique())), rol_names=('Procedimento_Rol', lambda x: list(x.unique()))).reset_index()
+        for index, row in tuss_grouped.head(10).iterrows():
+            tuss_desc = " | ".join(filter(None, row['tuss_descriptions'])) or 'Sem descrição TUSS'
+            rol_name = " | ".join(filter(None, row['rol_names'])) or 'Sem procedimento Rol'
+            suggestions.append({'tuss_code': str(row['Codigo_TUSS']), 'tuss_description': tuss_desc, 'rol_name': rol_name})
+    return jsonify(suggestions)
+
+
+@app.route('/get_ai_suggestion', methods=['POST'])
+def get_ai_suggestion():
+    if not client_ia:
+        return jsonify({"error": "O serviço de IA não está configurado no servidor."}), 503
+
+    try:
+        data = request.get_json()
+        query = data.get('query')
+        results = data.get('results', [])
+
+        if not query or not results:
+            return jsonify({"error": "A consulta e os resultados são necessários."}), 400
+
+        RELEVANT_KEYS_FOR_AI = [
+            'Codigo_TUSS', 'Descricao_TUSS', 'Procedimento_Rol',
+            'CAPITULO', 'GRUPO', 'SUBGRUPO', 'Semantico',
+            'Sinonimo_1', 'Sinonimo_2'
+        ]
+        simplified_results = []
+        for r in results:
+            procedimento_rol_str = str(r.get('Procedimento_Rol', ''))
+            unique_id = f"{r.get('Codigo_TUSS')}_{sha1(procedimento_rol_str.encode('utf-8')).hexdigest()[:8]}"
+            pruned_result = {
+                'unique_id': unique_id,
+                **{key: r.get(key) for key in RELEVANT_KEYS_FOR_AI 
+                   if r.get(key) and pd.notna(r.get(key)) and str(r.get(key)).strip() not in ['---', '']}
+            }
+            if 'Codigo_TUSS' in pruned_result:
+                simplified_results.append(pruned_result)
+        formatted_results_str = json.dumps(simplified_results, indent=2, ensure_ascii=False)
+        system_prompt = (
+            "Você é um especialista em terminologia de procedimentos médicos do Brasil (Tabela TUSS e Rol da ANS). "
+            "Sua tarefa é analisar uma lista de procedimentos e escolher os 3 que melhor correspondem à consulta do usuário, em ordem de relevância."
+        )
+        user_prompt = (
+            f"Consulta do usuário: \"{query}\"\n\n"
+            f"### Resultados da Busca para Análise (JSON):\n{formatted_results_str}\n\n"
+            "### Sua Tarefa:\n"
+            "1.  **Pense em voz alta:** Dentro de uma tag `<thought>`, explique seu processo de raciocínio passo a passo. Analise a consulta e compare os resultados, justificando por que um é mais relevante que o outro com base em seu `Procedimento_Rol` e outros campos.\n"
+            "2.  **Forneça a resposta final:** Após a tag `<thought>`, seu único resultado deve ser um bloco de código JSON. Este JSON **DEVE** conter uma chave `suggested_ids` com uma lista de **EXATAMENTE 3 strings** do campo `unique_id` que você selecionou, ordenadas da mais para a menos relevante.\n\n"
+            "**EXEMPLO DE RESPOSTA OBRIGATÓRIA:**\n"
+            "<thought>\n"
+            "O Raciocínio da IA fica aqui...\n"
+            "</thought>\n"
+            "```json\n"
+            "{\n"
+            '  "suggested_ids": ["30602122_abc12345", "30602360_def67890", "30602033_ghi11223"]\n'
+            "}\n"
+            "```"
+        )
+        
+        completion = client_ia.chat.completions.create(
+            model="baidu/ERNIE-4.5-21B-A3B-PT",
+            messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}],
+            max_tokens=1500, temperature=0.1
+        )
+        raw_response = completion.choices[0].message.content.strip()
+
+        thought_process = "Não foi possível extrair o raciocínio da resposta da IA."
+        json_part = None
+
+        if "<thought>" in raw_response and "</thought>" in raw_response:
+            start = raw_response.find("<thought>") + len("<thought>")
+            end = raw_response.find("</thought>")
+            thought_process = raw_response[start:end].strip()
+
+        if "```json" in raw_response:
+            start = raw_response.find("```json") + len("```json")
+            end = raw_response.rfind("```")
+            json_str = raw_response[start:end].strip()
+            try:
+                json_part = json.loads(json_str)
+            except json.JSONDecodeError: pass
+        
+        if not json_part or "suggested_ids" not in json_part or not isinstance(json_part.get("suggested_ids"), list) or len(json_part["suggested_ids"]) == 0:
+            return jsonify({
+                "error": "A IA não retornou a lista de 'suggested_ids' no formato JSON esperado.",
+                "details": raw_response
+            }), 422
+        
+        response_data = {
+            "suggested_ids": json_part["suggested_ids"][:3],
+            "thought_process": thought_process,
+            "query": query,
+            "results": simplified_results
+        }
+        return jsonify(response_data)
+
+    except Exception as e:
+        print("--- [ERRO FATAL NA SUGESTÃO DA IA] ---"); traceback.print_exc()
+        return jsonify({"error": f"Ocorreu um erro interno na IA: {str(e)}"}), 500
+
+
+# --- SEÇÃO DE PERSISTÊNCIA ---
+def commit_file_to_repo(local_file_name, commit_message):
+    if not hf_api:
+        print(f"--- [AVISO] API do HF não configurada. Pular o commit de '{local_file_name}'. ---")
+        return
+    local_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), local_file_name)
+    if not os.path.exists(local_file_path) or os.path.getsize(local_file_path) == 0:
+        print(f"--- [AVISO] Arquivo '{local_file_name}' não existe ou está vazio. Pular commit. ---")
+        return
+    path_in_repo = local_file_name
+    try:
+        print(f"--- [API HF] Tentando fazer o commit de '{local_file_name}' para o repositório... ---")
+        hf_api.upload_file(
+            path_or_fileobj=local_file_path, path_in_repo=path_in_repo,
+            repo_id=REPO_ID, repo_type="space", commit_message=commit_message)
+        print(f"--- [API HF] Sucesso no commit de '{local_file_name}'. ---")
+    except Exception as e:
+        print(f"--- [ERRO API HF] Falha no commit de '{local_file_name}': {e} ---")
+
+def save_data_on_exit():
+    print("--- [SHUTDOWN] O aplicativo está desligando. Verificando dados para salvar... ---")
+    if DATA_HAS_CHANGED:
+        print("--- [SHUTDOWN] Mudanças detectadas. Fazendo o commit dos arquivos para o repositório. ---")
+        commit_file_to_repo(USER_FEEDBACK_FILE, "Commit automático: Atualiza feedbacks de usuários.")
+    else:
+        print("--- [SHUTDOWN] Nenhuma mudança nos dados detectada. Nenhum commit necessário. ---")
+
+atexit.register(save_data_on_exit)
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host='0.0.0.0', port=port, debug=False)

enhanced_search_v2.py

@@ -0,0 +1,379 @@
+# enhanced_search_v2.py (Versão Final Comentada e Corrigida)
+###################################################################################################
+#
+# Este arquivo contém o motor de busca principal. Ele implementa uma estratégia de busca em
+# múltiplas camadas, começando pelas buscas de mais alta confiança (exatas) e progredindo
+# para métodos mais abrangentes (relevância de termos, semântica).
+#
+# A ordenação final é o ponto mais sofisticado, usando uma hierarquia de critérios para
+# garantir os resultados mais relevantes no topo:
+#   1. Prioridade Máxima: Feedback explícito do usuário.
+#   2. Ordenação Primária: Score Semântico (a compreensão da IA sobre o contexto).
+#   3. Desempate 1: Score de Texto (quão bem as palavras correspondem).
+#   4. Desempate 2: Cobertura do Rol (procedimentos do Rol têm preferência).
+#
+# A desduplicação é feita pelo índice da linha da planilha, garantindo que cada indicação
+# única (DUT) seja tratada como um resultado distinto.
+#
+###################################################################################################
+
+import pandas as pd
+import re
+from thefuzz import process, fuzz
+from unidecode import unidecode
+import time
+from sentence_transformers import util
+import torch
+import math
+from collections import defaultdict
+from rank_bm25 import BM25Okapi
+
+# --- FUNÇÕES AUXILIARES DE NORMALIZAÇÃO --- #
+
+def literal_normalize_text(text):
+    """
+    Normalização "agressiva" para a Camada 0. Remove tudo exceto letras e números,
+    ideal para encontrar correspondências literais exatas, ignorando qualquer formatação.
+    """
+    if pd.isna(text): return ""
+    normalized = unidecode(str(text).lower())
+    normalized = re.sub(r'[^\w\s]', ' ', normalized)
+    return re.sub(r'\s+', ' ', normalized).strip()
+
+def normalize_text(text):
+    """
+    Normalização padrão: remove acentos e converte para minúsculas. Usado em quase todas as buscas.
+    """
+    if pd.isna(text): return ""
+    return unidecode(str(text).lower().strip())
+
+def get_longest_word(query_text):
+    """Função de último recurso (fallback): extrai a palavra mais longa para tentar encontrar algo."""
+    words = re.findall(r'\b\w{4,}\b', query_text)
+    if not words: return ""
+    return max(words, key=len)
+
+
+# --- FUNÇÕES DE FORMATAÇÃO E DESTAQUE --- #
+
+def format_result(row_data, row_index, match_type="", score=0):
+    """
+    Formata uma linha do DataFrame em um dicionário de resultado padrão,
+    incluindo o índice da linha como identificador único.
+    """
+    data = row_data.copy()
+    is_rol = data.get('Correlacao_Rol', '').strip().lower() == 'sim'
+
+    if not is_rol:
+        data['Grupo'], data['Subgrupo'], data['Vigencia'], data['Resolucao_Normativa'] = '', '', '', ''
+        data['PAC'], data['DUT'] = '---', '---'
+    else:
+        data['PAC'] = 'Sim' if data.get('PAC', '').strip().lower() == 'pac' else 'Não'
+        original_dut_value = data.get('DUT', '').strip()
+        if original_dut_value and original_dut_value.replace('.', '', 1).isdigit():
+            data['DUT'] = f'Sim, DUT nº {original_dut_value}'
+        else: data['DUT'] = 'Não'
+
+    standard_columns = [
+        'Codigo_TUSS', 'Descricao_TUSS', 'Correlacao_Rol', 'Procedimento_Rol',
+        'Resolucao_Normativa', 'Vigencia', 'OD', 'AMB', 'HCO', 'HSO', 'PAC',
+        'DUT', 'SUBGRUPO', 'GRUPO', 'CAPITULO', 'Sinonimo_1', 'Sinonimo_2',
+        'Sinonimo_3', 'Sinonimo_4', 'Semantico'
+    ]
+    formatted_data = {col: data.get(col, '') for col in standard_columns}
+    
+    result = {
+        "row_index": row_index,
+        "score": round(score),
+        "text_score": round(score),
+        "semantic_score": 0,
+        "match_type": match_type,
+        "is_rol_procedure": is_rol
+    }
+    result.update(formatted_data)
+    return result
+
+def _highlight_matches(results, query):
+    """Adiciona tags <b></b> para destacar os termos da busca na interface do usuário."""
+    if not query or not results: return results
+    stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}
+    query_words = {word for word in normalize_text(query).split() if len(word) > 2 and word not in stopwords}
+    cols_to_highlight = ['Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico']
+    for result in results:
+        for col in cols_to_highlight:
+            original_text = result.get(col, '')
+            if original_text and query_words:
+                highlighted_text = original_text
+                for word in sorted(list(query_words), key=len, reverse=True):
+                    pattern = r'\b(' + re.escape(word) + r')\b'
+                    highlighted_text = re.sub(pattern, r'<b>\1</b>', highlighted_text, flags=re.IGNORECASE)
+                result[f"{col}_highlighted"] = highlighted_text
+            else:
+                result[f"{col}_highlighted"] = original_text
+    return results
+
+
+# --- FUNÇÕES DE CARREGAMENTO DE DADOS --- #
+
+def load_and_prepare_database(db_path):
+    """
+    Carrega a planilha principal e pré-processa todos os dados necessários para a busca ser rápida.
+    Esta função é executada apenas uma vez, quando o aplicativo inicia.
+    """
+    try:
+        print(f"Carregando e preparando a base de dados de: {db_path}...")
+        df_original = pd.read_csv(db_path, dtype=str).fillna('')
+        search_cols = ['Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico', 'SUBGRUPO', 'GRUPO', 'CAPITULO']
+        df_normalized = df_original.copy()
+        df_normalized['Codigo_TUSS_literal'] = df_normalized['Codigo_TUSS'].apply(literal_normalize_text)
+        df_normalized['Codigo_TUSS_norm'] = df_normalized['Codigo_TUSS'].apply(normalize_text)
+        df_normalized['full_text_norm'] = ""
+        for col in search_cols:
+            if col in df_normalized.columns:
+                df_normalized[f'{col}_literal'] = df_normalized[col].apply(literal_normalize_text)
+                df_normalized[f'{col}_norm'] = df_normalized[col].apply(normalize_text)
+                df_normalized['full_text_norm'] += ' ' + df_normalized[f'{col}_norm']
+        print("Criando dicionário da base, modelo BM25 e frequência de palavras...")
+        db_word_set = set(); tokenized_corpus = []
+        for text in df_normalized['full_text_norm']:
+            words = text.split(); tokenized_corpus.append(words); db_word_set.update(words)
+        db_word_set.discard('')
+        bm25_model = BM25Okapi(tokenized_corpus)
+        doc_freq = defaultdict(int)
+        for doc_words in tokenized_corpus:
+            for word in set(doc_words): doc_freq[word] += 1
+        tuss_to_full_text_map = df_normalized.set_index('Codigo_TUSS')['full_text_norm'].to_dict()
+        print("Criando corpus para busca fuzzy...")
+        fuzzy_search_corpus = []
+        for index, row in df_normalized.iterrows():
+            for col in ['Descricao_TUSS', 'Procedimento_Rol', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico']:
+                if col in df_original.columns and f'{col}_norm' in row and pd.notna(row[f'{col}_norm']):
+                    val = row[f'{col}_norm']
+                    if val: fuzzy_search_corpus.append((val, index, f'{col}_norm'))
+        print(f"Base de dados pronta com {len(df_original)} procedimentos.")
+        return df_original, df_normalized, fuzzy_search_corpus, bm25_model, db_word_set, doc_freq, tuss_to_full_text_map
+    except Exception as e: print(f"Erro crítico ao carregar/preparar a base de dados: {e}"); raise
+
+def load_general_dictionary(path):
+    try:
+        with open(path, 'r', encoding='utf-8') as f: words = {normalize_text(line.strip()) for line in f if line.strip()}
+        return words
+    except (FileNotFoundError, Exception): return set()
+
+def load_correction_corpus(dict_path, column_name='Termo_Correto'):
+    try:
+        df_dict = pd.read_csv(dict_path, dtype=str).fillna('')
+        if column_name not in df_dict.columns: return [], []
+        original_corpus = df_dict[column_name].dropna().astype(str).tolist()
+        normalized_corpus = [normalize_text(term) for term in original_corpus]
+        return original_corpus, normalized_corpus
+    except (FileNotFoundError, Exception): return [], []
+
+
+# --- FUNÇÕES DE RECLASSIFICAÇÃO SEMÂNTICA (IA) --- #
+
+def create_unified_document_text(result_dict):
+    """Cria uma string de texto única para a análise da IA."""
+    text_parts = {
+        result_dict.get('Descricao_TUSS', ''), result_dict.get('Procedimento_Rol', ''),
+        result_dict.get('Semantico', ''), result_dict.get('SUBGRUPO', ''),
+        result_dict.get('GRUPO', ''), result_dict.get('CAPITULO', '')
+    }
+    for i in range(1, 5): text_parts.add(result_dict.get(f'Sinonimo_{i}', ''))
+    return ". ".join(sorted([part for part in text_parts if part and str(part).strip()]))
+
+def rerank_with_cross_encoder(query, results_list, model):
+    """
+    Reclassifica os resultados usando o Cross-Encoder e aplica a lógica de ordenação hierárquica.
+    """
+    if not model or not results_list or not query: return results_list, "Cross-Encoder não fornecido ou lista de candidatos vazia."
+    sentence_pairs = [[query, create_unified_document_text(result)] for result in results_list]
+    if not sentence_pairs: return results_list, "Não foram encontrados pares para reordenar."
+
+    try:
+        raw_scores = model.predict(sentence_pairs, show_progress_bar=False)
+        semantic_scores_normalized = torch.sigmoid(torch.tensor(raw_scores)).numpy() * 100
+        for i, result in enumerate(results_list):
+            # A CORREÇÃO: Apenas o 'semantic_score' é preenchido.
+            # O 'score' e o 'text_score' originais são mantidos intactos.
+            result['semantic_score'] = round(semantic_scores_normalized[i])
+            result['match_type'] = "Relevância Semântica (IA)"
+        
+        key_function = lambda x: (x.get('semantic_score', 0), x.get('text_score', 0), x.get('is_rol_procedure', False))
+        reranked_results = sorted(results_list, key=key_function, reverse=True)
+        
+        log_message = "Reordenação final por: 1º Semântica, 2º Texto, 3º Cobertura do Rol."
+        return reranked_results, log_message
+    
+    except Exception as e:
+        log_message = f"Erro no Cross-Encoder: {e}"; print(log_message)
+        return results_list, log_message
+
+
+# --- FUNÇÃO INTERNA DE BUSCA COM CAMADAS --- #
+
+def _run_search_layers(literal_query, normalized_query, response, df_original, df_normalized, fuzzy_search_corpus, bm25_model, limit_per_layer):
+    """
+    Executa a busca em múltiplas camadas, da mais precisa para a mais abrangente.
+    """
+    matched_indices = set()
+    stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}
+    query_words = [word for word in normalized_query.split() if word not in stopwords and len(word) > 1]
+    
+    def sort_key(x):
+        return (x.get('score', 0), x.get('is_rol_procedure', False))
+
+    for layer in ["literal_matches", "exact_matches", "logical_matches", "almost_exact_matches", "term_matches", "keyword_matches"]:
+        response["results_by_layer"][layer] = []
+
+    # CAMADA 0: Busca Literal Exata
+    temp_results = []
+    if literal_query:
+        for col in ['Codigo_TUSS_literal', 'Descricao_TUSS_literal', 'Procedimento_Rol_literal']:
+            if col in df_normalized.columns:
+                for index, _ in df_normalized[df_normalized[col] == literal_query].iterrows():
+                    if index not in matched_indices: temp_results.append(format_result(df_original.loc[index], index, "Texto Exato", 100)); matched_indices.add(index)
+    response["results_by_layer"]["literal_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer]
+
+    # CAMADA 1: Busca Normalizada Exata
+    temp_results = []
+    if normalized_query:
+        for index, _ in df_normalized[df_normalized['Codigo_TUSS_norm'] == normalized_query].iterrows():
+            if index not in matched_indices: temp_results.append(format_result(df_original.loc[index], index, "Código Exato", 100)); matched_indices.add(index)
+        for col in ['Descricao_TUSS_norm', 'Procedimento_Rol_norm']:
+            if col in df_normalized.columns:
+                for index, _ in df_normalized[df_normalized[col] == normalized_query].iterrows():
+                    if index not in matched_indices: temp_results.append(format_result(df_original.loc[index], index, "Exato (Normalizado)", 100)); matched_indices.add(index)
+    response["results_by_layer"]["exact_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer]
+
+    # CAMADA 2: Busca Lógica (E)
+    temp_results = []
+    if query_words:
+        mask = pd.Series(True, index=df_normalized.index)
+        for word in query_words: mask &= df_normalized['full_text_norm'].str.contains(r'\b' + re.escape(word) + r'\b', na=False)
+        for index, row in df_normalized[mask & ~df_normalized.index.isin(matched_indices)].iterrows():
+            score = fuzz.WRatio(normalized_query, row.get('full_text_norm', '')); temp_results.append(format_result(df_original.loc[index], index, "Busca Lógica", score)); matched_indices.add(index)
+    response["results_by_layer"]["logical_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer]
+
+    # CAMADA 3: Busca por Aproximação (Fuzzy)
+    temp_results, processed_indices = [], set()
+    if fuzzy_search_corpus:
+        for match_text, score in process.extractBests(normalized_query, [item[0] for item in fuzzy_search_corpus], scorer=fuzz.token_set_ratio, limit=limit_per_layer * 3, score_cutoff=90):
+            if score == 100 and match_text == normalized_query: continue
+            for _, original_index, _ in [item for item in fuzzy_search_corpus if item[0] == match_text]:
+                if original_index not in matched_indices and original_index not in processed_indices: temp_results.append(format_result(df_original.loc[original_index], original_index, "Busca por Aproximação", 98)); matched_indices.add(original_index); processed_indices.add(original_index)
+    response["results_by_layer"]["almost_exact_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer]
+
+    # CAMADA 4: Busca por Relevância de Termos (BM25)
+    temp_results = []
+    if query_words and bm25_model:
+        doc_scores = bm25_model.get_scores(normalized_query.split()); max_score = max(doc_scores) if any(doc_scores) else 1.0
+        for i, score in enumerate(doc_scores):
+            if score > 0 and (original_index := df_normalized.index[i]) not in matched_indices:
+                normalized_score = (score / max_score) * 90 if max_score > 0 else 0; temp_results.append(format_result(df_original.loc[original_index], original_index, "Relevância de Termos", normalized_score)); matched_indices.add(original_index)
+    response["results_by_layer"]["term_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer * 4]
+    
+    # CAMADA 5: Fallback por Palavra-Chave
+    if sum(len(v) for k, v in response["results_by_layer"].items()) == 0 and normalized_query:
+        if longest_word := get_longest_word(normalized_query):
+            temp_results = []
+            for index, row in df_normalized[df_normalized['full_text_norm'].str.contains(r'\b' + re.escape(longest_word) + r'\b', na=False) & ~df_normalized.index.isin(matched_indices)].iterrows():
+                temp_results.append(format_result(df_original.loc[index], index, f"Palavra-Chave", 80))
+            response["results_by_layer"]["keyword_matches"] = sorted(temp_results, key=sort_key, reverse=True)[:limit_per_layer]
+    return None
+
+
+# --- FUNÇÃO PRINCIPAL QUE ORQUESTRA A BUSCA --- #
+
+def search_procedure_with_log(query, df_original, df_normalized, fuzzy_search_corpus, correction_corpus,
+                              portuguese_word_set, bm25_model, db_word_set, 
+                              doc_freq, tuss_to_full_text_map,
+                              limit_per_layer=10,
+                              semantic_model=None,
+                              cross_encoder_model=None,
+                              user_best_matches_counts=None, user_feedback_threshold=10):
+    RERANK_LIMIT = 50; start_time = time.time(); original_query = str(query).strip()
+    response = {"search_log": [], "results_by_layer": {}, "final_semantic_results": [], "was_corrected": False, "original_query": original_query, "corrected_query": ""}
+    if not original_query: response["search_log"].append("Query vazia."); return response
+    response["search_log"].append(f"Buscando por: '{original_query}'")
+    
+    # ETAPA 1: CORREÇÃO ORTOGRÁFICA
+    stopwords = {'de', 'do', 'da', 'dos', 'das', 'a', 'o', 'e', 'em', 'um', 'uma', 'para', 'com'}; query_after_correction = original_query
+    original_correction_corpus, normalized_correction_corpus = correction_corpus; valid_words = portuguese_word_set.union(db_word_set)
+    if valid_words and original_correction_corpus:
+        words, corrected_words, made_correction = query_after_correction.split(), [], False
+        for word in words:
+            norm_word = normalize_text(word)
+            clean_norm_word = re.sub(r'[^\w]', '', norm_word)
+            if len(norm_word) < 4 or norm_word in stopwords or clean_norm_word in valid_words:
+                corrected_words.append(word); continue
+            
+            match_norm, score = process.extractOne(clean_norm_word, normalized_correction_corpus, scorer=fuzz.token_set_ratio)
+            if score >= 85:
+                corrected_word = original_correction_corpus[normalized_correction_corpus.index(match_norm)]
+                if word.istitle(): corrected_word = corrected_word.title()
+                elif word.isupper(): corrected_word = corrected_word.upper()
+                corrected_words.append(corrected_word); made_correction = True
+            else: corrected_words.append(word)
+        if made_correction: query_after_correction = " ".join(corrected_words); response.update({"was_corrected": True, "corrected_query": query_after_correction}); response["search_log"].append(f"Query corrigida para: '{query_after_correction}'.")
+    
+    # ETAPA 2: PREPARAÇÃO DAS QUERIES
+    cleaned_query = " ".join([word for word in query_after_correction.split() if normalize_text(word) not in stopwords]); normalized_query = normalize_text(cleaned_query)
+    if not cleaned_query.strip(): response["search_log"].append("Query resultante vazia."); return response
+    if cleaned_query != query_after_correction: response["search_log"].append(f"Query limpa (sem stop words): '{cleaned_query}'")
+    
+    # ETAPA 3: EXECUÇÃO DA BUSCA
+    _run_search_layers(literal_normalize_text(query_after_correction), normalized_query, response, df_original, df_normalized, fuzzy_search_corpus, bm25_model, limit_per_layer)
+    
+    # ETAPA 4: AGREGAÇÃO E REORDENAÇÃO HÍBRIDA
+    layer_names_pt = {
+        "literal_matches": "Busca Literal Exata", "exact_matches": "Busca Normalizada Exata",
+        "logical_matches": "Busca Lógica", "almost_exact_matches": "Busca por Aproximação",
+        "term_matches": "Busca por Relevância de Termos", "keyword_matches": "Busca por Palavra-Chave"
+    }
+    response["search_log"].append("\n--- Detalhamento por Camada ---")
+    for key, name in layer_names_pt.items(): response["search_log"].append(f"Camada '{name}': {len(response['results_by_layer'].get(key, []))} candidatos.")
+        
+    all_candidates = []
+    high_confidence_results = response["results_by_layer"].get("literal_matches", []) + response["results_by_layer"].get("exact_matches", [])
+    if high_confidence_results:
+        response["search_log"].append("\n--- [MODO DE ALTA CONFIANÇA] ---"); all_candidates = high_confidence_results
+    else:
+        response["search_log"].append("\n--- [MODO DE BUSCA AMPLA] ---")
+        for key in layer_names_pt.keys():
+            if key not in ["literal_matches", "exact_matches"]: all_candidates.extend(response["results_by_layer"].get(key, []))
+    
+    # Desduplicação por índice de linha para garantir que cada indicação seja única.
+    unique_candidates = list({r['row_index']: r for r in all_candidates}.values())
+    response["search_log"].append(f"Total de candidatos encontrados: {len(all_candidates)}. Candidatos únicos (após desduplicação): {len(unique_candidates)}.")
+    
+    if user_best_matches_counts:
+        query_norm_fb = normalize_text(response.get("corrected_query") or original_query)
+        for r in unique_candidates:
+            votes = user_best_matches_counts.get(query_norm_fb, {}).get(r['Codigo_TUSS'], 0)
+            if votes >= user_feedback_threshold: r.update({'is_user_best_match': True, 'feedback_votes': votes})
+
+    response["search_log"].append(f"\n--- Análise e Reordenação ---")
+    
+    final_list = []
+    if unique_candidates:
+        query_for_semantic = response.get("corrected_query") or cleaned_query
+        
+        prioritized_by_feedback = sorted([r for r in unique_candidates if r.get('is_user_best_match')], key=lambda x: (x.get('feedback_votes', 0), x.get('semantic_score', 0), x.get('text_score', 0)), reverse=True)
+        to_rerank = [r for r in unique_candidates if not r.get('is_user_best_match')]
+        
+        final_list.extend(prioritized_by_feedback)
+        if prioritized_by_feedback: response["search_log"].append(f"{len(prioritized_by_feedback)} resultado(s) priorizado(s) por feedback.")
+        
+        if to_rerank:
+            to_rerank_sorted = sorted(to_rerank, key=lambda x: x.get('text_score', 0), reverse=True)
+            reranked_by_ia, log_msg = rerank_with_cross_encoder(query_for_semantic, to_rerank_sorted[:RERANK_LIMIT], cross_encoder_model)
+            response["search_log"].append(log_msg)
+            final_list.extend(reranked_by_ia)
+
+    response["final_semantic_results"] = _highlight_matches(final_list[:15], query_for_semantic)
+    end_time = time.time(); response["search_duration_seconds"] = round(end_time - start_time, 4)
+    response["search_log"].append(f"Busca completa em {response['search_duration_seconds']} segundos.")
+    print(f"\n\n==================== LOG DE DEPURAÇÃO (QUERY: '{original_query}') ====================")
+    for log_item in response["search_log"]: print(log_item)
+    return response