Upload 11 files

agent.py

@@ -0,0 +1,56 @@
+from .search import SearchEngine
+
+
+class ShoppingAgent:
+    def __init__(self):
+        self.search_engine = SearchEngine()
+        self.search_engine.load()
+
+    def runtime_info(self):
+        return self.search_engine.runtime_info()
+
+    def montar_resposta(self, query, resultados):
+        if not resultados:
+            return f'Não encontrei produtos relevantes para "{query}".'
+
+        nomes = [item["product_name"] for item in resultados[:3]]
+
+        if len(nomes) == 1:
+            return f'Encontrei um produto relevante para "{query}": {nomes[0]}.'
+
+        if len(nomes) == 2:
+            return f'Encontrei produtos relevantes para "{query}", com destaque para {nomes[0]} e {nomes[1]}.'
+
+        return (
+            f'Encontrei produtos relevantes para "{query}", com destaque para '
+            f'{nomes[0]}, {nomes[1]} e {nomes[2]}.'
+        )
+
+    def verificar_resposta(self, resposta, resultados):
+        if not resultados:
+            return resposta
+
+        nomes_resultados = [item["product_name"] for item in resultados]
+        resposta_limpa = resposta.lower()
+
+        mencoes_validas = any(nome.lower() in resposta_limpa for nome in nomes_resultados)
+
+        if mencoes_validas:
+            return resposta
+
+        top1 = resultados[0]["product_name"]
+        return f"{resposta} O item mais relevante encontrado foi {top1}."
+
+    def responder(self, query, top_k=5):
+        busca = self.search_engine.buscar(query, top_k=top_k)
+        resultados = busca["resultados"]
+
+        resposta_inicial = self.montar_resposta(query, resultados)
+        resposta_final = self.verificar_resposta(resposta_inicial, resultados)
+
+        return {
+            "query": query,
+            "categoria_inferida": busca["categoria_inferida"],
+            "answer": resposta_final,
+            "products": resultados,
+        }

feedback.py

@@ -0,0 +1,168 @@
+import csv
+import os
+from datetime import datetime, timezone
+
+from .google_oauth import GoogleAuthRequiredError, append_feedback_to_sheet, load_credentials
+from .memory import salvar_memoria_negativa
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
+FEEDBACK_FILE = os.path.join(LOGS_DIR, "feedback.csv")
+FEEDBACK_HEADERS = [
+    "timestamp",
+    "query",
+    "product_id",
+    "product_name",
+    "rating",
+    "is_helpful",
+    "note",
+    "categoria_inferida",
+    "feedback",
+    "motivo",
+    "score_final",
+    "score_semantico",
+    "bonus_lexical",
+    "penalidade_feedback",
+    "user_message",
+]
+
+
+def garantir_pasta_logs():
+    os.makedirs(LOGS_DIR, exist_ok=True)
+
+
+def inicializar_arquivo_feedback():
+    garantir_pasta_logs()
+
+    if not os.path.exists(FEEDBACK_FILE):
+        with open(FEEDBACK_FILE, mode="w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow(FEEDBACK_HEADERS)
+
+
+def google_sheets_habilitado():
+    return load_credentials() is not None and bool(os.getenv("GOOGLE_SPREADSHEET_ID", "").strip())
+
+
+def _append_feedback_csv(row):
+    inicializar_arquivo_feedback()
+
+    with open(FEEDBACK_FILE, mode="a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow([row.get(header, "") for header in FEEDBACK_HEADERS])
+
+
+def _build_feedback_payload(
+    query,
+    product_id,
+    product_name,
+    rating=None,
+    is_helpful=None,
+    note=None,
+    categoria_inferida=None,
+    feedback=None,
+    motivo=None,
+    score_final=None,
+    score_semantico=None,
+    bonus_lexical=None,
+    penalidade_feedback=None,
+    user_message=None,
+):
+    return {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "query": query,
+        "product_id": product_id,
+        "product_name": product_name,
+        "rating": rating if rating is not None else "",
+        "is_helpful": is_helpful if is_helpful is not None else "",
+        "note": note or "",
+        "categoria_inferida": categoria_inferida or "",
+        "feedback": feedback or "",
+        "motivo": motivo or "",
+        "score_final": score_final if score_final is not None else "",
+        "score_semantico": score_semantico if score_semantico is not None else "",
+        "bonus_lexical": bonus_lexical if bonus_lexical is not None else "",
+        "penalidade_feedback": penalidade_feedback if penalidade_feedback is not None else "",
+        "user_message": user_message or "",
+    }
+
+
+def salvar_feedback(
+    query,
+    product_id,
+    product_name,
+    rating=None,
+    is_helpful=None,
+    note=None,
+    categoria_inferida=None,
+    feedback=None,
+    motivo=None,
+    score_final=None,
+    score_semantico=None,
+    bonus_lexical=None,
+    penalidade_feedback=None,
+    user_message=None,
+):
+    row = _build_feedback_payload(
+        query=query,
+        product_id=product_id,
+        product_name=product_name,
+        rating=rating,
+        is_helpful=is_helpful,
+        note=note,
+        categoria_inferida=categoria_inferida,
+        feedback=feedback,
+        motivo=motivo,
+        score_final=score_final,
+        score_semantico=score_semantico,
+        bonus_lexical=bonus_lexical,
+        penalidade_feedback=penalidade_feedback,
+        user_message=user_message,
+    )
+
+    _append_feedback_csv(row)
+    saved_google_sheets = False
+    warning = None
+
+    try:
+        append_feedback_to_sheet(row)
+        saved_google_sheets = True
+    except GoogleAuthRequiredError:
+        warning = "Feedback salvo localmente, mas nao enviado ao Google Sheets. Acesse /auth/google para autorizar."
+    except Exception as exc:
+        warning = (
+            "Feedback salvo localmente, mas nao enviado ao Google Sheets. "
+            f"Erro de sincronizacao: {exc}"
+        )
+
+    if rating is not None and rating <= 2:
+        salvar_memoria_negativa(
+            query=query,
+            product_id=product_id,
+            product_name=product_name,
+            rating=rating,
+            motivo="rating_baixo",
+        )
+
+    if is_helpful is False:
+        salvar_memoria_negativa(
+            query=query,
+            product_id=product_id,
+            product_name=product_name,
+            rating=rating if rating is not None else "",
+            motivo="nao_foi_util",
+        )
+
+    response = {
+        "ok": True,
+        "saved_local": True,
+        "saved_google_sheets": saved_google_sheets,
+    }
+    if warning:
+        response["warning"] = warning
+    return response
+
+
+def caminho_feedback():
+    return FEEDBACK_FILE

logger.py

@@ -0,0 +1,60 @@
+import csv
+import os
+from datetime import datetime
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LOGS_DIR = os.path.join(BASE_DIR, "logs")
+SEARCH_LOG_FILE = os.path.join(LOGS_DIR, "search_logs.csv")
+
+
+def garantir_pasta_logs():
+    os.makedirs(LOGS_DIR, exist_ok=True)
+
+
+def inicializar_arquivo_logs():
+    garantir_pasta_logs()
+
+    if not os.path.exists(SEARCH_LOG_FILE):
+        with open(SEARCH_LOG_FILE, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                "timestamp",
+                "query",
+                "categoria_inferida",
+                "answer",
+                "top1_id",
+                "top1_name",
+                "top2_id",
+                "top2_name",
+                "top3_id",
+                "top3_name"
+            ])
+
+
+def salvar_log_busca(resultado):
+    inicializar_arquivo_logs()
+
+    produtos = resultado.get("products", [])
+
+    def get_prod(i, campo):
+        if i < len(produtos):
+            return produtos[i].get(campo, "")
+        return ""
+
+    with open(SEARCH_LOG_FILE, "a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow([
+            datetime.now().isoformat(),
+            resultado.get("query", ""),
+            resultado.get("categoria_inferida", ""),
+            resultado.get("answer", ""),
+            get_prod(0, "product_id"),
+            get_prod(0, "product_name"),
+            get_prod(1, "product_id"),
+            get_prod(1, "product_name"),
+            get_prod(2, "product_id"),
+            get_prod(2, "product_name"),
+        ])
+
+    return {"status": "ok"}

main.py

@@ -0,0 +1,238 @@
+import os
+import threading
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, Query, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
+from pydantic import BaseModel
+
+from .agent import ShoppingAgent
+from .feedback import caminho_feedback, google_sheets_habilitado, salvar_feedback
+from .google_oauth import build_flow, get_authorization_url, load_credentials, save_credentials
+from .logger import salvar_log_busca
+from .memory import caminho_memoria_negativa
+
+EMBEDDING_PROVIDER = os.getenv("EMBEDDING_PROVIDER", "transformers").strip().lower()
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "Ana2012/bertimbau-buscador").strip()
+
+
+def _env_flag(name, default="true"):
+    return os.getenv(name, default).strip().lower() in {"1", "true", "yes", "on"}
+
+
+PRELOAD_AGENT = _env_flag("PRELOAD_AGENT", "true")
+LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
+DATA_DIR = "/data"
+
+app = FastAPI(title="TCC2 Agent API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+agent = None
+agent_lock = threading.Lock()
+
+
+def get_agent():
+    global agent
+    if agent is None:
+        with agent_lock:
+            if agent is None:
+                agent = ShoppingAgent()
+    return agent
+
+
+@app.on_event("startup")
+def preload_agent():
+    if PRELOAD_AGENT:
+        get_agent()
+
+
+class ChatRequest(BaseModel):
+    query: Optional[str] = None
+    message: Optional[str] = None
+    top_k: int = 5
+
+
+class FeedbackRequest(BaseModel):
+    query: str
+    product_id: str
+    product_name: str
+    rating: Optional[int] = None
+    is_helpful: Optional[bool] = None
+    note: Optional[str] = None
+    categoria_inferida: Optional[str] = None
+    feedback: Optional[str] = None
+    motivo: Optional[str] = None
+    score_final: Optional[float] = None
+    score_semantico: Optional[float] = None
+    bonus_lexical: Optional[float] = None
+    penalidade_feedback: Optional[float] = None
+    user_message: Optional[str] = None
+
+
+@app.get("/health")
+def health():
+    runtime = get_agent().runtime_info() if agent is not None else None
+    return {
+        "status": "ok",
+        "agent_ready": agent is not None,
+        "embedding_provider": EMBEDDING_PROVIDER,
+        "model_repo": HF_MODEL_REPO,
+        "preload_agent": PRELOAD_AGENT,
+        "runtime": runtime,
+        "feedback_storage": "google_sheets" if google_sheets_habilitado() else "csv",
+    }
+
+
+@app.get("/", include_in_schema=False)
+def root():
+    return RedirectResponse(url="/docs")
+
+
+@app.get("/favicon.ico", include_in_schema=False)
+def favicon():
+    return Response(status_code=204)
+
+
+@app.get("/auth/google")
+def auth_google():
+    authorization_url, _state = get_authorization_url()
+    return RedirectResponse(url=authorization_url)
+
+
+@app.get("/oauth2callback")
+def oauth2callback(code: str = Query(...)):
+    flow = build_flow()
+    flow.fetch_token(code=code)
+    save_credentials(flow.credentials)
+    return HTMLResponse(
+        "<h3>Autorizacao concluida. O backend ja pode salvar feedbacks no Google Sheets.</h3>"
+    )
+
+
+@app.get("/auth/status")
+def auth_status():
+    credentials = load_credentials()
+    connected = credentials is not None and credentials.valid
+    return {
+        "google_sheets_connected": connected,
+        "message": (
+            "Google Sheets autorizado e pronto para uso."
+            if connected
+            else "Google Sheets ainda nao autorizado. Acesse /auth/google para conectar."
+        ),
+    }
+
+
+@app.get("/debug/files")
+def debug_files():
+    data_path = Path(DATA_DIR)
+    logs_path = Path(LOGS_DIR)
+    feedback_path = Path(caminho_feedback())
+    memory_path = Path(caminho_memoria_negativa())
+
+    return {
+        "data_exists": data_path.exists(),
+        "logs_exists": logs_path.exists(),
+        "feedback_exists": feedback_path.exists(),
+        "negative_memory_exists": memory_path.exists(),
+        "data_files": sorted(p.name for p in data_path.iterdir()) if data_path.exists() else [],
+        "logs_files": sorted(p.name for p in logs_path.iterdir()) if logs_path.exists() else [],
+        "feedback_file": str(feedback_path),
+        "negative_memory_file": str(memory_path),
+        "feedback_storage": "google_sheets" if google_sheets_habilitado() else "csv",
+    }
+
+
+@app.get("/debug/feedback")
+def debug_feedback():
+    feedback_path = Path(caminho_feedback())
+    if not feedback_path.exists():
+        return {"error": "arquivo nao existe"}
+
+    return {"conteudo": feedback_path.read_text(encoding="utf-8")}
+
+
+@app.get("/download/feedback")
+def download_feedback():
+    feedback_path = caminho_feedback()
+    if not os.path.exists(feedback_path):
+        return {"error": "arquivo nao existe"}
+
+    return FileResponse(feedback_path, filename="feedback.csv")
+
+
+@app.get("/debug/memory")
+def debug_memory():
+    memory_path = Path(caminho_memoria_negativa())
+    if not memory_path.exists():
+        return {"status": "missing", "file": str(memory_path)}
+
+    return {
+        "status": "ok",
+        "file": str(memory_path),
+        "content": memory_path.read_text(encoding="utf-8"),
+    }
+
+
+@app.post("/chat")
+def chat(request: ChatRequest):
+    texto = request.query or request.message
+
+    if not texto:
+        return {"error": "query ou message deve ser informado"}
+
+    resultado = get_agent().responder(texto, top_k=request.top_k)
+    salvar_log_busca(resultado)
+    return resultado
+
+
+@app.post("/feedback")
+def feedback(request: FeedbackRequest):
+    feedback_file = caminho_feedback()
+    print(
+        "Salvando feedback:",
+        {
+            "query": request.query,
+            "product_id": request.product_id,
+            "feedback_file": feedback_file,
+            "logs_dir_exists": os.path.exists(LOGS_DIR),
+            "google_sheets_enabled": google_sheets_habilitado(),
+        },
+    )
+
+    try:
+        return salvar_feedback(
+            query=request.query,
+            product_id=request.product_id,
+            product_name=request.product_name,
+            rating=request.rating,
+            is_helpful=request.is_helpful,
+            note=request.note,
+            categoria_inferida=request.categoria_inferida,
+            feedback=request.feedback,
+            motivo=request.motivo,
+            score_final=request.score_final,
+            score_semantico=request.score_semantico,
+            bonus_lexical=request.bonus_lexical,
+            penalidade_feedback=request.penalidade_feedback,
+            user_message=request.user_message,
+        )
+    except Exception as exc:
+        return {
+            "ok": False,
+            "saved_local": False,
+            "saved_google_sheets": False,
+            "detail": str(exc),
+            "feedback_file": feedback_file,
+            "logs_dir_exists": os.path.exists(LOGS_DIR),
+            "google_sheets_enabled": google_sheets_habilitado(),
+        }

memory.py

@@ -0,0 +1,51 @@
+import csv
+import os
+from datetime import datetime
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# Usa volume persistente do Fly.io montado em /data
+# Garante que feedback não seja perdido após deploy/restart
+LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
+NEGATIVE_MEMORY_FILE = os.path.join(LOGS_DIR, "negative_memory.csv")
+
+
+def garantir_pasta_logs():
+    os.makedirs(LOGS_DIR, exist_ok=True)
+
+
+def inicializar_memoria_negativa():
+    garantir_pasta_logs()
+
+    if not os.path.exists(NEGATIVE_MEMORY_FILE):
+        with open(NEGATIVE_MEMORY_FILE, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                "timestamp",
+                "query",
+                "product_id",
+                "product_name",
+                "rating",
+                "motivo"
+            ])
+
+
+def salvar_memoria_negativa(query, product_id, product_name, rating, motivo="feedback_negativo"):
+    inicializar_memoria_negativa()
+
+    with open(NEGATIVE_MEMORY_FILE, "a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow([
+            datetime.now().isoformat(),
+            query,
+            product_id,
+            product_name,
+            rating,
+            motivo
+        ])
+
+    return {"status": "ok"}
+
+
+def caminho_memoria_negativa():
+    return NEGATIVE_MEMORY_FILE

search.py

@@ -0,0 +1,259 @@
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+from .utils import (
+    bonus_lexical,
+    inferir_categoria_consulta,
+    limpar_texto,
+    mapear_categoria,
+)
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+LOGS_DIR = os.path.join(BASE_DIR, "logs")
+
+PATH_PRODUCTS = os.path.join(DATA_DIR, "produtos_finetunado.csv")
+PATH_EMBEDDINGS = os.path.join(DATA_DIR, "embeddings_produtos_finetunado.npy")
+PATH_NEGATIVE_MEMORY = os.path.join(LOGS_DIR, "negative_memory.csv")
+
+MODEL_NAME = os.getenv("HF_MODEL_REPO", "Ana2012/bertimbau-buscador").strip()
+HF_API_TOKEN = os.getenv("HF_API_TOKEN", "").strip()
+
+
+class SearchEngine:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.df_produtos = None
+        self.emb_produtos = None
+        self.df_negative_memory = pd.DataFrame()
+        self.negative_memory_mtime = None
+
+    def load(self):
+        self._load_products()
+        self._load_model()
+        self._load_embeddings()
+        self._refresh_negative_memory(force=True)
+
+    def _load_products(self):
+        df = pd.read_csv(PATH_PRODUCTS)
+        df.columns = df.columns.str.strip().str.lower()
+
+        df["product_name"] = df["product_name"].fillna("").astype(str)
+        df["description"] = df["description"].fillna("").astype(str)
+        df["categoria_principal"] = df["categoria_principal"].fillna("").astype(str)
+        df["category_names_text"] = df["category_names_text"].fillna("").astype(str)
+        df["region"] = df["region"].fillna("").astype(str)
+        df["neighborhood"] = df["neighborhood"].fillna("").astype(str)
+
+        df["product_name_limpo"] = df["product_name"].apply(limpar_texto)
+        df["description_limpa"] = df["description"].apply(limpar_texto)
+        df["categoria_principal_limpa"] = df["categoria_principal"].apply(limpar_texto)
+        df["category_names_text_limpo"] = df["category_names_text"].apply(limpar_texto)
+        df["region_limpa"] = df["region"].apply(limpar_texto)
+        df["neighborhood_limpo"] = df["neighborhood"].apply(limpar_texto)
+
+        df["texto_busca_reforcado"] = (
+            "produto " + df["product_name_limpo"] + " "
+            + "categoria " + df["categoria_principal_limpa"] + " "
+            + "categorias " + df["category_names_text_limpo"] + " "
+            + "bairro " + df["neighborhood_limpo"] + " "
+            + "regiao " + df["region_limpa"] + " "
+            + "descricao " + df["description_limpa"]
+        ).str.strip()
+
+        df["categoria_grupo"] = df["categoria_principal"].apply(mapear_categoria)
+
+        self.df_produtos = df
+
+    def _load_model(self):
+        kwargs = {"device": self.device}
+        if HF_API_TOKEN:
+            kwargs["token"] = HF_API_TOKEN
+
+        # Usa o mesmo pipeline validado localmente com SentenceTransformer.
+        self.model = SentenceTransformer(MODEL_NAME, **kwargs)
+
+    def _load_embeddings(self):
+        self.emb_produtos = np.load(PATH_EMBEDDINGS)
+
+        # Se estes embeddings .npy foram gerados com outro pipeline
+        # (por exemplo, AutoModel + mean pooling manual), os scores podem ficar inconsistentes.
+        # Nesse caso, regenere os embeddings dos produtos com o mesmo SentenceTransformer.
+        if self.emb_produtos.ndim != 2:
+            raise RuntimeError("O arquivo de embeddings precisa conter uma matriz 2D.")
+
+    def runtime_info(self):
+        return {
+            "model_repo": MODEL_NAME,
+            "device": self.device,
+            "products_loaded": 0 if self.df_produtos is None else int(len(self.df_produtos)),
+            "embeddings_loaded": 0 if self.emb_produtos is None else int(len(self.emb_produtos)),
+            "embedding_dim": 0 if self.emb_produtos is None else int(self.emb_produtos.shape[1]),
+        }
+
+    def _refresh_negative_memory(self, force=False):
+        if not os.path.exists(PATH_NEGATIVE_MEMORY):
+            self.df_negative_memory = pd.DataFrame()
+            self.negative_memory_mtime = None
+            return
+
+        current_mtime = os.path.getmtime(PATH_NEGATIVE_MEMORY)
+        if not force and self.negative_memory_mtime == current_mtime:
+            return
+
+        df = pd.read_csv(PATH_NEGATIVE_MEMORY)
+        df.columns = df.columns.str.strip().str.lower()
+
+        for col in ["query", "product_id", "product_name", "motivo", "rating"]:
+            if col not in df.columns:
+                df[col] = ""
+
+        df["query"] = df["query"].fillna("").astype(str)
+        df["query_limpa"] = df["query"].apply(limpar_texto)
+        df["product_id"] = df["product_id"].fillna("").astype(str)
+        df["product_name"] = df["product_name"].fillna("").astype(str)
+        df["motivo"] = df["motivo"].fillna("").astype(str)
+        df["rating_num"] = pd.to_numeric(df["rating"], errors="coerce")
+
+        self.df_negative_memory = df
+        self.negative_memory_mtime = current_mtime
+
+    def _similaridade_consulta(self, query_atual, query_memoria):
+        if not query_atual or not query_memoria:
+            return 0.0
+
+        if query_atual == query_memoria:
+            return 1.0
+
+        termos_atuais = set(query_atual.split())
+        termos_memoria = set(query_memoria.split())
+
+        if not termos_atuais or not termos_memoria:
+            return 0.0
+
+        intersecao = len(termos_atuais & termos_memoria)
+        if intersecao == 0:
+            return 0.0
+
+        return intersecao / max(len(termos_atuais), len(termos_memoria))
+
+    def _calcular_penalidade_feedback(self, query_text, df_filtrado):
+        self._refresh_negative_memory()
+
+        if self.df_negative_memory.empty:
+            return np.zeros(len(df_filtrado))
+
+        query_limpa = limpar_texto(query_text)
+        memorias = self.df_negative_memory[
+            self.df_negative_memory["product_id"].isin(df_filtrado["product_id"].astype(str))
+        ]
+
+        if memorias.empty:
+            return np.zeros(len(df_filtrado))
+
+        penalidades = {}
+
+        for _, memoria in memorias.iterrows():
+            similaridade = self._similaridade_consulta(query_limpa, memoria["query_limpa"])
+            if similaridade <= 0:
+                continue
+
+            penalidade = 0.08 + (0.12 * similaridade)
+
+            if memoria["motivo"] == "nao_foi_util":
+                penalidade += 0.04
+
+            if pd.notna(memoria["rating_num"]) and memoria["rating_num"] <= 2:
+                penalidade += 0.04
+
+            product_id = memoria["product_id"]
+            penalidades[product_id] = min(penalidades.get(product_id, 0.0) + penalidade, 0.45)
+
+        return df_filtrado["product_id"].astype(str).map(lambda x: penalidades.get(x, 0.0)).values
+
+    def gerar_embedding_unico(self, texto):
+        embedding = self.model.encode(
+            texto,
+            convert_to_numpy=True,
+            normalize_embeddings=False,
+            show_progress_bar=False,
+        )
+        return np.asarray(embedding, dtype=np.float32)
+
+    def buscar(self, query_text, top_k=5):
+        query_limpa = limpar_texto(query_text)
+        categoria = inferir_categoria_consulta(query_limpa)
+
+        if categoria is not None:
+            mask = self.df_produtos["categoria_grupo"] == categoria
+            df_filtrado = self.df_produtos[mask].copy()
+            idx_filtrado = df_filtrado.index.tolist()
+        else:
+            df_filtrado = self.df_produtos.copy()
+            idx_filtrado = df_filtrado.index.tolist()
+
+        if len(df_filtrado) == 0:
+            df_filtrado = self.df_produtos.copy()
+            idx_filtrado = df_filtrado.index.tolist()
+
+        emb_query = self.gerar_embedding_unico(query_text).reshape(1, -1)
+        emb_base = self.emb_produtos[idx_filtrado]
+
+        if emb_base.shape[1] != emb_query.shape[1]:
+            raise RuntimeError(
+                "Dimensao incompatível entre os embeddings salvos e o embedding da consulta. "
+                "Regenere o arquivo .npy com o mesmo modelo SentenceTransformer."
+            )
+
+        sims = cosine_similarity(emb_query, emb_base)[0]
+
+        bonus = df_filtrado.apply(
+            lambda row: bonus_lexical(
+                query_text,
+                row["product_name"],
+                row["categoria_principal"],
+                row["neighborhood"],
+                row["region"],
+                row["description"],
+                row["texto_busca_reforcado"],
+            ),
+            axis=1,
+        ).values
+
+        penalidade_feedback = self._calcular_penalidade_feedback(query_text, df_filtrado)
+        score_final = sims + bonus - penalidade_feedback
+
+        top_idx_local = np.argsort(score_final)[::-1][:top_k]
+
+        resultados = []
+        for rank, idx_local in enumerate(top_idx_local, start=1):
+            idx_global = idx_filtrado[idx_local]
+            prod = self.df_produtos.iloc[idx_global]
+
+            resultados.append({
+                "rank": rank,
+                "establishment_id": str(prod["establishment_id"]),
+                "product_id": str(prod["product_id"]),
+                "product_name": prod["product_name"],
+                "categoria_principal": prod["categoria_principal"],
+                "categoria_grupo": prod["categoria_grupo"],
+                "region": prod["region"],
+                "neighborhood": prod["neighborhood"],
+                "score_semantico": float(sims[idx_local]),
+                "bonus_lexical": float(bonus[idx_local]),
+                "penalidade_feedback": float(penalidade_feedback[idx_local]),
+                "score_final": float(score_final[idx_local]),
+            })
+
+        return {
+            "query": query_text,
+            "categoria_inferida": categoria,
+            "resultados": resultados,
+        }

test_agent.py

@@ -0,0 +1,18 @@
+from .agent import ShoppingAgent
+
+agent = ShoppingAgent()
+
+resultado = agent.responder("coca cola 2l")
+
+print("Consulta:", resultado["query"])
+print("Categoria inferida:", resultado["categoria_inferida"])
+print("Resposta do agente:", resultado["answer"])
+print("\nProdutos encontrados:")
+
+for item in resultado["products"]:
+    print(
+        item["rank"],
+        item["product_name"],
+        item["categoria_principal"],
+        item["score_final"]
+    )

test_search.py

@@ -0,0 +1,17 @@
+from .search import SearchEngine
+
+engine = SearchEngine()
+engine.load()
+
+resultado = engine.buscar("coca cola 2l", top_k=5)
+
+print("Consulta:", resultado["query"])
+print("Categoria inferida:", resultado["categoria_inferida"])
+
+for item in resultado["resultados"]:
+    print(
+        item["rank"],
+        item["product_name"],
+        item["categoria_principal"],
+        item["score_final"]
+)

utils.py

@@ -0,0 +1,73 @@
+import re
+import unicodedata
+import pandas as pd
+
+
+def limpar_texto(texto):
+    if pd.isna(texto):
+        return ""
+
+    texto = str(texto).lower().strip()
+    texto = unicodedata.normalize("NFKD", texto)
+    texto = "".join(c for c in texto if not unicodedata.combining(c))
+
+    texto = re.sub(r"[\n\r\t]", " ", texto)
+    texto = re.sub(r"[^a-z0-9\s]", " ", texto)
+    texto = re.sub(r"\s+", " ", texto).strip()
+
+    return texto
+
+
+def mapear_categoria(cat):
+    cat = limpar_texto(cat)
+
+    if "acai" in cat:
+        return "acai"
+    if "pastel" in cat or "pastel de pizza" in cat:
+        return "pastel"
+    if "pizza" in cat:
+        return "pizza"
+    if "hamburg" in cat or "burger" in cat:
+        return "hamburguer"
+    if "sushi" in cat or "japones" in cat or "oriental" in cat:
+        return "japones"
+    if "suco" in cat:
+        return "suco"
+    if "bebida" in cat or "refrigerante" in cat or "refri" in cat:
+        return "bebida"
+
+    return cat
+
+
+def inferir_categoria_consulta(query):
+    q = limpar_texto(query)
+
+    if "acai" in q:
+        return "acai"
+    if "pastel" in q or "pastel de pizza" in q:
+        return "pastel"
+    if "pizza" in q:
+        return "pizza"
+    if "hamburguer" in q or "burger" in q or "x bacon" in q:
+        return "hamburguer"
+    if "sushi" in q or "temaki" in q:
+        return "japones"
+    if "suco" in q:
+        return "suco"
+    if "coca" in q or "refrigerante" in q or "refri" in q:
+        return "bebida"
+
+    return None
+
+
+def bonus_lexical(query, *texts):
+    q = limpar_texto(query)
+    referencias = [limpar_texto(texto) for texto in texts if texto]
+
+    bonus = 0.0
+
+    for termo in q.split():
+        if any(termo in referencia for referencia in referencias):
+            bonus += 0.03
+
+    return bonus