updated code

.gitignore

@@ -1 +1,3 @@
-.env
+.env
+categories.json
+categories.index

app.py

@@ -1,28 +1,27 @@
 from flask import Flask, request, jsonify, render_template
-from sentence_transformers import SentenceTransformer
 import faiss, numpy as np, pickle, os
 from openai import OpenAI
 from dotenv import load_dotenv
-from build_index import build_faiss_index  # <-- import your function
 
 load_dotenv()
 app = Flask(__name__)
 
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
 INDEX_PATH = "categories.index"
 META_PATH = "categories_meta.pkl"
 
-# Automatically build the index if missing
-if not (os.path.exists(INDEX_PATH) and os.path.exists(META_PATH)):
-    print("⚠️ Index not found — building now...")
-    build_faiss_index()
-
-# Load model, index, metadata
-model = SentenceTransformer("all-MiniLM-L6-v2")
+# Load FAISS + metadata
 index = faiss.read_index(INDEX_PATH)
 with open(META_PATH, "rb") as f:
     categories = pickle.load(f)
 
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+def embed_query(text, model="text-embedding-3-large"):
+    resp = client.embeddings.create(
+        model=model,
+        input=text
+    )
+    return np.array(resp.data[0].embedding, dtype="float32").reshape(1, -1)
 
 def ask_openai(product_text, candidates):
     prompt = f"""
@@ -31,43 +30,54 @@ You are a product category classifier.
 Product details:
 {product_text}
 
-Here are the most relevant candidate categories:
+Candidate categories:
 {chr(10).join([f"- {c}" for c in candidates])}
 
-Choose the single most accurate category path from the list above.
-Return ONLY the exact category path text.
+Choose the single best category.
+Return ONLY the exact category path.
 """
-    response = client.chat.completions.create(
+    resp = client.chat.completions.create(
         model="gpt-4o-mini",
-        messages=[{"role": "user", "content": prompt}],
         temperature=0.2,
+        messages=[{"role": "user", "content": prompt}]
     )
-    return response.choices[0].message.content.strip()
-
-@app.route("/")
-def home():
-    return render_template("index.html")
+    return resp.choices[0].message.content.strip()
 
 @app.route("/predict-category", methods=["POST"])
 def predict_category():
     data = request.json
+
     title = data.get("title", "")
     description = data.get("description", "")
-    text = f"{title}. {description}"
-
-    # Embed query
-    query_vec = model.encode([text], convert_to_numpy=True)
-
-    # Search FAISS index
-    D, I = index.search(np.array(query_vec, dtype=np.float32), 10)
+    product_type = data.get("product_type", "")
+    tags = data.get("tags", [])
+
+    # Handle tags if passed as a list OR comma-separated string
+    if isinstance(tags, list):
+        tags_text = ", ".join(tags)
+    else:
+        tags_text = str(tags)
+
+    # Combine everything into a single rich text block
+    text = f"""
+Title: {title}
+Description: {description}
+Product Type: {product_type}
+Tags: {tags_text}
+""".strip()
+
+    # Embed using OpenAI
+    query_vec = embed_query(text)
+
+    # Search FAISS
+    D, I = index.search(query_vec, 10)
     candidates = [categories[i]["category_path"] for i in I[0]]
-
-    # Compute confidence
+    print(candidates)
+    # Confidence scoring
     sims = 1 / (1 + D[0])
     confidences = (sims - sims.min()) / (sims.max() - sims.min() + 1e-9)
-    confidence = float(confidences[0])
 
-    # Get GPT refinement
+    # GPT refinement
     final_category = ask_openai(text, candidates)
 
     return jsonify({
@@ -76,8 +86,13 @@ def predict_category():
             {"category": c, "confidence": float(conf)}
             for c, conf in zip(candidates[:5], confidences[:5])
         ],
-        "final_confidence": round(confidence, 3)
+        "final_confidence": float(confidences[0])
     })
 
+@app.route("/")
+def home():
+    return render_template("index.html")
+
+
 if __name__ == "__main__":
     app.run(debug=True)

build_index.py

@@ -1,76 +1,61 @@
 import json
 import numpy as np
 import faiss
-from sentence_transformers import SentenceTransformer
 import pickle
-from tqdm import tqdm
 import os
+from tqdm import tqdm
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+def embed_text(texts, model="text-embedding-3-large"):
+    embeddings = []
+    for t in tqdm(texts, desc="Creating OpenAI embeddings"):
+        resp = client.embeddings.create(
+            model=model,
+            input=t
+        )
+        embeddings.append(resp.data[0].embedding)
+    return np.array(embeddings).astype("float32")
+
 
 def build_faiss_index(
     json_path="categories.json",
     index_path="categories.index",
     meta_path="categories_meta.pkl",
-    model_name="all-MiniLM-L6-v2",
-    batch_size=256
 ):
-    """
-    Builds a FAISS index from a category JSON file.
-
-    Args:
-        json_path (str): Path to the JSON file containing category data.
-        index_path (str): Path to save the FAISS index file.
-        meta_path (str): Path to save the metadata pickle file.
-        model_name (str): SentenceTransformer model name.
-        batch_size (int): Batch size for encoding.
-
-    Returns:
-        tuple: (index_path, meta_path)
-    """
-    print("🔧 Building FAISS index...")
-
-    # Load categories
+    print("🔧 Loading categories...")
     if not os.path.exists(json_path):
-        raise FileNotFoundError(f"❌ JSON file not found: {json_path}")
+        raise FileNotFoundError(f"❌ JSON missing: {json_path}")
+
     with open(json_path, "r", encoding="utf-8") as f:
         categories = json.load(f)
 
     texts = [c["category_path"] for c in categories]
     print(f"📦 Total categories: {len(texts)}")
 
-    # Load model
-    model = SentenceTransformer(model_name)
-    embeddings = []
-
-    total_batches = (len(texts) + batch_size - 1) // batch_size
-    print(f"⚙️ Encoding in {total_batches} batches...")
-
-    for i in range(0, len(texts), batch_size):
-        current_batch = i // batch_size + 1
-        print(f"🚀 Batch {current_batch}/{total_batches}")
-        batch = texts[i:i + batch_size]
-        batch_embeddings = model.encode(batch, convert_to_numpy=True, show_progress_bar=False)
-        embeddings.append(batch_embeddings)
-
-    embeddings = np.vstack(embeddings)
+    print("⚙️ Creating OpenAI embeddings…")
+    embeddings = embed_text(texts)
 
     # Build FAISS index
     dim = embeddings.shape[1]
     index = faiss.IndexFlatL2(dim)
     index.add(embeddings)
 
-    # Save index + metadata
     faiss.write_index(index, index_path)
+
     with open(meta_path, "wb") as f:
         pickle.dump(categories, f)
 
-    print(f"\n✅ FAISS index built successfully!")
-    print(f"📁 Index saved at: {index_path}")
-    print(f"📁 Metadata saved at: {meta_path}")
-    print(f"📊 Total categories: {len(categories)} | Embedding dimension: {dim}")
+    print("\n✅ OpenAI + FAISS index created!")
+    print(f"📁 Index: {index_path}")
+    print(f"📁 Metadata: {meta_path}")
+    print(f"📊 Embedding dim: {dim}")
 
     return index_path, meta_path
 
 
-# Optional: run directly to build index
 if __name__ == "__main__":
     build_faiss_index()

categories_meta.pkl

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