Deploy backend FastAPI para HF Spaces

.dockerignore

@@ -0,0 +1,5 @@
+fly.toml
+.git/
+__pycache__/
+.envrc
+.venv/

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

ChatAmoOfertas/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

ChatAmoOfertas/README.md

@@ -0,0 +1,10 @@
+---
+title: ChatAmoOfertas
+emoji: 🏃
+colorFrom: green
+colorTo: gray
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Dockerfile

@@ -0,0 +1,26 @@
+
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1 \
+    PORT=7860 \
+    HF_HOME=/home/user/.cache/huggingface \
+    HF_HUB_CACHE=/home/user/.cache/huggingface/hub \
+    TRANSFORMERS_CACHE=/home/user/.cache/huggingface/transformers
+
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir --extra-index-url https://download.pytorch.org/whl/cpu -r requirements.txt
+
+COPY . /app
+RUN mkdir -p /home/user/.cache/huggingface/hub /home/user/.cache/huggingface/transformers \
+    && chown -R user:user /app /home/user/.cache
+
+USER user
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "python -m uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

app/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,
+        }

app/feedback.py

@@ -0,0 +1,75 @@
+import csv
+import os
+from datetime import datetime
+
+from .memory import salvar_memoria_negativa
+
+
+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")
+FEEDBACK_FILE = os.path.join(LOGS_DIR, "feedback.csv")
+
+
+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([
+                "timestamp",
+                "query",
+                "product_id",
+                "product_name",
+                "rating",
+                "is_helpful"
+            ])
+
+
+def salvar_feedback(query, product_id, product_name, rating=None, is_helpful=None):
+    inicializar_arquivo_feedback()
+
+    with open(FEEDBACK_FILE, mode="a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow([
+            datetime.now().isoformat(),
+            query,
+            product_id,
+            product_name,
+            rating if rating is not None else "",
+            is_helpful if is_helpful is not None else ""
+        ])
+
+    # Regra simples para criar memória negativa
+    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"
+        )
+
+    return {
+        "status": "ok",
+        "message": "Feedback salvo com sucesso."
+    }
+
+
+def caminho_feedback():
+    return FEEDBACK_FILE

app/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"}

app/main.py

@@ -0,0 +1,186 @@
+import os
+import threading
+from pathlib import Path
+
+from fastapi import FastAPI, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, RedirectResponse
+from pydantic import BaseModel
+from typing import Optional
+
+from .agent import ShoppingAgent
+from .feedback import caminho_feedback, salvar_feedback
+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,
+    # Libera temporariamente a comunicacao entre frontend na Cloudflare e backend no Fly.io.
+    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
+
+
+@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,
+    }
+
+
+@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("/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),
+    }
+
+
+@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),
+        },
+    )
+
+    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
+        )
+    except Exception as exc:
+        return {
+            "status": "error",
+            "message": "Erro ao salvar feedback.",
+            "detail": str(exc),
+            "feedback_file": feedback_file,
+            "logs_dir_exists": os.path.exists(LOGS_DIR),
+        }

app/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

app/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,
+        }

app/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"]
+    )

app/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"]
+)

app/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

data/embeddings_produtos_bertimbau_reforcado.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd9acd51ae3ccf45d25108f07c4aa51c662ed9c77f38a728c0853199152687ed
+size 158850176

data/embeddings_produtos_finetunado.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96ed5c483e191b957161d75c711b7d268b84a5434aa92d41a1f910e975136a2c
+size 158850176

data/products_tratado_textobusca.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fd942f41249a721b2342e5a72b8ab0c3a2799ba8e0fe4b78732068c0f7b10ed
+size 31993441

data/produtos_finetunado.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dade0a9d6c3ecf4c98b49bac5e03f46ddea2da8cbf059bd1d43952162d6e63ba
+size 31961695

fly.toml

@@ -0,0 +1,39 @@
+# fly.toml app configuration file generated for backend-damp-fog-5601 on 2026-03-26T21:56:01-03:00
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = 'backend-damp-fog-5601'
+primary_region = 'gru'
+
+[build]
+  dockerfile = 'Dockerfile'
+
+[env]
+  PORT = '7860'
+  PRELOAD_AGENT = 'true'
+  EMBEDDING_PROVIDER = 'transformers'
+  HF_MODEL_REPO = 'Ana2012/bertimbau-buscador'
+  HF_HOME = '/home/user/.cache/huggingface'
+  HF_HUB_CACHE = '/home/user/.cache/huggingface/hub'
+  TRANSFORMERS_CACHE = '/home/user/.cache/huggingface/transformers'
+
+[processes]
+  app = "sh -c 'python -m uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}'"
+
+[http_service]
+  internal_port = 7860
+  force_https = true
+  auto_stop_machines = 'stop'
+  auto_start_machines = true
+  min_machines_running = 1
+  processes = ['app']
+
+[[mounts]]
+  source = "data"
+  destination = "/data"
+
+[[vm]]
+  memory = '2gb'
+  cpus = 1
+  memory_mb = 2048

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn[standard]
+python-dotenv
+pandas
+numpy
+torch
+transformers
+sentence-transformers
+huggingface-hub
+safetensors
+scikit-learn