Update app.py

app.py

@@ -1,12 +1,13 @@
 # ==============================================================================
-#  API do AetherMap — VERSÃO IMPERIAL 3.0
-#  Backend aprimorado com análises por cluster e dados para gráficos detalhados.
+#  API do AetherMap — VERSÃO SEMÂNTICA 4.0
+#  Backend com busca semântica verdadeira via endpoint /search/
 # ==============================================================================
 
 import numpy as np
 import pandas as pd
 import torch
 import gc
+import uuid
 
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from typing import List, Dict, Any
@@ -21,14 +22,18 @@ from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
 from scipy.stats import entropy
 
 # ==============================================================================
-# CONFIGURAÇÕES GERAIS
+# CONFIGURAÇÕES GERAIS E CACHE
 # ==============================================================================
 DEFAULT_MODEL = "all-MiniLM-L6-v2"
 BATCH_SIZE = 256
 UMAP_N_NEIGHBORS = 30
 HDBSCAN_MIN_SIZE = 50
 
-# Lista de stopwords expandida e mantida
+# <<< NOVA CÂMARA DO TESOURO >>>
+# Guarda os embeddings e textos do último processamento.
+# Em produção real com múltiplos usuários, usaríamos Redis ou um DB vetorial.
+cache: Dict[str, Any] = {}
+
 STOP_WORDS_PT = [
     'de','a','o','que','e','do','da','em','um','para','é','com','não','uma','os','no',
     'se','na','por','mais','as','dos','como','mas','foi','ao','ele','das','tem','à',
@@ -54,8 +59,9 @@ STOP_WORDS_PT = [
     'teremos','terão','teria','teríamos','teriam','dá','pergunta','resposta'
 ]
 
+
 # ==============================================================================
-# MODELO — Carregado uma vez e reaproveitado
+# MODELO E FUNÇÕES DE ANÁLISE (como antes)
 # ==============================================================================
 @lru_cache(maxsize=1)
 def load_model():
@@ -63,114 +69,77 @@ def load_model():
     print(f"[MODEL] Carregando modelo '{DEFAULT_MODEL}' em: {device}")
     return SentenceTransformer(DEFAULT_MODEL, device=device)
 
-# ==============================================================================
-# FUNÇÕES AUXILIARES DE ANÁLISE (Isoladas e reutilizáveis)
-# ==============================================================================
+# ... (Todas as funções de análise: preparar_textos, processar_pipeline, calcular_metricas, etc. permanecem exatamente as mesmas da versão anterior)
 def preparar_textos(file_bytes: bytes, n_samples: int) -> List[str]:
+    # ... (código inalterado)
     linhas = file_bytes.decode("utf-8", errors="ignore").splitlines()
     textos = [s for line in linhas if (s := line.strip()) and len(s.split()) > 3]
     return textos[:n_samples]
 
 def processar_pipeline(textos: List[str]) -> (pd.DataFrame, np.ndarray):
+    # ... (código inalterado)
     print(f"[PIPELINE] Iniciando pipeline para {len(textos)} textos...")
     model = load_model()
     embeddings = model.encode(textos, batch_size=BATCH_SIZE, show_progress_bar=False, convert_to_numpy=True)
-    
     reducer = umap.UMAP(n_components=3, n_neighbors=UMAP_N_NEIGHBORS, min_dist=0.0, metric="cosine", random_state=42)
     emb_3d = reducer.fit_transform(embeddings)
     emb_3d = StandardScaler().fit_transform(emb_3d)
-    
     clusterer = hdbscan.HDBSCAN(min_cluster_size=HDBSCAN_MIN_SIZE)
     clusters = clusterer.fit_predict(emb_3d)
-    
-    df = pd.DataFrame({
-        "x": emb_3d[:, 0], "y": emb_3d[:, 1], "z": emb_3d[:, 2],
-        "full_text": textos, "cluster": clusters.astype(str)
-    })
-    
+    df = pd.DataFrame({"x": emb_3d[:, 0], "y": emb_3d[:, 1], "z": emb_3d[:, 2], "full_text": textos, "cluster": clusters.astype(str)})
     del reducer, clusterer, emb_3d; gc.collect()
     return df, embeddings
 
-# <<< MODIFICAÇÃO >>> Retorna dados para gráficos
 def calcular_metricas(textos: List[str]) -> Dict[str, Any]:
+    # ... (código inalterado)
     print("[METRICAS] Calculando métricas globais...")
     if not textos: return {}
-
     vectorizer_count = CountVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
     vectorizer_tfidf = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=20000)
-    
     try:
         counts_matrix = vectorizer_count.fit_transform(textos)
         tfidf_matrix = vectorizer_tfidf.fit_transform(textos)
-    except ValueError: # Corpus vazio ou só com stopwords
+    except ValueError:
         return {"riqueza_lexical": 0, "top_tfidf_palavras": [], "top_frequencia_palavras": [], "entropia": 0.0}
-
-    # Métricas de Frequência
     vocab_count = vectorizer_count.get_feature_names_out()
     contagens = counts_matrix.sum(axis=0).A1
     top_idx_freq = np.argsort(contagens)[-10:][::-1]
     top_frequencia = [{"palavra": vocab_count[i], "contagem": int(contagens[i])} for i in top_idx_freq]
-
-    # Métricas de TF-IDF
     vocab_tfidf = vectorizer_tfidf.get_feature_names_out()
     soma_tfidf = tfidf_matrix.sum(axis=0).A1
     top_idx_tfidf = np.argsort(soma_tfidf)[-10:][::-1]
     top_tfidf = [{"palavra": vocab_tfidf[i], "score": round(float(soma_tfidf[i]), 4)} for i in top_idx_tfidf]
-    
-    return {
-        "riqueza_lexical": len(vocab_count),
-        "top_tfidf_palavras": top_tfidf,
-        "top_frequencia_palavras": top_frequencia,
-        "entropia": float(entropy(contagens / contagens.sum(), base=2))
-    }
-
-# <<< MODIFICAÇÃO >>> Retorna dados para o histograma
+    return {"riqueza_lexical": len(vocab_count), "top_tfidf_palavras": top_tfidf, "top_frequencia_palavras": top_frequencia, "entropia": float(entropy(contagens / contagens.sum(), base=2))}
+
 def encontrar_duplicados(df: pd.DataFrame, embeddings: np.ndarray) -> Dict[str, Any]:
+    # ... (código inalterado)
     print("[DUPLICADOS] Detectando duplicados...")
-    
     mask = df["full_text"].duplicated(keep=False)
     grupos_exatos = {t: [int(i) for i in idxs] for t, idxs in df[mask].groupby("full_text").groups.items()}
-    
     pares_semanticos = []
     histograma = {"bins": [], "contagens": []}
-    
     if 2 < len(embeddings) < 5000:
         sim = cosine_similarity(embeddings)
         triu_indices = np.triu_indices_from(sim, k=1)
         sim_vetor = sim[triu_indices]
-
-        # Pares para a lista de duplicados
         pares_idx = np.where(sim_vetor > 0.98)[0]
         for i in pares_idx:
             idx1, idx2 = triu_indices[0][i], triu_indices[1][i]
             if df["full_text"].iloc[idx1] != df["full_text"].iloc[idx2]:
-                pares_semanticos.append({
-                    "doc1_idx": int(idx1), "doc2_idx": int(idx2),
-                    "similaridade": float(sim[idx1, idx2]),
-                    "texto1": df["full_text"].iloc[idx1], "texto2": df["full_text"].iloc[idx2],
-                })
-        
-        # Histograma para o gráfico
+                pares_semanticos.append({"doc1_idx": int(idx1), "doc2_idx": int(idx2), "similaridade": float(sim[idx1, idx2]), "texto1": df["full_text"].iloc[idx1], "texto2": df["full_text"].iloc[idx2],})
         contagens, bin_edges = np.histogram(sim_vetor, bins=np.arange(0.8, 1.01, 0.05))
         histograma["bins"] = [f"{b:.2f}-{e:.2f}" for b, e in zip(bin_edges[:-1], bin_edges[1:])]
         histograma["contagens"] = contagens.tolist()
+    return {"grupos_exatos": grupos_exatos, "pares_semanticos": pares_semanticos, "similaridade_histograma": histograma}
 
-    return {
-        "grupos_exatos": grupos_exatos,
-        "pares_semanticos": pares_semanticos,
-        "similaridade_histograma": histograma
-    }
-
-# <<< NOVA FUNÇÃO >>> Cria o brasão de armas de cada cluster
 def analisar_clusters(df: pd.DataFrame) -> Dict[str, Any]:
+    # ... (código inalterado)
     print("[CLUSTERS] Analisando clusters individualmente...")
     analise = {}
     ids_clusters_validos = sorted([c for c in df["cluster"].unique() if c != "-1"], key=int)
-
     for cid in ids_clusters_validos:
         textos_cluster = df[df["cluster"] == cid]["full_text"].tolist()
         if len(textos_cluster) < 2: continue
-        
         try:
             vectorizer = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=1000)
             tfidf_matrix = vectorizer.fit_transform(textos_cluster)
@@ -180,21 +149,18 @@ def analisar_clusters(df: pd.DataFrame) -> Dict[str, Any]:
             top_palavras = [{"palavra": vocab[i], "score": round(float(soma[i]), 4)} for i in top_idx]
         except ValueError:
             top_palavras = []
-        
-        analise[cid] = {
-            "num_documentos": len(textos_cluster),
-            "top_palavras": top_palavras
-        }
+        analise[cid] = {"num_documentos": len(textos_cluster), "top_palavras": top_palavras}
     return analise
 
+
 # ==============================================================================
 # FASTAPI — DEFINIÇÃO DA API
 # ==============================================================================
-app = FastAPI(title="API do AetherMap (Versão Imperial)", version="3.0.0")
+app = FastAPI(title="API do AetherMap (Versão Semântica)", version="4.0.0")
 
 @app.post("/process/")
 async def process_api(n_samples: int = Form(10000), file: UploadFile = File(...)):
-    print(f"[API] Requisição recebida para {file.filename} ({n_samples} amostras).")
+    print(f"[API /process] Requisição recebida para {file.filename}.")
     try:
         file_bytes = await file.read()
         textos = preparar_textos(file_bytes, n_samples)
@@ -202,7 +168,11 @@ async def process_api(n_samples: int = Form(10000), file: UploadFile = File(...)
 
         df, embeddings = processar_pipeline(textos)
         
-        # <<< MODIFICAÇÃO >>> Chamando todas as novas e aprimoradas funções de análise
+        # <<< MODIFICAÇÃO >>> Guardando o resultado na Câmara do Tesouro
+        job_id = str(uuid.uuid4()) # Gera um ID único para esta análise
+        cache[job_id] = {"embeddings": embeddings, "df": df}
+        print(f"[CACHE] Resultados salvos no cache com o ID: {job_id}")
+
         metricas_globais = calcular_metricas(df["full_text"].tolist())
         analise_de_duplicados = encontrar_duplicados(df, embeddings)
         analise_por_cluster = analisar_clusters(df)
@@ -210,26 +180,57 @@ async def process_api(n_samples: int = Form(10000), file: UploadFile = File(...)
         n_clusters = len(df["cluster"].unique()) - (1 if "-1" in df["cluster"].unique() else 0)
         n_ruido = int((df["cluster"] == "-1").sum())
 
-        # <<< MODIFICAÇÃO >>> Montando a resposta imperial, rica em dados
         resposta = {
-            "metadata": {
-                "filename": file.filename,
-                "num_documents_processed": len(df),
-                "n_samples_requested": n_samples,
-                "num_clusters_found": n_clusters,
-                "num_noise_points": n_ruido,
-            },
+            "job_id": job_id, # Enviamos o ID para o frontend
+            "metadata": {"filename": file.filename, "num_documents_processed": len(df), "num_clusters_found": n_clusters, "num_noise_points": n_ruido},
             "metrics": metricas_globais,
             "duplicates": analise_de_duplicados,
-            "cluster_analysis": analise_por_cluster, # NOVO
+            "cluster_analysis": analise_por_cluster,
             "plot_data": df[["x", "y", "z", "cluster", "full_text"]].to_dict("records"),
         }
         
-        print("[API] Processamento finalizado com sucesso.")
+        print("[API /process] Processamento finalizado com sucesso.")
         return resposta
 
     except Exception as e:
         import traceback
-        print("[ERRO] ERRO CRÍTICO NA REQUISIÇÃO:", e)
+        print("[ERRO] ERRO CRÍTICO EM /process:", e)
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {str(e)}")
+
+
+# <<< NOVO FEITIÇO IMPERIAL >>>
+@app.post("/search/")
+async def search_api(query: str = Form(...), job_id: str = Form(...)):
+    print(f"[API /search] Busca recebida para a query '{query}' no job '{job_id}'.")
+    
+    if job_id not in cache:
+        raise HTTPException(status_code=404, detail="Job ID não encontrado ou expirado. Por favor, processe um novo arquivo.")
+
+    try:
+        model = load_model()
+        cached_data = cache[job_id]
+        corpus_embeddings = cached_data["embeddings"]
+        
+        # 1. Cria o embedding da busca
+        query_embedding = model.encode([query], convert_to_numpy=True)
+        
+        # 2. Calcula a similaridade de cosseno
+        similarities = cosine_similarity(query_embedding, corpus_embeddings)[0]
+        
+        # 3. Encontra os top 100 resultados com score acima de um limiar
+        top_indices = np.argsort(similarities)[-100:][::-1]
+        
+        results = [
+            {"index": int(i), "score": float(similarities[i])}
+            for i in top_indices if similarities[i] > 0.3
+        ]
+        
+        print(f"[API /search] Encontrados {len(results)} resultados semanticamente relevantes.")
+        return {"results": results}
+
+    except Exception as e:
+        import traceback
+        print("[ERRO] ERRO CRÍTICO EM /search:", e)
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Erro interno na busca semântica: {str(e)}")