Upload 2 files

app.py

@@ -0,0 +1,250 @@
+# app.py (Versão FINAL - Corrigido para erro 401 com renomeação de Secret)
+
+import pandas as pd
+from flask import Flask, render_template, request, jsonify
+import os
+import sys
+import traceback
+import subprocess
+from sentence_transformers import SentenceTransformer
+import csv
+from collections import defaultdict
+import datetime
+import re
+from huggingface_hub import InferenceClient
+
+# --- Variáveis e Constantes de Feedback ---
+USER_FEEDBACK_FILE = 'user_feedback.csv'
+USER_BEST_MATCHES_COUNTS = {}
+USER_FEEDBACK_THRESHOLD = 3
+FEEDBACK_CSV_COLUMNS = ['timestamp', 'query_original', 'query_normalized', 'tuss_code_submitted', 'tuss_code_raw_input', 'tuss_description_associated', 'rol_names_associated', 'feedback_type']
+
+# --- INÍCIO DA CORREÇÃO: Lendo o Secret com o nome correto ---
+# Buscamos a chave do Secret que você renomeou para 'NOVITA_API_KEY'
+api_key = os.environ.get("NOVITA_API_KEY")
+if not api_key:
+    print("--- [AVISO CRÍTICO] Secret 'NOVITA_API_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. ---")
+# --- FIM DA CORREÇÃO ---
+
+
+# --- Funções de Feedback (sem alterações) ---
+def normalize_text_for_feedback(text):
+    if pd.isna(text): return ""
+    from enhanced_search_v2 import normalize_text as es_normalize_text
+    return es_normalize_text(str(text).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)
+            header = next(reader)
+            if [col.strip() for col in header] != FEEDBACK_CSV_COLUMNS: raise ValueError("Cabeçalho inválido")
+            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. ---")
+    except Exception as e: print(f"--- [ERRO] Falha ao carregar feedback: {e} ---"); traceback.print_exc()
+
+def append_user_feedback(query_original, tuss_code_submitted, feedback_type, tuss_code_raw_input=''):
+    feedback_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), USER_FEEDBACK_FILE)
+    query_normalized = normalize_text_for_feedback(query_original)
+    tuss_descriptions, rol_names = [], []
+    if DF_ORIGINAL is not None and not DF_ORIGINAL.empty:
+        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'
+    try:
+        with open(feedback_file_path, 'a', newline='', encoding='utf-8') as f:
+            csv.writer(f).writerow([datetime.datetime.now().isoformat(), query_original, query_normalized, tuss_code_submitted, tuss_code_raw_input, tuss_desc_assoc, rol_names_assoc, feedback_type])
+        global USER_BEST_MATCHES_COUNTS
+        if query_normalized not in USER_BEST_MATCHES_COUNTS: USER_BEST_MATCHES_COUNTS[query_normalized] = {}
+        USER_BEST_MATCHES_COUNTS[query_normalized][tuss_code_submitted] = USER_BEST_MATCHES_COUNTS[query_normalized].get(tuss_code_submitted, 0) + 1
+    except Exception as e: print(f"--- [ERRO] Falha ao adicionar feedback: {e} ---"); traceback.print_exc()
+
+# --- Execução de Scripts e Importações (sem alterações) ---
+# ... (código igual ao anterior)
+
+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 ---
+DF_ORIGINAL, DF_NORMALIZED, FUZZY_CORPUS, IDF_SCORES, DB_WORD_SET = (None, None, None, None, set())
+CORRECTION_CORPUS, NORMALIZED_CORRECTION_CORPUS = [], []
+PORTUGUESE_WORD_SET = set()
+SEMANTIC_MODEL = None
+
+try:
+    db_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'rol_procedures_database.csv')
+    DF_ORIGINAL, DF_NORMALIZED, FUZZY_CORPUS, IDF_SCORES, DB_WORD_SET = 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()
+
+    print("\n--- [SETUP] Carregando modelo semântico... ---")
+    model_name = 'sentence-transformers/all-MiniLM-L6-v2'
+    
+    # --- CORREÇÃO: A chamada agora é limpa, sem parâmetros extras. ---
+    # Como não há mais um HF_TOKEN no ambiente, a biblioteca não tentará se autenticar.
+    SEMANTIC_MODEL = SentenceTransformer(model_name, device='cpu')
+    
+    print(f"--- [SUCESSO] Modelo semântico '{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 (O restante do arquivo permanece igual) ---
+@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()
+        
+        results = search_procedure_with_log(
+            query=query,
+            df_original=DF_ORIGINAL,
+            df_normalized=DF_NORMALIZED,
+            fuzzy_search_corpus=FUZZY_CORPUS,
+            correction_corpus=(CORRECTION_CORPUS, NORMALIZED_CORRECTION_CORPUS),
+            portuguese_word_set=PORTUGUESE_WORD_SET,
+            idf_scores=IDF_SCORES,
+            db_word_set=DB_WORD_SET,
+            limit_per_layer=10,
+            semantic_model=SEMANTIC_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():
+    try:
+        data = request.get_json()
+        query, tuss_code_submitted, feedback_type, tuss_code_raw_input = data.get('query'), data.get('tuss_code'), data.get('feedback_type', 'unknown'), data.get('tuss_code_raw_input', '')
+        if not query or not tuss_code_submitted: return jsonify({"status": "error", "message": "Query e TUSS Code são obrigatórios."}), 400
+        append_user_feedback(query, tuss_code_submitted, feedback_type, tuss_code_raw_input)
+        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 (sem chave de API)."}), 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
+
+        formatted_results = []
+        for r in results:
+            tuss_code = r.get('Codigo_TUSS', 'N/A')
+            tuss_desc = r.get('Descricao_TUSS', 'N/A')
+            rol_desc = r.get('Procedimento_Rol', 'N/A')
+            sinonimos = ", ".join(filter(None, [
+                r.get('Sinonimo_1'), r.get('Sinonimo_2'), r.get('Sinonimo_3'), r.get('Sinonimo_4'), r.get('Semantico')
+            ]))
+            formatted_results.append(
+                f"TUSS: {tuss_code}\nDescrição TUSS: {tuss_desc}\nDescrição Rol: {rol_desc}\nContexto/Sinônimos: {sinonimos}\n"
+            )
+
+        results_string = "\n".join(formatted_results)
+        system_prompt = (
+            "Você é um especialista em terminologia médica e na tabela TUSS brasileira. "
+            "Sua tarefa é analisar uma consulta de busca e uma lista de procedimentos médicos retornados por um sistema. "
+            "Você deve escolher o ÚNICO procedimento que melhor corresponde à intenção da consulta. "
+            "Responda APENAS com o código TUSS do procedimento escolhido (ex: 40301741). Não inclua nenhuma outra palavra, explicação ou pontuação."
+        )
+        user_prompt = (
+            f"Consulta do usuário: \"{query}\"\n\n"
+            "Resultados da busca:\n"
+            "----------------------\n"
+            f"{results_string}"
+            "\n----------------------\n\n"
+            "Qual destes é a melhor correspondência para a consulta? Responda apenas com o código TUSS."
+        )
+
+        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=20,
+            temperature=0.1,
+        )
+
+        suggested_content = completion.choices[0].message.content.strip()
+        suggested_tuss = re.sub(r'\D', '', suggested_content)
+
+        if not suggested_tuss:
+            return jsonify({"error": "A IA não conseguiu determinar um melhor resultado.", "details": suggested_content}), 422
+
+        return jsonify({"suggested_tuss_code": suggested_tuss})
+
+    except Exception as e:
+        print("--- [ERRO FATAL NA SUGESTÃO DA IA] ---")
+        traceback.print_exc()
+        error_message = f"Ocorreu um erro interno ao processar a sugestão da IA: {str(e)}"
+        return jsonify({"error": error_message}), 500
+
+
+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,471 @@
+# enhanced_search_v2.py
+# ---------------------
+# Motor de busca híbrido e em camadas para procedimentos médicos.
+# Versão final consolidada com todas as otimizações.
+#
+# Funcionalidades Principais:
+# 1. Correção Ortográfica PRÉ-BUSCA: Corrige termos inválidos ANTES de qualquer busca.
+# 2. Camada 0 para Busca Literal Robusta: Encontra correspondências exatas da frase,
+#    ignorando caixa, acentos, pontuação e espaçamento.
+# 3. Early Exit Otimizado: Interrompe a busca com log claro e correto.
+# 4. Busca em Múltiplas Camadas: Da mais restrita (literal) à mais abrangente (ponderada).
+# 5. Pontuação por Relevância (IDF): Palavras raras têm mais peso.
+# 6. Limpeza de Dados: Zera campos do Rol para procedimentos que não são do Rol.
+# 7. Reordenação Semântica: Usa o MiniLM-L6-v2 para entender o significado e reordenar.
+# 8. Feedback de Usuário: Prioriza resultados validados pela comunidade.
+# 9. Lida com múltiplos procedimentos (linhas do DB) para um mesmo código TUSS.
+
+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
+
+
+# --- FUNÇÕES AUXILIARES DE NORMALIZAÇÃO ---
+
+def literal_normalize_text(text):
+    """
+    Normaliza o texto para busca literal (Camada 0): minúsculas, sem acentos,
+    sem pontuação e com espaços padronizados.
+    """
+    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 texto para busca por tokens (palavras): minúsculas, sem acentos e espaços extras."""
+    if pd.isna(text): return ""
+    return unidecode(str(text).lower().strip())
+
+def get_longest_word(query_text):
+    """Extrai a palavra mais longa de uma query (usado no fallback)."""
+    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 ---
+
+# No arquivo enhanced_search_v2.py
+
+def format_result(row_data, match_type="", score=0):
+    """
+    Formata uma linha do DataFrame em um dicionário de resultado padrão.
+    Aplica a regra de negócio para limpar dados se o procedimento não for do Rol.
+    """
+    data = row_data.copy()
+    if data.get('Correlacao_Rol', '').strip().lower() != 'sim':
+        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'
+        
+        # Lógica da DUT corrigida aqui
+        original_dut_value = data.get('DUT', '').strip()
+        # CORREÇÃO: A verificação agora aceita números com ponto decimal (ex: "65.1")
+        # A lógica é: se o valor, após remover o primeiro '.', for composto apenas de dígitos, é válido.
+        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 = {"score": round(score), "match_type": match_type}
+    result.update(formatted_data)
+    return result
+
+def _highlight_matches(results, query):
+    """Adiciona tags <b></b> em volta das palavras da query nos resultados."""
+    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, '')
+            highlighted_text = original_text
+            if original_text and query_words:
+                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
+    return results
+
+
+# --- FUNÇÕES DE CARREGAMENTO DE DADOS ---
+
+def load_and_prepare_database(db_path):
+    """
+    Carrega o CSV, cria colunas normalizadas, campo de texto único, pesos IDF e um conjunto
+    de todas as palavras únicas da base de dados.
+    """
+    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']
+        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("Calculando pesos IDF e dicionário da base...")
+        num_documents = len(df_normalized)
+        doc_freq = defaultdict(int)
+        db_word_set = set()
+        for text in df_normalized['full_text_norm']:
+            words = set(text.split())
+            db_word_set.update(words)
+            for word in words:
+                if word: doc_freq[word] += 1
+        db_word_set.discard('')
+        print(f"Dicionário da base de dados criado com {len(db_word_set)} palavras únicas.")
+
+        idf_scores = {word: math.log(num_documents / (freq + 1)) for word, freq in doc_freq.items()}
+        print(f"Pesos IDF calculados para {len(idf_scores)} palavras.")
+        
+        print("Criando corpus para busca fuzzy...")
+        fuzzy_search_corpus = []
+        for index, row in df_normalized.iterrows():
+            for col in search_cols:
+                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, idf_scores, db_word_set
+    except Exception as e:
+        print(f"Erro crítico ao carregar/preparar a base de dados: {e}"); raise
+
+def load_general_dictionary(path):
+    try:
+        print(f"Carregando dicionário geral de português de: {path}...")
+        with open(path, 'r', encoding='utf-8') as f:
+            words = {normalize_text(line.strip()) for line in f if line.strip()}
+        print(f"Dicionário geral carregado com {len(words)} palavras.")
+        return words
+    except FileNotFoundError: return set()
+    except Exception as e: return set()
+
+def load_correction_corpus(dict_path, column_name='Termo_Correto'):
+    try:
+        print(f"Carregando corpus de correção de: {dict_path}...")
+        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]
+        
+        print(f"Corpus de correção carregado com {len(original_corpus)} termos.")
+        return original_corpus, normalized_corpus
+    except FileNotFoundError: return [], []
+    except Exception as e: return [], []
+
+
+# --- FUNÇÃO DE RECLASSIFICAÇÃO SEMÂNTICA ---
+
+def rerank_with_semantic_model(original_query, results_list, model):
+    if not model or not results_list: return results_list
+    semantic_columns = ['Descricao_TUSS', 'Procedimento_Rol', 'SUBGRUPO', 'Sinonimo_1', 'Sinonimo_2', 'Sinonimo_3', 'Sinonimo_4', 'Semantico']
+    corpus_texts = [". ".join(sorted(list({res.get(col) for col in semantic_columns if res.get(col) and isinstance(res.get(col), str)}))) for res in results_list]
+    try:
+        query_embedding = model.encode(original_query, convert_to_tensor=True, show_progress_bar=False)
+        corpus_embeddings = model.encode(corpus_texts, convert_to_tensor=True, show_progress_bar=False)
+        cosine_scores = util.cos_sim(query_embedding, corpus_embeddings)
+    except Exception as e: return results_list
+    for i, result in enumerate(results_list):
+        result['semantic_score'] = round(max(0, cosine_scores[0][i].item()) * 100)
+        result['hybrid_score'] = result['semantic_score'] + result.get('score', 0)
+    return sorted(results_list, key=lambda x: (x.get('score', 0) == 100, x.get('hybrid_score', 0)), reverse=True)
+
+
+# --- FUNÇÃO INTERNA DE BUSCA COM CAMADAS ---
+
+def _run_search_layers(literal_query, normalized_query, response, df_original, df_normalized, fuzzy_search_corpus, idf_scores, limit_per_layer):
+    """Executa as camadas de busca e retorna o nome da camada de saída em caso de early exit."""
+    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]
+
+    # --- CAMADA 0: Busca Literal ---
+    if literal_query:
+        temp_results = []
+        literal_cols = ['Codigo_TUSS_literal', 'Descricao_TUSS_literal', 'Procedimento_Rol_literal']
+        for col in literal_cols:
+            if col in df_normalized.columns:
+                mask = df_normalized[col].str.contains(r'\b' + re.escape(literal_query) + r'\b', na=False)
+                matches = df_normalized[mask]
+                for index, _ in matches.iterrows():
+                    if index not in matched_indices:
+                        match_type = "Código Literal" if "Codigo" in col else "Texto Literal"
+                        temp_results.append(format_result(df_original.loc[index], match_type, 100))
+                        matched_indices.add(index)
+        if temp_results:
+            response["results_by_layer"]["literal_matches"] = sorted(temp_results, key=lambda x: x['Codigo_TUSS'])[:limit_per_layer]
+            return "Busca Literal"
+
+    # --- CAMADA 1: Busca Normalizada Exata ---
+    temp_results = []
+    if normalized_query:
+        exact_code_matches = df_normalized[df_normalized['Codigo_TUSS_norm'] == normalized_query]
+        for index, _ in exact_code_matches.iterrows():
+            if index not in matched_indices:
+                temp_results.append(format_result(df_original.loc[index], "Código Exato (Normalizado)", 100))
+                matched_indices.add(index)
+        for col in ['Descricao_TUSS_norm', 'Procedimento_Rol_norm']:
+            if col in df_normalized.columns:
+                exact_text_matches = df_normalized[df_normalized[col] == normalized_query]
+                for index, _ in exact_text_matches.iterrows():
+                    if index not in matched_indices:
+                        temp_results.append(format_result(df_original.loc[index], "Exato (Normalizado)", 100))
+                        matched_indices.add(index)
+    if temp_results:
+        response["results_by_layer"]["exact_matches"] = sorted(temp_results, key=lambda x: x['Codigo_TUSS'])[:limit_per_layer]
+        return "Normalizada Exata"
+
+    # --- 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', ''))
+            if score > 85:
+                temp_results.append(format_result(df_original.loc[index], "Busca Lógica (E)", score))
+                matched_indices.add(index)
+    response["results_by_layer"]["logical_matches"] = sorted(temp_results, key=lambda x: x.get('score', 0), reverse=True)[:limit_per_layer]
+
+    # --- CAMADA 3: Busca 'Quase Exata' (Fuzzy) ---
+    temp_results = []
+    processed_indices_layer3 = set()
+    if fuzzy_search_corpus and normalized_query:
+        almost_exact_matches = 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)
+        for match_text, score in almost_exact_matches:
+            if score == 100 and match_text == normalized_query: continue
+            corpus_items = [item for item in fuzzy_search_corpus if item[0] == match_text]
+            for _, original_index, _ in corpus_items:
+                if original_index not in matched_indices and original_index not in processed_indices_layer3:
+                    temp_results.append(format_result(df_original.loc[original_index], "Quase Exato", 98))
+                    matched_indices.add(original_index)
+                    processed_indices_layer3.add(original_index)
+    response["results_by_layer"]["almost_exact_matches"] = sorted(temp_results, key=lambda x: x['Codigo_TUSS'])[:limit_per_layer]
+
+    # --- CAMADA 4: Busca por Termos Validados ---
+    temp_results = []
+    if query_words:
+        mask_c4 = pd.Series(True, index=df_normalized.index)
+        for word in query_words:
+            mask_c4 &= df_normalized['full_text_norm'].str.contains(r'\b' + re.escape(word) + r'\b', na=False)
+        for index, row in df_normalized[mask_c4 & ~df_normalized.index.isin(matched_indices)].iterrows():
+            score = fuzz.WRatio(normalized_query, row.get('Descricao_TUSS_norm', ''))
+            if score > 75:
+                temp_results.append(format_result(df_original.iloc[index], "Termos Validados (E)", score))
+                matched_indices.add(index)
+    response["results_by_layer"]["contains_matches"] = sorted(temp_results, key=lambda x: x.get('score', 0), reverse=True)[:limit_per_layer]
+
+    # --- CAMADA 5: Busca Ponderada (IDF) ---
+    temp_results = []
+    if query_words and idf_scores:
+        max_idf = max(idf_scores.values()) if idf_scores else 1.0
+        total_query_idf = sum(idf_scores.get(word, max_idf) for word in query_words)
+        regex_pattern = '|'.join(re.escape(word) for word in query_words)
+        mask = df_normalized['full_text_norm'].str.contains(regex_pattern, na=False)
+        candidate_df = df_normalized[mask & ~df_normalized.index.isin(matched_indices)]
+        for index, row in candidate_df.iterrows():
+            weighted_score = sum(idf_scores.get(word, 0) for word in query_words if word in row['full_text_norm'].split())
+            normalized_score = (weighted_score / total_query_idf) * 90 if total_query_idf > 0 else 0
+            if query_words and row.get('full_text_norm', '').strip().startswith(query_words[0]):
+                normalized_score = min(normalized_score + 10, 95)
+            temp_results.append(format_result(df_original.loc[index], "Busca Ponderada (IDF)", normalized_score))
+            matched_indices.add(index)
+    response["results_by_layer"]["term_matches"] = sorted(temp_results, key=lambda x: x.get('score', 0), reverse=True)[:limit_per_layer * 4]
+
+    # --- CAMADA 6: Fallback ---
+    total_found_primary = sum(len(v) for v in response["results_by_layer"].values())
+    if total_found_primary == 0 and normalized_query:
+        temp_results = []
+        longest_word = get_longest_word(normalized_query)
+        if longest_word:
+            mask_c6 = df_normalized['full_text_norm'].str.contains(r'\b' + re.escape(longest_word) + r'\b', na=False)
+            for index, row in df_normalized[mask_c6 & ~df_normalized.index.isin(matched_indices)].iterrows():
+                temp_results.append(format_result(df_original.loc[index], f"Palavra-Chave '{longest_word}'", 80))
+        response["results_by_layer"]["keyword_matches"] = sorted(temp_results, key=lambda x: x['Codigo_TUSS'])[: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, idf_scores, db_word_set,
+                              limit_per_layer=10, semantic_model=None,
+                              user_best_matches_counts=None, user_feedback_threshold=10):
+    SEMANTIC_RERANK_LIMIT = 40
+    start_time = time.time()
+    original_query = str(query).strip()
+
+    response = {"search_log": [],
+                "results_by_layer": {"literal_matches": [], "exact_matches": [], "logical_matches": [],
+                                     "almost_exact_matches": [], "contains_matches": [],
+                                     "term_matches": [], "keyword_matches": []},
+                "final_semantic_results": [], "was_corrected": False, "original_query": original_query,
+                "corrected_query": ""}
+
+    if not original_query:
+        response["search_log"].append("Query vazia, busca não realizada.")
+        return response
+
+    response["search_log"].append(f"Buscando por: '{original_query}'")
+
+    # ETAPA 1: CORREÇÃO ORTOGRÁFICA PRÉ-BUSCA
+    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_from_query, corrected_words, made_correction = original_query.split(), [], False
+        for word in words_from_query:
+            norm_word = normalize_text(word)
+            if norm_word in stopwords or len(norm_word) < 4:
+                corrected_words.append(word)
+                continue
+            
+            if norm_word not in valid_words:
+                match_norm, score = process.extractOne(norm_word, normalized_correction_corpus, scorer=fuzz.token_set_ratio)
+                if score >= 85:
+                    match_index = normalized_correction_corpus.index(match_norm)
+                    corrected_word_original = original_correction_corpus[match_index]
+                    
+                    corrected_word = corrected_word_original
+                    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)
+            else:
+                corrected_words.append(word)
+        if made_correction:
+            query_after_correction = " ".join(corrected_words)
+            response["was_corrected"] = True
+            response["corrected_query"] = query_after_correction
+            response["search_log"].append(f"Query corrigida para: '{query_after_correction}'.")
+
+    # ETAPA 2: PREPARAÇÃO DAS QUERIES PARA AS CAMADAS
+    literal_query = literal_normalize_text(query_after_correction)
+    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() and not literal_query.strip():
+        response["search_log"].append("Query resultante é vazia. Busca não realizada.")
+        return response
+
+    if cleaned_query != query_after_correction:
+         response["search_log"].append(f"Query limpa (sem stop words): '{cleaned_query}'")
+
+    # Para proibir buscas com apenas um caractere
+    if len(cleaned_query.strip()) <= 1:
+        # Pega o termo que seria buscado para exibir no log. Pode ser vazio.
+        term_to_log = cleaned_query.strip()
+        response["search_log"].append(f"Busca por '{term_to_log}' ignorada. A busca deve conter no mínimo 2 caracteres.")
+        response["final_semantic_results"] = []
+        return response
+
+    # ETAPA 3: EXECUÇÃO DA BUSCA
+    exit_layer_name = _run_search_layers(literal_query, normalized_query, response, df_original, df_normalized, fuzzy_search_corpus,
+                                         idf_scores, limit_per_layer)
+
+    # ETAPA 4: AGREGAÇÃO E REORDENAÇÃO DOS RESULTADOS
+    all_candidates = []
+    layer_order = ["literal_matches", "exact_matches", "logical_matches", "almost_exact_matches", "contains_matches", "term_matches", "keyword_matches"]
+    layer_names_map = {"literal_matches": "0. Busca Literal", "exact_matches": "1. Normalizada Exata", "logical_matches": "2. Lógica 'E'",
+                       "almost_exact_matches": "3. Quase Exatos (Fuzzy)", "contains_matches": "4. Termos Validados",
+                       "term_matches": "5. Busca Ponderada (IDF)", "keyword_matches": "6. Fallback (Palavra-Chave)"}
+
+    if exit_layer_name:
+        response["search_log"].append(f"--- [OTIMIZAÇÃO] Resultado de alta confiança encontrado na camada '{exit_layer_name}'. Busca interrompida. ---")
+
+    response["search_log"].append("\n--- Detalhamento da Busca por Camadas ---")
+    for layer_key in layer_order:
+        layer_results = response["results_by_layer"].get(layer_key, [])
+        num_results = len(layer_results)
+        response["search_log"].append(f"[{layer_names_map.get(layer_key, layer_key)}]: {num_results} resultado(s)")
+        all_candidates.extend(layer_results)
+
+    # Lógica de feedback do usuário
+    feedback_prioritized_tuss_votes = {}
+    if user_best_matches_counts and all_candidates:
+        query_norm_for_feedback = normalize_text(response.get("corrected_query") or original_query)
+        feedback_for_query = user_best_matches_counts.get(query_norm_for_feedback, {})
+        for tuss_code, votes in feedback_for_query.items():
+            if votes >= user_feedback_threshold:
+                feedback_prioritized_tuss_votes[tuss_code] = votes
+        if feedback_prioritized_tuss_votes:
+            response["search_log"].append(f"\nFeedback de usuários qualificado encontrado.")
+            for result in all_candidates:
+                if result.get('Codigo_TUSS') in feedback_prioritized_tuss_votes:
+                    result['is_user_best_match'] = True
+                    result['feedback_votes'] = feedback_prioritized_tuss_votes[result.get('Codigo_TUSS')]
+
+    response["search_log"].append(f"\n--- Análise e Reordenação ---\nTotal de candidatos encontrados: {len(all_candidates)}")
+    
+    query_for_highlight = response.get("corrected_query") or cleaned_query
+    all_candidates = _highlight_matches(all_candidates, query_for_highlight)
+    final_list = []
+    
+    if all_candidates:
+        query_for_semantic = response.get("corrected_query") or cleaned_query
+        prioritized_candidates = [res for res in all_candidates if res.get('is_user_best_match')]
+        non_prioritized_candidates = [res for res in all_candidates if not res.get('is_user_best_match')]
+        
+        if semantic_model and prioritized_candidates:
+            reranked_prioritized = rerank_with_semantic_model(query_for_semantic, prioritized_candidates, semantic_model)
+            prioritized_results_sorted = sorted(reranked_prioritized, key=lambda x: (x.get('feedback_votes', 0), x.get('semantic_score', 0)), reverse=True)
+        else:
+            prioritized_results_sorted = sorted(prioritized_candidates, key=lambda x: (x.get('feedback_votes', 0), x.get('score', 0)), reverse=True)
+        final_list.extend(prioritized_results_sorted)
+
+        if semantic_model and non_prioritized_candidates:
+            candidates_for_rerank = non_prioritized_candidates[:SEMANTIC_RERANK_LIMIT]
+            reranked_non_prioritized = rerank_with_semantic_model(query_for_semantic, candidates_for_rerank, semantic_model)
+            final_list.extend(reranked_non_prioritized)
+            seen_reranked_codes = {r.get('Codigo_TUSS') for r in reranked_non_prioritized}
+            for candidate in non_prioritized_candidates:
+                if candidate.get('Codigo_TUSS') not in seen_reranked_codes:
+                    final_list.append(candidate)
+        else:
+            final_list.extend(sorted(non_prioritized_candidates, key=lambda x: x.get('score', 0), reverse=True))
+        
+        response["search_log"].append(f"Lista final de resultados combinada: {len(final_list)} itens antes do limite.")
+        response["final_semantic_results"] = final_list[:10]
+    else:
+        response["search_log"].append("Nenhum resultado final para exibir.")
+        response["final_semantic_results"] = []
+
+    end_time = time.time()
+    response["search_duration_seconds"] = round(end_time - start_time, 4)
+    response["search_log"].append(f"\nBusca completa em {response['search_duration_seconds']} segundos.")
+    print(f"\n\n==================== LOG DE DEPURAÇÃO (QUERY: '{original_query}') ====================")
+    return response