API update

README.md

@@ -9,5 +9,3 @@ pinned: false
 license: mit
 short_description: API service for rage movie and tv show recommendation app
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/{api_routes.py → api/api_routes.py}

@@ -1,6 +1,7 @@
-from app.bootstrap import chat_fn
-from app.schemas import ChatRequest
-from fastapi import APIRouter
+from app.core.bootstrap import chat_fn
+from app.api.schemas import ChatRequest, FinalRecsRequest
+from app.services.usage_logger import log_final_results
+from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 
 router = APIRouter()
@@ -16,8 +17,32 @@ async def chat_endpoint(req: ChatRequest):
             genres=req.genres,
             providers=req.providers,
             year_range=tuple(req.year_range),
+            session_id=req.session_id,
+            query_id=req.query_id,
+            device_info=req.device_info,
         )
         for chunk in generator:
             yield chunk
 
     return StreamingResponse(response_stream(), media_type="text/plain")
+
+
+@router.post("/log/final_recs")
+async def log_final_recommendations(req: FinalRecsRequest):
+    rows = [
+        {
+            "query_id": req.query_id,
+            "media_id": rec.media_id,
+            "is_final_rec": True,
+            "why_summary": rec.why
+        }
+        for rec in req.final_recs
+    ]
+
+    try:
+        log_final_results(rows)
+        return {"status": "ok"}
+    except Exception as e:
+        print(f"❌ Error logging final recs: {e}")
+        raise HTTPException(status_code=500, detail="Failed to log final recommendations")
+

app/{schemas.py → api/schemas.py}

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List
+from typing import List, Optional
 
 from pydantic import BaseModel, field_validator, model_validator
 
@@ -13,6 +13,11 @@ class MediaType(str, Enum):
     MOVIE = "movies"
     TV = "tvs"
 
+class DeviceInfo(BaseModel):
+    device_type: Optional[str] = None
+    platform: Optional[str] = None
+    user_agent: Optional[str] = None
+
 
 class ChatRequest(BaseModel):
     question: str
@@ -21,6 +26,9 @@ class ChatRequest(BaseModel):
     genres: List[str] = []
     providers: List[str] = []
     year_range: List[int] = [1920, 2025]
+    session_id: str
+    query_id: str
+    device_info: Optional[DeviceInfo] = None
 
     @field_validator("question")
     def validate_question(cls, v):
@@ -33,3 +41,13 @@ class ChatRequest(BaseModel):
         if len(self.year_range) != 2:
             raise ValueError("year_range must be a list of exactly two integers: [start, end]")
         return self
+
+
+class FinalRec(BaseModel):
+    media_id: int
+    why: str
+
+
+class FinalRecsRequest(BaseModel):
+    query_id: str
+    final_recs: List[FinalRec]

app/core/bootstrap.py

@@ -0,0 +1,46 @@
+import os
+import time
+
+import nltk
+from app.services.chatbot import build_chat_fn
+from app.core.config import (
+    NLTK_PATH,
+    QDRANT_API_KEY,
+    QDRANT_ENDPOINT,
+    QDRANT_MOVIE_COLLECTION_NAME,
+    QDRANT_TV_COLLECTION_NAME,
+)
+from app.llm.custom_models import load_sentence_model, load_bm25_files, setup_intent_classifier
+from app.retrieval.retriever import get_media_retriever
+from app.retrieval.vectorstore import connect_qdrant
+
+start = time.time()
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+# nltk.data.path.append(str(NLTK_PATH))
+
+
+def setup_retriever():
+    embed_model = load_sentence_model()
+    bm25_models, bm25_vocabs = load_bm25_files()
+    nltk.data.path.append(str(NLTK_PATH))
+    print("✅ NLTK resources loaded")
+    
+    qdrant_client = connect_qdrant(endpoint=QDRANT_ENDPOINT, api_key=QDRANT_API_KEY)
+
+    return get_media_retriever(
+        embed_model=embed_model,
+        qdrant_client=qdrant_client,
+        bm25_models=bm25_models,
+        bm25_vocabs=bm25_vocabs,
+        movie_collection_name=QDRANT_MOVIE_COLLECTION_NAME,
+        tv_collection_name=QDRANT_TV_COLLECTION_NAME,
+    )
+
+
+# Initialize once at startup
+retriever = setup_retriever()
+intent_classifier = setup_intent_classifier()
+chat_fn = build_chat_fn(retriever, intent_classifier)
+
+print(f"🔧 Total startup time: {time.time() - start:.2f}s")
+

app/{config.py → core/config.py}

@@ -9,18 +9,27 @@ OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
 
 QDRANT_ENDPOINT = os.getenv("QDRANT_ENDPOINT")
-QDRANT_MOVIE_COLLECTION_NAME = os.getenv("QDRANT_MOVIE_COLLECTION_NAME_BGE")
-QDRANT_TV_COLLECTION_NAME = os.getenv("QDRANT_TV_COLLECTION_NAME_BGE")
+# QDRANT_MOVIE_COLLECTION_NAME = os.getenv("QDRANT_MOVIE_COLLECTION_NAME_BGE")
+# QDRANT_TV_COLLECTION_NAME = os.getenv("QDRANT_TV_COLLECTION_NAME_BGE")
+QDRANT_MOVIE_COLLECTION_NAME = "Movies_BGE_June"
+QDRANT_TV_COLLECTION_NAME = "TV_Shows_BGE_June"
 
-NLTK_PATH = Path(__file__).resolve().parent.parent / "data" / "nltk_data"
-BM25_PATH = Path(__file__).resolve().parent.parent / "data" / "bm25_files"
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_API_KEY = os.getenv("SUPABASE_API_KEY")
 
-INTENT_MODEL = "JJTsao/intent-classifier-distilbert-moviebot"   # Fine-tuned intent classification model for query intent classifiation  
-EMBEDDING_MODEL = "JJTsao/fine-tuned_movie_retriever-bge-base-en-v1.5"  # Fine-tuned sentence transfomer model for query dense vector embedding 
+NLTK_PATH = Path(__file__).resolve().parent.parent.parent / "data" / "nltk_data"
+BM25_PATH = Path(__file__).resolve().parent.parent.parent / "data" / "bm25_files"
+
+INTENT_MODEL = "JJTsao/intent-classifier-distilbert-moviebot"  # Fine-tuned intent classification model for query intent classifiation
+EMBEDDING_MODEL = "JJTsao/fine-tuned_movie_retriever-bge-base-en-v1.5"  # Fine-tuned sentence transfomer model for query dense vector embedding
 OPENAI_MODEL = "gpt-4o-mini"  # LLM for chat completions
 
 
 if not OPENAI_API_KEY or not QDRANT_API_KEY:
     raise ValueError("Missing API key(s).")
-if not QDRANT_ENDPOINT or not QDRANT_MOVIE_COLLECTION_NAME or not QDRANT_TV_COLLECTION_NAME:
+if (
+    not QDRANT_ENDPOINT
+    or not QDRANT_MOVIE_COLLECTION_NAME
+    or not QDRANT_TV_COLLECTION_NAME
+):
     raise ValueError("Missing QDrant URL or collection name.")

app/{bootstrap.py → llm/custom_models.py}

@@ -1,69 +1,47 @@
-import os
 import time
 from pathlib import Path
 
 import joblib
-import nltk
-from app.chatbot import build_chat_fn
-from app.config import (
-    BM25_PATH,
-    INTENT_MODEL,
-    NLTK_PATH,
-    QDRANT_API_KEY,
-    QDRANT_ENDPOINT,
-    QDRANT_MOVIE_COLLECTION_NAME,
-    QDRANT_TV_COLLECTION_NAME,
-)
-from app.llm_services import load_sentence_model
-from app.retriever import get_media_retriever
-from app.vectorstore import connect_qdrant
+import torch
+from app.core.config import BM25_PATH, EMBEDDING_MODEL, INTENT_MODEL
 from rank_bm25 import BM25Okapi
+from sentence_transformers import SentenceTransformer
 from transformers import pipeline
 
-start = time.time()
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
+# === Model Config ===
+_sentence_model = None  # Not loaded at import time
 
 
-def load_bm25_files() -> tuple[dict[str, BM25Okapi], dict[str, int]]:
-    bm25_dir = Path(BM25_PATH)
-    try:
-        bm25_models = {
-            "movie": joblib.load(bm25_dir / "movie_bm25_model.joblib"),
-            "tv": joblib.load(bm25_dir / "tv_bm25_model.joblib"),
-        }
-        bm25_vocabs = {
-            "movie": joblib.load(bm25_dir / "movie_bm25_vocab.joblib"),
-            "tv": joblib.load(bm25_dir / "tv_bm25_vocab.joblib"),
-        }
-    except FileNotFoundError as e:
-        raise FileNotFoundError(f"Missing BM25 files: {e}")
-    return bm25_models, bm25_vocabs
-
+def load_sentence_model():
+    global _sentence_model
+    if _sentence_model is None:
+        print("Loading embedding model...")
+        _sentence_model = SentenceTransformer(
+            EMBEDDING_MODEL, device="cuda" if torch.cuda.is_available() else "cpu"
+        )
 
-def setup_retriever():
-    embed_model = load_sentence_model()
-    qdrant_client = connect_qdrant(endpoint=QDRANT_ENDPOINT, api_key=QDRANT_API_KEY)
-    nltk.data.path.append(str(NLTK_PATH))
-    print("✅ NLTK resources loaded")
+        print(f"Model '{EMBEDDING_MODEL}' loaded. Performing GPU warmup...")
 
-    bm25_models, bm25_vocabs = load_bm25_files()
-    print("✅ BM25 files loaded")
+        # Realistic multi-sentence warmup to trigger full CUDA graph
+        warmup_sentences = [
+            "A suspenseful thriller with deep character development and moral ambiguity.",
+            "Coming-of-age story with emotional storytelling and strong ensemble performances.",
+            "Mind-bending sci-fi with philosophical undertones and high concept ideas.",
+            "Recommend me some comedies.",
+        ]
+        _ = _sentence_model.encode(warmup_sentences, show_progress_bar=False)
+        time.sleep(0.5)
+        _ = _sentence_model.encode(warmup_sentences, show_progress_bar=False)
+        print("🚀 Embedding model fully warmed up.")
 
-    return get_media_retriever(
-        embed_model=embed_model,
-        qdrant_client=qdrant_client,
-        bm25_models=bm25_models,
-        bm25_vocabs=bm25_vocabs,
-        movie_collection_name=QDRANT_MOVIE_COLLECTION_NAME,
-        tv_collection_name=QDRANT_TV_COLLECTION_NAME,
-    )
+    return _sentence_model
 
 
 def setup_intent_classifier():
-    print(f"🔧 Loading intent classifier from {INTENT_MODEL}")
+    print(f"Loading intent classifier from {INTENT_MODEL}")
     classifier = pipeline("text-classification", model=INTENT_MODEL)
 
-    print("🔥 Warming up intent classifier...")
+    print("Warming up intent classifier...")
     warmup_queries = [
         "Can you recommend a feel-good movie?",
         "Who directed The Godfather?",
@@ -76,10 +54,23 @@ def setup_intent_classifier():
     return classifier
 
 
-# Initialize once at startup
-retriever = setup_retriever()
-intent_classifier = setup_intent_classifier()
-chat_fn = build_chat_fn(retriever, intent_classifier)
+def load_bm25_files() -> tuple[dict[str, BM25Okapi], dict[str, int]]:
+    bm25_dir = Path(BM25_PATH)
+    try:
+        bm25_models = {
+            "movie": joblib.load(bm25_dir / "movie_bm25_model.joblib"),
+            "tv": joblib.load(bm25_dir / "tv_bm25_model.joblib"),
+        }
+        bm25_vocabs = {
+            "movie": joblib.load(bm25_dir / "movie_bm25_vocab.joblib"),
+            "tv": joblib.load(bm25_dir / "tv_bm25_vocab.joblib"),
+        }
+        print("✅ BM25 files loaded")
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"Missing BM25 files: {e}")
+    return bm25_models, bm25_vocabs
 
-print(f"🔧 Total startup time: {time.time() - start:.2f}s")
 
+def embed_text(text: str) -> list[float]:
+    model = load_sentence_model()
+    return model.encode(text).tolist()

app/{llm_services.py → llm/llm_completion.py}

@@ -1,57 +1,43 @@
-import time
-
-import torch
 from openai import OpenAI
-from sentence_transformers import SentenceTransformer
-from app.config import EMBEDDING_MODEL, OPENAI_MODEL, OPENAI_API_KEY
-
-# === LLM Config ===
-_sentence_model = None  # Not loaded at import time
+from app.core.config import OPENAI_MODEL, OPENAI_API_KEY
 
 # === Clients ===
 openai_client = OpenAI(api_key=OPENAI_API_KEY)
 
 # === System Prompt ===
 SYSTEM_PROMPT = """
-You are a professional film curator and critic. Your role is to analyze the user's preferences and recommend high-quality films or TV shows using the provided context. Do not seek film or tv show options outside of the list provided to you.
-Focus on: 
-
-- Artistic merit and storytelling 
-- Genres, themes, and tone
-- Popularity, IMDB ratings, and Rotten Tomatoes ratings
+You are a professional film curator and critic. Your role is to analyze the user's preferences and recommend high-quality films or TV shows using only the provided list.
 
-Provide a brief explanation of why the user might enjoy each movie or tv series. Include IMDB rating, Rotten Tomatoe ratings, and a poster. Answer with authority and care. Respond in markdown.
-"""
+Focus on:
 
+- Artistic merit and storytelling
+- Genres, themes, tone, and emotional resonance
+- IMDB and Rotten Tomatoes ratings
+- Strong character-driven or thematically rich selections
 
-def load_sentence_model():
-    global _sentence_model
-    if _sentence_model is None:
-        print("⏳ Loading embedding model...")
-        _sentence_model = SentenceTransformer(
-            EMBEDDING_MODEL, device="cuda" if torch.cuda.is_available() else "cpu"
-        )
+### Response Format (in markdown):
 
-        print(f"🔥 Model '{EMBEDDING_MODEL}' loaded. Performing GPU warmup...")
+1. Start with a concise 2 sentences **opening paragraph** that contextualizes the theme and the overall viewing experience the user is seeking. At the end of this paragraph, insert the token: <!-- END_INTRO -->.
 
-        # Realistic multi-sentence warmup to trigger full CUDA graph
-        warmup_sentences = [
-            "A suspenseful thriller with deep character development and moral ambiguity.",
-            "Coming-of-age story with emotional storytelling and strong ensemble performances.",
-            "Mind-bending sci-fi with philosophical undertones and high concept ideas.",
-            "Recommend me some comedies.",
-        ]
-        _ = _sentence_model.encode(warmup_sentences, show_progress_bar=False)
-        time.sleep(0.5)
-        _ = _sentence_model.encode(warmup_sentences, show_progress_bar=False)
-        print("🚀 Embedding model fully warmed up.")
+2. Then, for each recommendation, use the following format (repeat for each title). At the end of each movie recommendation block, insert the token: <!-- END_MOVIE -->:
 
-    return _sentence_model
+```
+### <Number>. <Movie Title>
+- GENRES: Genre1, Genre2, ...
+- IMDB_RATING: X.X
+- ROTTEN_TOMATOES_RATING: XX%
+- MEDIA_ID: 1234
+- POSTER_PATH: /abc123.jpg
+- BACKDROP_PATH: /abc123.jpg
+- TRAILER_KEY: abc123
+- WHY_YOU_MIGHT_ENJOY_IT: <Short paragraph explaining the appeal based on character, themes, tone, and relevance to the user's intent.>
+<!-- END_MOVIE -->
+```
 
+3. End with a brief **closing paragraph** that summarizes the emotional or intellectual throughline across the recommendations, and affirms their alignment with the user's preferences.
 
-def embed_text(text: str) -> list[float]:
-    model = load_sentence_model()
-    return model.encode(text).tolist()
+Write in **Markdown** only. Be concise, authoritative, and avoid overly generic statements. Each "Why You Might Enjoy It" should be specific and grounded in the movie’s themes, storytelling, or cultural relevance.
+"""
 
 
 def build_chat_history(history: list, max_turns: int = 5) -> list:
@@ -61,7 +47,6 @@ def build_chat_history(history: list, max_turns: int = 5) -> list:
     ]
 
 
-
 def call_chat_model_openai(history, user_message: str):
     messages = [{"role": "system", "content": SYSTEM_PROMPT}]
     messages += build_chat_history(history or [])

app/{media_retriever.py → retrieval/media_retriever.py}

@@ -1,5 +1,6 @@
 from collections import Counter
-from typing import Dict, List
+from typing import Dict, List, Tuple
+import threading
 
 from nltk.corpus import stopwords
 from nltk.stem import PorterStemmer
@@ -8,6 +9,8 @@ from qdrant_client import QdrantClient
 from qdrant_client.models import FieldCondition, Filter, MatchValue, Range, models
 from sentence_transformers import SentenceTransformer
 
+_stop_words_lock = threading.Lock()
+
 
 class MediaRetriever:
     def __init__(
@@ -45,7 +48,12 @@ class MediaRetriever:
 
     @staticmethod
     def tokenize_and_preprocess(text: str) -> List[str]:
-        stop_words = set(stopwords.words("english"))
+        with _stop_words_lock:
+            try:
+                stop_words = set(stopwords.words("english"))
+            except Exception as e:
+                print("⚠️ Failed to load NLTK stopwords:", e)
+                stop_words = set()        
         stemmer = PorterStemmer()
 
         tokens = word_tokenize(text.lower())
@@ -118,7 +126,7 @@ class MediaRetriever:
 
         # Fuse dense and sparse results and rerank
         fused = self.fuse_dense_sparse(dense_results, sparse_results)
-        reranked = self.rerank_fused_results(fused)
+        reranked, scored_lookup = self.rerank_fused_results(fused)
 
         reranked_ids = [p.id for p in reranked[:20]]
         print ("\nReranked Top-30:")
@@ -129,7 +137,7 @@ class MediaRetriever:
                 f"#{i + 1} {p.payload.get('title', '')} | Score: {p.score} Dense: {f['dense_score']:.3f}, Sparse: {f['sparse_score']:.3f}, Pop: {p.payload.get('popularity', 0)}, Rating: {p.payload.get('vote_average', 0)}"
             )
 
-        return reranked[: self.top_k]
+        return reranked[: self.top_k], scored_lookup
 
     def _build_filter(
         self, genres=None, providers=None, year_range=None
@@ -172,7 +180,7 @@ class MediaRetriever:
             using="dense_vector",
             query_filter=qdrant_filter,
             limit=self.semantic_retrieval_limit,
-            with_payload=["llm_context", "title", "popularity", "vote_average"],
+            with_payload=["llm_context", "media_id", "title", "popularity", "vote_average"],
             with_vectors=False,
         )
 
@@ -188,7 +196,7 @@ class MediaRetriever:
             using="sparse_vector",
             query_filter=qdrant_filter,
             limit=self.bm25_retrieval_limit,
-            with_payload=["llm_context", "title", "popularity", "vote_average"],
+            with_payload=["llm_context", "media_id", "title", "popularity", "vote_average"],
             with_vectors=False,
         )
 
@@ -227,29 +235,38 @@ class MediaRetriever:
     def rerank_fused_results(
         self,
         fused: Dict[str, Dict],
-    ) -> List:
+    ) -> Tuple[List, Dict]:
         max_popularity = max(
             (float(f["point"].payload.get("popularity", 0)) for f in fused.values()),
             default=1.0,
         )
 
-        def compute_score(f):
+        scored = {}
+        for id_, f in fused.items():
             point = f["point"]
             dense_score = f["dense_score"]
             sparse_score = f["sparse_score"]
             popularity = float(point.payload.get("popularity", 0)) / max_popularity
             vote_average = float(point.payload.get("vote_average", 0)) / 10.0
 
-            return (
+            reranked_score = (
                 self.dense_weight * dense_score
                 + self.sparse_weight * sparse_score
                 + self.rating_weight * vote_average
                 + self.popularity_weight * popularity
             )
 
-        reranked = sorted(fused.values(), key=compute_score, reverse=True)
+            scored[id_] = {
+                "point": point,
+                "dense_score": dense_score,
+                "sparse_score": sparse_score,
+                "reranked_score": reranked_score,
+            }
+
+        sorted_ids = sorted(scored.items(), key=lambda x: x[1]["reranked_score"], reverse=True)
+
+        return [v["point"] for _, v in sorted_ids], scored
 
-        return [f["point"] for f in reranked]
 
     def format_context(self, movies: list[dict]) -> str:
         # Formart the retrieved documents as context for LLM

app/{retriever.py → retrieval/retriever.py}

@@ -1,4 +1,4 @@
-from app.media_retriever import MediaRetriever
+from app.retrieval.media_retriever import MediaRetriever
 
 def get_media_retriever(
     embed_model,

app/{chatbot.py → services/chatbot.py}

@@ -2,11 +2,11 @@ import re
 import time
 from concurrent.futures import ThreadPoolExecutor
 
-from app.llm_services import call_chat_model_openai
-
+from app.llm.llm_completion import call_chat_model_openai
+from app.services.usage_logger import log_query_and_results
 
 def sanitize_markdown(md_text: str) -> str:
-    return re.sub(r'!\[.*?\]\(.*?\)', '', md_text)
+    return re.sub(r"!\[.*?\]\(.*?\)", "", md_text)
 
 
 def build_chat_fn(retriever, intent_classifier):
@@ -17,9 +17,12 @@ def build_chat_fn(retriever, intent_classifier):
         genres=None,
         providers=None,
         year_range=None,
+        session_id=None,
+        query_id=None,
+        device_info=None
     ):
         full_t0 = time.time()
-        
+
         with ThreadPoolExecutor() as executor:
             # Classify user intent to determine if it is a recommendation ask
             t0 = time.time()
@@ -46,11 +49,10 @@ def build_chat_fn(retriever, intent_classifier):
         t0 = time.time()
         sparse_vector = retriever.embed_sparse(question, media_type)
         print(f"📈 embed_sparse() result received in {time.time() - t0:.3f}s")
-        
+
         if is_rec_intent:
-            # If Yes, proceed with the RAG pipeline for retrieval and recommendation
-            t0 = time.time()            
-            retrieved_movies = retriever.retrieve_and_rerank(
+            t0 = time.time()
+            retrieved_movies, scored_lookup = retriever.retrieve_and_rerank(
                 dense_vector,
                 sparse_vector,
                 media_type.lower(),
@@ -60,18 +62,73 @@ def build_chat_fn(retriever, intent_classifier):
             )
             print(f"\n📚 retrieve_and_rerank() took {time.time() - t0:.3f}s")
             
+            query_entry = {
+                "query_id": query_id,
+                "session_id": session_id,
+                "question": question,
+                "intent": "recommendation",
+                "media_type": media_type,
+                "genres": genres,
+                "providers": providers,
+                "year_start": year_range[0],
+                "year_end": year_range[1],
+                "device_type": device_info.device_type,
+                "platform" : device_info.platform,
+                "user_agent": device_info.user_agent
+            }
+            
+            result_entries = []
+            for rank, p in enumerate (retrieved_movies):
+                s = scored_lookup[p.id]
+                result_entries.append({
+                    "query_id": query_id,
+                    "media_type": media_type,
+                    "media_id": p.payload["media_id"],
+                    "title": p.payload["title"],
+                    "rank": rank + 1,
+                    "dense_score": s["dense_score"],
+                    "sparse_score": s["sparse_score"],
+                    "reranked_score": s["reranked_score"],
+                    "is_final_rec": False
+                })
+                
+            try:
+                log_query_and_results(query_entry, result_entries)
+            except Exception as e:
+                print("⚠️ Failed to log to Supabase:", e)
+
+            yield "[[MODE:recommendation]]\n"
+            
             context = retriever.format_context(retrieved_movies)
             user_message = f"{question}\n\nContext:\nBased on the following retrieved {media_type.lower()}, suggest the best recommendations.\n\n{context}"
-            
-            print(f"✨ Total chat() prep time before streaming: {time.time() - full_t0:.3f}s")
+
+            print(
+                f"✨ Total chat() prep time before streaming: {time.time() - full_t0:.3f}s"
+            )
+
             for chunk in call_chat_model_openai(history, user_message):
                 yield chunk
 
         else:
-            # If No, proceed with a general conversation
-            user_message = question
+            log_query_and_results(
+                query_entry={
+                    "query_id": query_id,
+                    "session_id": session_id,
+                    "question": question,
+                    "intent": "chat",
+                    "media_type": media_type,
+                },
+                result_entries=[]
+            )
             
-            print(f"✨ Total chat() prep time before streaming: {time.time() - full_t0:.3f}s")
+            user_message = f"The user did not ask for a recommendation. Ask them to be more specific. Answer this as a general question: {question}"
+
+            print(
+                f"✨ Total chat() prep time before streaming: {time.time() - full_t0:.3f}s"
+            )
+            
+            yield "[[MODE:chat]]\n"
+
             for chunk in call_chat_model_openai(history, user_message):
                 yield sanitize_markdown(chunk)
 

app/services/usage_logger.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+
+import httpx
+from app.core.config import SUPABASE_API_KEY, SUPABASE_URL
+
+
+def log_query_and_results(
+    query_entry: dict,
+    result_entries: list[dict],
+):
+    if not SUPABASE_URL or not SUPABASE_API_KEY:
+        print("⚠️ Missing Supabase config, skipping log.")
+        return
+
+    timestamp = datetime.utcnow().isoformat()
+    query_entry.setdefault("created_at", timestamp)
+    for r in result_entries:
+        r.setdefault("created_at", timestamp)
+
+    headers = {
+        "apikey": SUPABASE_API_KEY,
+        "Authorization": f"Bearer {SUPABASE_API_KEY}",
+        "Content-Type": "application/json",
+        "Prefer": "resolution=merge-duplicates"
+    }
+    
+    try:
+        # 1. Insert usage log
+        query_resp = httpx.post(
+            f"{SUPABASE_URL}/rest/v1/query_logs",
+            headers=headers,
+            json=[query_entry]
+        )
+
+        if query_resp.status_code not in (200, 201, 204):
+            print("⚠️ Failed to log usage:", query_resp.text)
+
+        # 2. Insert result logs in batch
+        if result_entries:
+            result_resp = httpx.post(
+                f"{SUPABASE_URL}/rest/v1/result_logs",
+                headers=headers,
+                json=result_entries
+            )
+            if result_resp.status_code not in (200, 201, 204):
+                print("⚠️ Failed to log results:", result_resp.text)
+
+    except Exception as e:
+        print("❌ Logging error:", e)
+
+
+def log_final_results(result_entries: list[dict]):
+    if not SUPABASE_URL or not SUPABASE_API_KEY:
+        print("⚠️ Missing Supabase config, skipping log.")
+        return
+
+    headers = {
+        "apikey": SUPABASE_API_KEY,
+        "Authorization": f"Bearer {SUPABASE_API_KEY}",
+        "Content-Type": "application/json",
+        "Prefer": "resolution=merge-duplicates"
+    }
+
+    try:
+        result_resp = httpx.post(
+            f"{SUPABASE_URL}/rest/v1/result_logs",
+            headers=headers,
+            json=result_entries
+        )
+        if result_resp.status_code not in (200, 201, 204):
+            print("⚠️ Failed to log final results:", result_resp.text)
+    except Exception as e:
+        print("❌ Error in write_final_results:", e)
+
+        
+

data/bm25_files/movie_bm25_model.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8aaf32789542f07efa41b2f3a6023110e0f9df84f354ce50fc67173ed57eb9e0
-size 6617501
+oid sha256:829dfd9b3e50992a2617415e4d45e05eb8b887206e77ff5250416b7cd5dac0d2
+size 6637836

data/bm25_files/movie_bm25_vocab.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:559fe41c00d8e94d2e516f8278b5950f2e02b4938151cdc0e23986ae6936513b
-size 454110
+oid sha256:5d1304c2611aa1072156fe60aa0298934dc72a8f85c5f484ba49ff641223dadf
+size 688111

data/bm25_files/tv_bm25_model.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4bf700b0207c36e600f176b8151c195f2b3d6f9950dc70b10c922c06706224fc
-size 5680147
+oid sha256:7b7275086436201a11b2027fa28727d8d05cf6c3180bb68de2cd0deb12e5dc62
+size 5712382

data/bm25_files/tv_bm25_vocab.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eab388573cc6b4b7dc5b70cd13bdb7dcaaf0a7f261a9cf980c3251a33425d8a0
-size 489786
+oid sha256:db37c47df4a7f73e792c479d72095a62a35389be3ed01997aa60ab57d0e320a5
+size 497815

main.py

@@ -1,4 +1,4 @@
-from app.api_routes import router
+from app.api.api_routes import router
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -20,3 +20,7 @@ app.include_router(router)
 @app.get("/health")
 def health_check():
     return {"status": "ok"}
+
+@app.get("/")
+def read_root():
+    return {"status": "ok"}