updated config and ultils to include sentence_transformer for score, re-added gemma for summarization

config.py

@@ -3,6 +3,7 @@ from dotenv import load_dotenv
 from supabase import create_client
 import requests
 import time
+from sentence_transformers import SentenceTransformer  # Import the transformer model
 
 # Load environment variables from .env file
 load_dotenv()
@@ -14,33 +15,33 @@ if not SUPABASE_KEY:
     raise ValueError("SUPABASE_KEY is not set in the environment variables.")
 supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-# Hugging Face API Config
+# Load Sentence Transformer Model (scoring)
+embedding_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+
 HF_MODELS = {
-    "gemma": "https://api-inference.huggingface.co/models/google/gemma-7b",
-    "bart": "https://api-inference.huggingface.co/models/facebook/bart-large-cnn"
+    "gemma": "https://router.huggingface.co/hf-inference/models/Falconsai/text_summarization"
 }
 
 HF_API_TOKEN = os.getenv("HF_API_TOKEN")
 if not HF_API_TOKEN:
     raise ValueError("Missing Hugging Face API key. Check your .env file.")
 
-# Correct API Headers
 HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
 
 def query(payload, model="gemma", retries=3, delay=5):
     """
     Sends a request to the Hugging Face API with retries.
-
+    
     :param payload: The input data for inference.
-    :param model: The model name ('gemma' or 'bart').
+    :param model: The model name ('gemma' for summarization).
     :param retries: Number of times to retry if the request fails.
     :param delay: Delay in seconds before retrying.
     :return: The model's response in JSON format, or None if all retries fail.
     """
     if model not in HF_MODELS:
-        raise ValueError("Invalid model name. Choose 'gemma' or 'bart'.")
+        raise ValueError("Invalid model name. Choose 'gemma' for summarization.")
 
-    api_url = HF_MODELS[model]  # Correct model URL
+    api_url = HF_MODELS[model]
 
     for attempt in range(retries):
         try:
@@ -48,20 +49,23 @@ def query(payload, model="gemma", retries=3, delay=5):
 
             if response.status_code == 401:
                 print(f"Error querying Hugging Face model '{model}': 401 Unauthorized. Check API key.")
-                return None  # API key issue
+                return None
+
+            if response.status_code == 402:
+                print(f"Error querying Hugging Face model '{model}': 402 Payment Required. Free tier may not support this model.")
+                return None
 
             if response.status_code == 500:
                 print(f"Server error (500) on attempt {attempt + 1}. Retrying in {delay} seconds...")
-                time.sleep(delay)  # Wait before retrying
-                continue  # Retry the request
-
-            response.raise_for_status()  # Raise an error for failed requests (except 500)
+                time.sleep(delay)
+                continue
 
-            return response.json()  # Return the parsed JSON response
+            response.raise_for_status()
+            return response.json()
 
         except requests.exceptions.RequestException as e:
             print(f"Error querying Hugging Face model '{model}': {e}")
-            time.sleep(delay)  # Wait before retrying
+            time.sleep(delay)
 
     print("All retry attempts failed.")
-    return None  # Return None if all retries fail
+    return None

utils.py

@@ -4,9 +4,10 @@ import json
 import re
 from io import BytesIO
 import supabase
-from config import SUPABASE_URL, SUPABASE_KEY, HF_API_TOKEN, HF_HEADERS, supabase, HF_MODELS, query
+from config import SUPABASE_URL, SUPABASE_KEY, HF_API_TOKEN, HF_HEADERS, supabase, HF_MODELS, query, embedding_model
+from sentence_transformers import SentenceTransformer, util
 
-# These functions will be called in the main.py file
+# These functions will be called in the app.py file
 
 def evaluate_resumes(uploaded_files, job_description):
     """Evaluates uploaded resumes and returns shortlisted candidates."""
@@ -45,54 +46,54 @@ def extract_email(resume_text):
 
 def score_candidate(resume_text, job_description):
     """
-    Scores the candidate's resume based on the job description using the Hugging Face API.
+    Scores the candidate's resume based on the job description using sentence-transformers.
     
     :param resume_text: The extracted resume text.
     :param job_description: The job description for comparison.
-    :return: A numerical score (default 0 if scoring fails).
+    :return: A numerical score (cosine similarity between 0 and 1).
     """
-    payload = {"inputs": f"Resume: {resume_text}\nJob Description: {job_description}"}
-    response_gemma = query(payload, model="gemma")  # Call Hugging Face API
-
-    if response_gemma is None:
-        print("API response is None")
-        return 0  
+    try:
+        # Generate embeddings
+        resume_embedding = embedding_model.encode(resume_text, convert_to_tensor=True)
+        job_embedding = embedding_model.encode(job_description, convert_to_tensor=True)
 
-    print("API Response:", response_gemma)  # Debugging
+        # Compute cosine similarity
+        score = util.pytorch_cos_sim(resume_embedding, job_embedding).item()
 
-    # Handle list response
-    if isinstance(response_gemma, list) and len(response_gemma) > 0:
-        response_gemma = response_gemma[0]  # Extract first item if response is a list
+        return round(score, 4)  # Return similarity score rounded to 4 decimal places
 
-    try:
-        if isinstance(response_gemma, dict) and "score" in response_gemma:
-            return float(response_gemma["score"])
-        else:
-            print("Unexpected API response format:", response_gemma)  # Debugging
-            return 0  # Default if score is missing
-    except (TypeError, ValueError) as e:
-        print(f"Error parsing score: {e}")
-        return 0  
+    except Exception as e:
+        print(f"Error computing similarity score: {e}")
+        return 0  # Return 0 if scoring fails
 
-# summarize_resume function will use HuggingFace BART model
 def summarize_resume(resume_text):
     """
-    Summarizes the resume using Facebook's BART-Large-CNN model.
+    Summarizes a resume using the Google gemma model.
     
-    :param resume_text: The extracted resume text.
-    :return: A summarized version of the resume or an error message.
+    :param resume_text: The resume text to summarize.
+    :return: A summarized version of the resume.
     """
-    payload = {"inputs": resume_text}
-    response_bart = query(payload, model="bart")
+    payload = {"inputs": f"Summarize this resume: {resume_text}"}
+    
+    response = query(payload, model="gemma")  # Use gemma for summarization
+
+    if response is None:
+        print("Error: API response is None")
+        return "Summary could not be generated."
 
-    if response_bart is None:
-        return "Summary could not be generated."  # Handle API failures gracefully
+    # If the response is a list, extract the first element
+    if isinstance(response, list) and len(response) > 0:
+        response = response[0]
 
     try:
-        summary = response_bart[0].get("summary_text", "Summary not available.")
-        return summary
-    except (IndexError, KeyError):
-        return "Summary not available."
+        if isinstance(response, dict) and "generated_text" in response:
+            return response["generated_text"]
+        else:
+            print("Unexpected API response format:", response)
+            return "Summary could not be generated."
+    except (TypeError, ValueError) as e:
+        print(f"Error parsing summary: {e}")
+        return "Summary could not be generated."
 
 def store_in_supabase(resume_text, score, candidate_name, email, summary):
     """