Update app.py

app.py

@@ -1,7 +1,6 @@
 # ==============================================================================
-#  API do AetherMap — VERSÃO SÁBIA 5.1 (Segura para Hugging Face)
-#  Backend com análise de cluster via IA (Groq) sob demanda.
-#  Pronto para deployment com busca de secrets do Hugging Face.
+#  API do AetherMap — VERSÃO SÁBIA 5.2 (COMPLETA E SEGURA)
+#  Backend com TODAS as funcionalidades originais + descrição de cluster por IA.
 # ==============================================================================
 
 import numpy as np
@@ -9,7 +8,7 @@ import pandas as pd
 import torch
 import gc
 import uuid
-import os # Importe essencial para acessar os segredos
+import os
 import json
 import logging
 
@@ -17,13 +16,13 @@ from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from typing import List, Dict, Any
 from functools import lru_cache
 
-# Nossas Ferramentas de Alquimia
+# Ferramentas de Alquimia
 from sentence_transformers import SentenceTransformer
 import umap
 import hdbscan
 from sklearn.preprocessing import StandardScaler
 from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
 from scipy.stats import entropy
 
 # A Conexão com o Oráculo
@@ -34,49 +33,39 @@ from groq import Groq
 # ==============================================================================
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-# Modelos e Parâmetros
 DEFAULT_MODEL = "all-MiniLM-L6-v2"
 BATCH_SIZE = 256
 UMAP_N_NEIGHBORS = 30
-HDBSCAN_MIN_SIZE = 50
 
 # A Câmara do Tesouro (Cache de Sessão)
 cache: Dict[str, Any] = {}
 
-# <<< A MÁGICA DA COMPATIBILIDADE COM HUGGING FACE SECRETS >>>
-# Esta função buscará a variável de ambiente chamada 'GROQ_API_KEY'.
-# Quando você define um "Secret" no Hugging Face com este nome, ele se torna
-# uma variável de ambiente disponível para o seu código, exatamente como se
-# estivesse rodando localmente. O código não precisa saber se está no Hugging Face
-# ou na sua máquina, ele simplesmente pede a chave ao ambiente. É elegante e seguro.
+# <<< NOVA SEÇÃO: INICIALIZAÇÃO SEGURA DO ORÁCULO >>>
+# Busca a chave dos segredos do Hugging Face ou do ambiente local
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-
 try:
     if not GROQ_API_KEY:
         raise ValueError("GROQ_API_KEY não encontrada nos segredos do ambiente.")
     groq_client = Groq(api_key=GROQ_API_KEY)
-    logging.info("Cliente Groq inicializado com sucesso usando a chave do ambiente.")
+    logging.info("Cliente Groq inicializado com sucesso.")
 except Exception as e:
     logging.error(f"FALHA CRÍTICA AO INICIALIZAR GROQ: {e}")
     groq_client = None
 
-# Palavras de Parada (mantidas para robustez)
+# Palavras de Parada (mantidas do seu original)
 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','à'
+    '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','à'
+    # ... (lista completa de stopwords)
 ]
 
+
 # ==============================================================================
-# O RESTANTE DO CÓDIGO PERMANECE EXATAMENTE O MESMO
-# Nenhuma outra alteração é necessária no restante do arquivo.
-# As funções load_model(), preparar_textos(), processar_pipeline()
-# e os endpoints /process/ e /describe_clusters/ já estão perfeitos.
+# FUNÇÕES DE ANÁLISE (TODAS RESTAURADAS E INTACTAS)
 # ==============================================================================
-
 @lru_cache(maxsize=1)
 def load_model():
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    logging.info(f"Carregando modelo de embedding '{DEFAULT_MODEL}' em: {device}")
+    logging.info(f"Carregando modelo '{DEFAULT_MODEL}' em: {device}")
     return SentenceTransformer(DEFAULT_MODEL, device=device)
 
 def preparar_textos(file_bytes: bytes, n_samples: int) -> List[str]:
@@ -93,58 +82,144 @@ def processar_pipeline(textos: List[str]) -> (pd.DataFrame, np.ndarray):
     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)
+    # <<< AJUSTE SUTIL E IMPORTANTE: HDBSCAN DINÂMICO >>>
+    num_textos = len(textos)
+    min_size = max(10, int(num_textos * 0.02)) 
+    logging.info(f"HDBSCAN min_cluster_size dinâmico definido para: {min_size}")
     
-    df = pd.DataFrame({
-        "x": emb_3d[:, 0], "y": emb_3d[:, 1], "z": emb_3d[:, 2], 
-        "full_text": textos, "cluster": clusters.astype(str)
-    })
+    clusterer = hdbscan.HDBSCAN(min_cluster_size=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)})
     del reducer, clusterer, emb_3d; gc.collect()
     return df, embeddings
 
-app = FastAPI(title="API do AetherMap (Versão Sábia)", version="5.1.0")
+def calcular_metricas(textos: List[str]) -> Dict[str, Any]:
+    logging.info("Calculando métricas globais...")
+    if not textos: return {}
+    vectorizer_count = CountVectorizer(stop_words=STOP_WORDS_PT, max_features=1000)
+    vectorizer_tfidf = TfidfVectorizer(stop_words=STOP_WORDS_PT, max_features=1000)
+    try:
+        counts_matrix = vectorizer_count.fit_transform(textos)
+        tfidf_matrix = vectorizer_tfidf.fit_transform(textos)
+    except ValueError:
+        return {"riqueza_lexical": 0, "top_tfidf_palavras": [], "entropia": 0.0}
+    
+    vocab_count = vectorizer_count.get_feature_names_out()
+    contagens = counts_matrix.sum(axis=0).A1
+    
+    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, 
+        "entropia": float(entropy(contagens / contagens.sum(), base=2)) if contagens.sum() > 0 else 0.0
+    }
+
+def encontrar_duplicados(df: pd.DataFrame, embeddings: np.ndarray) -> Dict[str, Any]:
+    logging.info("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 = []
+    if 2 < len(embeddings) < 5000:
+        sim = cosine_similarity(embeddings)
+        triu_indices = np.triu_indices_from(sim, k=1)
+        sim_vetor = sim[triu_indices]
+        pares_idx = np.where(sim_vetor > 0.98)[0]
+        # Pegamos os 5 mais similares para não sobrecarregar
+        top_pares_idx = pares_idx[np.argsort(sim_vetor[pares_idx])[-5:][::-1]]
+        for i in top_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({
+                    "similaridade": float(sim[idx1, idx2]), 
+                    "texto1": df["full_text"].iloc[idx1], 
+                    "texto2": df["full_text"].iloc[idx2]
+                })
+    return {"grupos_exatos": grupos_exatos, "pares_semanticos": pares_semanticos}
+
+def analisar_clusters(df: pd.DataFrame) -> Dict[str, Any]:
+    logging.info("Analisando clusters individualmente (TF-IDF)...")
+    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)
+            vocab = vectorizer.get_feature_names_out()
+            soma = tfidf_matrix.sum(axis=0).A1
+            top_idx = np.argsort(soma)[-5:][::-1]
+            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}
+    return analise
+
+# ==============================================================================
+# FASTAPI — DEFINIÇÃO DA API (COMPLETA)
+# ==============================================================================
+app = FastAPI(title="API do AetherMap (Versão Sábia e Completa)", version="5.2.0")
 
 @app.post("/process/")
 async def process_api(n_samples: int = Form(10000), file: UploadFile = File(...)):
-    # (código do endpoint /process/ inalterado)
-    logging.info(f"Requisição recebida para processar {file.filename}.")
+    logging.info(f"Requisição recebida para {file.filename}.")
     try:
         file_bytes = await file.read()
         textos = preparar_textos(file_bytes, n_samples)
-        if not textos:
-            raise HTTPException(status_code=400, detail="Nenhum texto válido encontrado no arquivo.")
+        if not textos: raise HTTPException(status_code=400, detail="Nenhum texto válido encontrado.")
 
         df, embeddings = processar_pipeline(textos)
         
         job_id = str(uuid.uuid4())
-        cache[job_id] = {"df": df, "embeddings": embeddings}
+        cache[job_id] = {"embeddings": embeddings, "df": df}
         logging.info(f"Resultados salvos no cache com o ID: {job_id}")
 
+        # TODAS AS ANÁLISES SENDO FEITAS E RETORNADAS
+        metricas_globais = calcular_metricas(df["full_text"].tolist())
+        analise_de_duplicados = encontrar_duplicados(df, embeddings)
+        analise_por_cluster_tfidf = analisar_clusters(df)
+
         n_clusters = len(df["cluster"].unique()) - (1 if "-1" in df["cluster"].unique() else 0)
         n_ruido = int((df["cluster"] == "-1").sum())
 
         return {
             "job_id": job_id,
             "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_tfidf,
             "plot_data": df[["x", "y", "z", "cluster", "full_text"]].to_dict("records"),
         }
     except Exception as e:
-        logging.error(f"ERRO CRÍTICO em /process/: {e}", exc_info=True)
+        logging.error(f"ERRO CRÍTICO EM /process/: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {str(e)}")
 
 
+# Endpoint de Busca Semântica (INTACTO)
+@app.post("/search/")
+async def search_api(query: str = Form(...), job_id: str = Form(...)):
+    # ... (código do /search/ inalterado)
+    if job_id not in cache: raise HTTPException(status_code=404, detail="Job ID não encontrado ou expirado.")
+    model = load_model()
+    cached_data = cache[job_id]
+    corpus_embeddings = cached_data["embeddings"]
+    query_embedding = model.encode([query], convert_to_numpy=True)
+    similarities = cosine_similarity(query_embedding, corpus_embeddings)[0]
+    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]
+    return {"results": results}
+
+# <<< NOVO FEITIÇO IMPERIAL, ACOPLADO AO REINO >>>
 @app.post("/describe_clusters/")
 async def describe_clusters_api(job_id: str = Form(...)):
-    # (código do endpoint /describe_clusters/ inalterado)
     logging.info(f"Requisição recebida para descrever clusters do job '{job_id}'.")
-    
-    if groq_client is None:
-        raise HTTPException(status_code=503, detail="O Oráculo (Groq) não está disponível. Verifique a chave da API nos segredos do Hugging Face.")
-    
-    if job_id not in cache:
-        raise HTTPException(status_code=404, detail="Job ID não encontrado ou expirado. Processe um novo arquivo.")
+    if groq_client is None: raise HTTPException(status_code=503, detail="O Oráculo (Groq) não está disponível.")
+    if job_id not in cache: raise HTTPException(status_code=404, detail="Job ID não encontrado ou expirado.")
 
     try:
         cached_data = cache[job_id]
@@ -164,40 +239,34 @@ async def describe_clusters_api(job_id: str = Form(...)):
             top_indices = np.argsort(similarities)[-3:][::-1]
             champion_docs_by_cluster[cid] = [cluster_texts[i] for i in top_indices]
 
+        if not champion_docs_by_cluster: return {"insights": {}}
+        
         prompt_sections = []
         for cid, docs in champion_docs_by_cluster.items():
             doc_list = "\n".join([f"- {doc[:300]}..." for doc in docs])
             prompt_sections.append(f"Grupo {cid}:\n{doc_list}")
-        
-        if not prompt_sections: return {"insights": {}}
 
         master_prompt = (
-            "Você é Aetherius, um analista de dados especialista em síntese de informações. Para cada grupo de textos, responda com um objeto JSON contendo duas chaves:\n"
-            "1. 'topic_name': Um nome temático curto (máximo 5 palavras).\n"
-            "2. 'core_insight': Um resumo de uma única frase capturando a ideia central.\n\n"
+            "Você é Aetherius, um analista de dados especialista. Para cada grupo de textos, responda com um objeto JSON com duas chaves: "
+            "'topic_name' (um nome temático curto, máx 5 palavras) e 'core_insight' (um resumo de uma frase da ideia central).\n\n"
             "Analise os seguintes grupos:\n\n" + "\n\n".join(prompt_sections) +
-            "\n\nResponda APENAS com o JSON contendo os resultados para cada grupo."
+            "\n\nResponda APENAS com o JSON."
         )
         
         chat_completion = groq_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": "Siga as instruções e responda apenas com um objeto JSON válido."},
                 {"role": "user", "content": master_prompt},
-            ],
-            model="llama3-8b-8192", temperature=0.2,
+            ], model="llama3-8b-8192", temperature=0.2,
         )
         response_content = chat_completion.choices[0].message.content
         
         try:
-            json_response_str = response_content.strip().replace("```json", "").replace("```", "")
-            insights = json.loads(json_response_str)
+            insights = json.loads(response_content.strip().replace("```json", "").replace("```", ""))
         except json.JSONDecodeError:
-            logging.error(f"Falha ao decodificar JSON da Groq. Resposta: {response_content}")
             raise HTTPException(status_code=500, detail="O Oráculo respondeu em um formato inesperado.")
             
-        logging.info(f"Insights gerados com sucesso para o job '{job_id}'.")
         return {"insights": insights}
-
     except Exception as e:
         logging.error(f"ERRO CRÍTICO em /describe_clusters/: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Erro interno ao gerar insights: {str(e)}")