Upload 6 files

Dockerfile

@@ -19,12 +19,6 @@ WORKDIR /app
 # This ensures the directory exists and is writable by the user running the process
 RUN mkdir -p /app/.cache && chmod -R 777 /app/.cache
 
-# --- Create the persistent storage mount point directory --- 
-# Create /data within the image and set permissions.
-# This only helps if HF Spaces actually mounts a writable volume here.
-RUN mkdir -p /data && chmod -R 777 /data
-# ---
-
 # Copy the requirements file into the container at /app
 COPY requirements.txt .
 

add_model_explanations.py

@@ -3,49 +3,36 @@ import json
 from typing import Dict, Any, Optional
 import logging
 import time
-# import google.generativeai as genai # Remove Gemini import
-from openai import OpenAI, APIError # Add back OpenAI imports
+from openai import OpenAI, APIError
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Define the base persistent storage path (must match other scripts)
-PERSISTENT_STORAGE_PATH = "/data" # <-- ADJUST IF YOUR PATH IS DIFFERENT
-
-# Point to the JSON data within persistent storage
-MODEL_DATA_DIR = os.path.join(PERSISTENT_STORAGE_PATH, "model_data_json")
+MODEL_DATA_DIR = "model_data_json"
 EXPLANATION_KEY = "model_explanation_gemini"
 DESCRIPTION_KEY = "description"
 MAX_RETRIES = 3 # Retries for API calls
 RETRY_DELAY_SECONDS = 5 # Delay between retries
 
-# --- DeepSeek API Configuration (Restored) ---
-DEEPSEEK_API_KEY_ENV_VAR = "DEEPSEEK_API_KEY" # Environment variable for the key
+# --- DeepSeek API Configuration ---
+DEEPSEEK_API_KEY_ENV_VAR = "DEEPSEEK_API_KEY"
 DEEPSEEK_BASE_URL = "https://api.deepseek.com"
 DEEPSEEK_MODEL_NAME = "deepseek-chat"
-# ---
-
-# Remove Gemini configuration
-# GEMINI_API_KEY_ENV_VAR = "GEMINI_API_KEY"
-# GEMINI_MODEL_NAME = "gemini-1.5-flash-latest"
 
-# Global client variable for DeepSeek/OpenAI client
-client: Optional[OpenAI] = None # Use OpenAI client type
-# gemini_model: Optional[genai.GenerativeModel] = None # Remove Gemini model variable
+# Global client variable
+client: Optional[OpenAI] = None
 
 def configure_llm_client():
     """Configures the OpenAI client for DeepSeek API using the API key from environment variables."""
     global client
-    # global gemini_model # Remove
-    api_key = os.getenv(DEEPSEEK_API_KEY_ENV_VAR) # Use DeepSeek env var
+    api_key = os.getenv(DEEPSEEK_API_KEY_ENV_VAR)
     if not api_key:
         logging.error(f"Error: {DEEPSEEK_API_KEY_ENV_VAR} environment variable not set.")
-        logging.error("Please set the environment variable with your DeepSeek API key before running the script.")
+        logging.error("Please set the environment variable before running the script.")
         return False
     try:
-        # Configure OpenAI client for DeepSeek
         client = OpenAI(api_key=api_key, base_url=DEEPSEEK_BASE_URL)
-        logging.info(f"DeepSeek API client configured successfully for model: {DEEPSEEK_MODEL_NAME}.")
+        logging.info("DeepSeek API client configured successfully.")
         return True
     except Exception as e:
         logging.error(f"Failed to configure DeepSeek API client: {e}")
@@ -66,8 +53,7 @@ def generate_explanation(model_id: str, description: str) -> Optional[str]:
     Returns:
         A short English explanation string from DeepSeek, or None if generation fails.
     """
-    global client # Use OpenAI client
-    # global gemini_model # Remove
+    global client
     if not client:
         logging.error(f"[{model_id}] DeepSeek client not configured. Cannot generate explanation.")
         return None
@@ -76,13 +62,13 @@ def generate_explanation(model_id: str, description: str) -> Optional[str]:
         logging.warning(f"[{model_id}] Description is empty or not a string. Skipping explanation generation.")
         return None
 
-    # Truncate very long descriptions (adjust limit back if needed for DeepSeek)
+    # Truncate very long descriptions
     max_desc_length = 4000
     if len(description) > max_desc_length:
         logging.warning(f"[{model_id}] Description truncated to {max_desc_length} chars for API call.")
         description = description[:max_desc_length] + "... [truncated]"
 
-    # Construct the messages for DeepSeek API (Restore original format)
+    # Construct the messages for DeepSeek API
     messages = [
         {"role": "system", "content": "You are an AI assistant tasked with summarizing Hugging Face model descriptions concisely."},        
         {"role": "user", "content": (
@@ -94,14 +80,10 @@ def generate_explanation(model_id: str, description: str) -> Optional[str]:
         )}
     ]
 
-    # Remove Gemini prompt construction
-    # prompt = (...) 
-
     retries = 0
     while retries < MAX_RETRIES:
         try:
             logging.info(f"[{model_id}] Calling DeepSeek API (Attempt {retries + 1}/{MAX_RETRIES})...")
-            # Use OpenAI client call format
             response = client.chat.completions.create(
                 model=DEEPSEEK_MODEL_NAME,
                 messages=messages,
@@ -110,20 +92,13 @@ def generate_explanation(model_id: str, description: str) -> Optional[str]:
                 temperature=0.2 # Lower temperature for more focused summary
             )
 
-            # Remove Gemini response handling
-            # if not response.candidates: ...
-            
-            explanation = response.choices[0].message.content.strip() # Get explanation from OpenAI response structure
+            explanation = response.choices[0].message.content.strip()
             logging.info(f"[{model_id}] Explanation received from DeepSeek: '{explanation}'")
-            
             # Basic post-processing: remove potential quotes
             if explanation.startswith('"') and explanation.endswith('"'):
                 explanation = explanation[1:-1]
-            # Remove Gemini specific post-processing
-            # explanation = explanation.replace('**', '') 
             return explanation
 
-        # Restore specific APIError catch for OpenAI client
         except APIError as e:
             retries += 1
             logging.error(f"[{model_id}] DeepSeek API Error (Attempt {retries}/{MAX_RETRIES}): {e}")
@@ -133,21 +108,14 @@ def generate_explanation(model_id: str, description: str) -> Optional[str]:
             else:
                 logging.error(f"[{model_id}] Max retries reached. Failed to generate explanation via DeepSeek.")
                 return None
-        # Keep general Exception catch
-        except Exception as e:
-            retries += 1 # Consider retrying general errors too or handle differently
-            logging.error(f"[{model_id}] Unexpected Error during API call (Attempt {retries}/{MAX_RETRIES}): {e}")
-            if retries < MAX_RETRIES:
-                 logging.info(f"Retrying in {RETRY_DELAY_SECONDS} seconds...")
-                 time.sleep(RETRY_DELAY_SECONDS)
-            else:
-                logging.error(f"[{model_id}] Max retries reached. Failed to generate explanation due to unexpected errors.")
-                return None
+        except Exception as e: # Catch other potential errors
+            logging.error(f"[{model_id}] Unexpected error during DeepSeek API call: {e}")
+            return None # Don't retry for unexpected errors
 
-    return None # Should not be reached if loop finishes without returning
+    return None
 
 def process_json_file(filepath: str):
-    """Reads, updates (only if explanation missing), and writes a single JSON file."""
+    """Reads, updates, and writes a single JSON file."""
     model_id = os.path.basename(filepath).replace('.json', '')
     logging.info(f"Processing {filepath}...")
 
@@ -156,58 +124,58 @@ def process_json_file(filepath: str):
             data = json.load(f)
     except json.JSONDecodeError:
         logging.error(f"[{model_id}] Invalid JSON format in {filepath}. Skipping.")
-        return False # Indicate failure/skip
+        return
     except FileNotFoundError:
         logging.error(f"[{model_id}] File not found: {filepath}. Skipping.")
-        return False
+        return
     except Exception as e:
         logging.error(f"[{model_id}] Error reading {filepath}: {e}. Skipping.")
-        return False
+        return
 
     if not isinstance(data, dict):
         logging.error(f"[{model_id}] Expected JSON object (dict) but got {type(data)} in {filepath}. Skipping.")
-        return False
+        return
 
-    # --- Check if explanation already exists ---
-    existing_explanation = data.get(EXPLANATION_KEY)
-    logging.debug(f"[{model_id}] Checking for existing explanation. Key: '{EXPLANATION_KEY}'. Found value: '{existing_explanation}' (Type: {type(existing_explanation)})")
-    if existing_explanation: # Simplified check: Checks for non-empty string, non-None
-        logging.info(f"[{model_id}] Explanation already exists. Skipping generation.")
-        return False # Indicate no update was needed
+    description = data.get(DESCRIPTION_KEY)
+    explanation_overwritten = False
 
-    # --- Deletion Logic REMOVED ---
-    # if EXPLANATION_KEY in data: ...
+    # --- Deletion Logic: Always remove existing explanation before trying to regenerate ---
+    if EXPLANATION_KEY in data:
+        logging.info(f"[{model_id}] Existing explanation found. Deleting before regenerating.")
+        del data[EXPLANATION_KEY]
+        explanation_overwritten = True # Mark that we intend to replace it
 
     # --- Generation Logic ---
-    logging.info(f"[{model_id}] Existing explanation is missing or empty. Proceeding with generation.")
-    description = data.get(DESCRIPTION_KEY)
     if not description:
          logging.warning(f"[{model_id}] Description field is missing or empty. Cannot generate explanation.")
-         return False # Cannot generate, so no update possible
+         return
 
     explanation = generate_explanation(model_id, description) # Try to generate a new one
 
-    # --- Update and Write Logic ---
+    # --- Update and Write Logic ---    
     if explanation: # Only update if generation was successful
         data[EXPLANATION_KEY] = explanation
         try:
             with open(filepath, 'w', encoding='utf-8') as f:
                 json.dump(data, f, ensure_ascii=False, indent=4)
-            logging.info(f"[{model_id}] Successfully generated and updated {filepath} with new explanation.")
-            return True # Indicate success/update
+            if explanation_overwritten:
+                 logging.info(f"[{model_id}] Successfully overwrote and updated {filepath} with new explanation.")
+            else:
+                 logging.info(f"[{model_id}] Successfully generated and updated {filepath} with new explanation.")
         except IOError as e:
             logging.error(f"[{model_id}] Error writing updated data to {filepath}: {e}")
-            return False
         except Exception as e:
             logging.error(f"[{model_id}] Unexpected error writing {filepath}: {e}")
-            return False
     else: # Explanation generation failed
-         logging.warning(f"[{model_id}] Failed to generate new explanation for {filepath} via API. File not updated.")
-         return False # Indicate failure/no update
+         log_message = f"[{model_id}] Failed to generate new explanation for {filepath} via API."
+         if explanation_overwritten:
+             log_message += " Existing explanation was removed but not replaced due to API failure."
+         logging.warning(log_message)
 
 
 def main():
     """Main function to iterate through the directory and process files."""
+    # Configure LLM client at the start
     if not configure_llm_client():
         return # Stop if API key is not configured
 
@@ -217,9 +185,8 @@ def main():
 
     logging.info(f"Starting processing directory: {MODEL_DATA_DIR}")
     processed_files = 0
-    updated_files = 0 # Count files actually updated
-    skipped_existing = 0 # Count files skipped because explanation existed
-    skipped_error = 0 # Count files skipped due to read/write/API errors or no description
+    updated_files = 0
+    skipped_files = 0
 
     all_files = [f for f in os.listdir(MODEL_DATA_DIR) if f.lower().endswith(".json")]
     total_files = len(all_files)
@@ -229,32 +196,29 @@ def main():
         filepath = os.path.join(MODEL_DATA_DIR, filename)
         logging.info(f"--- Processing file {i+1}/{total_files}: {filename} ---")
         try:
-            # process_json_file now returns True if updated, False otherwise
-            updated = process_json_file(filepath)
-            processed_files += 1
-            if updated:
-                updated_files += 1
-            else:
-                # Need to differentiate why it wasn't updated. Re-read is inefficient.
-                # Let's rely on logs from process_json_file for now.
-                # A better way would be for process_json_file to return status codes.
-                pass # Logging within the function indicates reason (skipped existing, API fail, etc.)
+            # Check if explanation exists before calling process_json_file
+            # to potentially save API calls if already done.
+            # However, process_json_file already has this check.
+            process_json_file(filepath)
+            processed_files +=1 # Count as processed even if skipped due to existing explanation
+
+            # Check if file was actually updated (optional metric)
+            # Re-read might be inefficient, could return status from process_json_file
+            # For simplicity, we just log success/failure in process_json_file
 
         except Exception as e:
-            logging.error(f"Unexpected error processing file loop for {filename}: {e}")
-            skipped_error += 1 # Count generic loop errors
+            logging.error(f"Unexpected error processing file {filename}: {e}")
+            skipped_files += 1
         # Add a small delay between files to potentially avoid hitting rate limits
-        # Adjust delay based on Gemini quota/limits (might need less than 0.5s)
-        time.sleep(0.2)
+        time.sleep(0.5) # Adjust delay as needed
 
 
     logging.info(f"--- Processing complete ---")
+    # Refine reporting slightly
     logging.info(f"Total JSON files found: {total_files}")
     logging.info(f"Files processed (attempted): {processed_files}")
-    logging.info(f"Files successfully updated with new explanation: {updated_files}")
-    # Cannot precisely count skipped_existing vs skipped_error without better return values
-    # logging.info(f"Files skipped (existing explanation, errors, or no description): {total_files - updated_files}")
-
+    # A more accurate count of updated files would require modifying process_json_file to return status
+    logging.info(f"Files skipped due to unexpected errors: {skipped_files}")
 
 if __name__ == "__main__":
     main() 

app.py

@@ -5,39 +5,17 @@ from flask_cors import CORS
 import numpy as np
 import json
 import traceback
-import logging # Added for background task logging
-import threading # Added for background task
-import time # Added for background task
-import schedule # Added for background task
-
-# --- Import the daily update function --- 
-try:
-    from daily_update import main as run_daily_update
-    # Set up logging for the daily_update module if it uses logging
-    # logging.getLogger('daily_update').setLevel(logging.INFO) # Example
-except ImportError:
-    logging.error("Failed to import daily_update.py. The daily update task will not run.")
-    run_daily_update = None # Define as None if import fails
-# ---
 
 app = Flask(__name__) # Create app object FIRST
-
-# Define the base persistent storage path (must match other scripts)
-PERSISTENT_STORAGE_PATH = "/data" # <-- ADJUST IF YOUR PATH IS DIFFERENT
-
-# Configure Flask app logging (optional but recommended)
-# app.logger.setLevel(logging.INFO)
-
 # Allow requests from the Vercel frontend and localhost for development
 CORS(app, origins=["http://127.0.0.1:3000", "http://localhost:3000", "https://rag-huggingface.vercel.app"], supports_credentials=True)
 
 # --- Configuration ---
-# Point to index/map files in persistent storage
-INDEX_FILE = os.path.join(PERSISTENT_STORAGE_PATH, "index.faiss")
-MAP_FILE = os.path.join(PERSISTENT_STORAGE_PATH, "index_to_metadata.pkl")
+INDEX_FILE = "index.faiss"
+MAP_FILE = "index_to_metadata.pkl"
 EMBEDDING_MODEL = 'all-mpnet-base-v2'
-# Point to model data JSON in persistent storage
-MODEL_DATA_DIR = os.path.join(PERSISTENT_STORAGE_PATH, "model_data_json")
+# Corrected path joining for model_data_json - relative to app.py location
+MODEL_DATA_DIR = os.path.join(os.path.dirname(__file__), 'model_data_json')
 # ---
 
 # --- Global variables for resources ---
@@ -76,8 +54,7 @@ def load_resources():
         print("Sentence transformer model loaded successfully.")
 
         # Load FAISS Index
-        # index_path = os.path.join(os.path.dirname(__file__), INDEX_FILE) # Old path
-        index_path = INDEX_FILE # Use configured path
+        index_path = os.path.join(os.path.dirname(__file__), INDEX_FILE)
         print(f"Loading FAISS index from: {index_path}")
         if not os.path.exists(index_path):
              raise FileNotFoundError(f"FAISS index file not found at {index_path}")
@@ -86,8 +63,7 @@ def load_resources():
         print("FAISS index loaded successfully.")
 
         # Load Index-to-Metadata Map
-        # map_path = os.path.join(os.path.dirname(__file__), MAP_FILE) # Old path
-        map_path = MAP_FILE # Use configured path
+        map_path = os.path.join(os.path.dirname(__file__), MAP_FILE)
         print(f"Loading index-to-Metadata map from: {map_path}")
         if not os.path.exists(map_path):
             raise FileNotFoundError(f"Metadata map file not found at {map_path}")
@@ -101,8 +77,8 @@ def load_resources():
 
     except FileNotFoundError as fnf_error:
         print(f"Error: {fnf_error}")
-        print(f"Please ensure {os.path.basename(INDEX_FILE)} and {os.path.basename(MAP_FILE)} exist in the persistent storage directory ({PERSISTENT_STORAGE_PATH}).")
-        print("You might need to run the update process first or manually place initial files there.")
+        print(f"Please ensure {INDEX_FILE} and {MAP_FILE} exist in the 'backend' directory relative to app.py.")
+        print("You might need to run 'python build_index.py' first.")
         RESOURCES_LOADED = False # Keep as False
     except ImportError as import_error:
          print(f"Import Error loading resources: {import_error}")
@@ -118,71 +94,6 @@ def load_resources():
 load_resources()
 # ---
 
-# --- Background Update Task --- 
-
-UPDATE_INTERVAL_HOURS = 24 # Check every 24 hours
-UPDATE_TIME = "02:00" # Time to run the update (24-hour format)
-
-def run_update_task():
-    """Wrapper function to run the daily update and handle errors."""
-    if run_daily_update is None:
-        logging.warning("run_daily_update function not available (import failed). Skipping task.")
-        return
-
-    logging.info(f"Background task: Starting daily update check (scheduled for {UPDATE_TIME})...")
-    try:
-        # Make sure the DEEPSEEK_API_KEY is set before running
-        if not os.getenv("DEEPSEEK_API_KEY"):
-            logging.error("Background task: DEEPSEEK_API_KEY not set. Daily update cannot run.")
-            return # Don't run if key is missing
-
-        run_daily_update() # Call the main function from daily_update.py
-        logging.info("Background task: Daily update process finished.")
-    except Exception as e:
-        logging.error(f"Background task: Error during daily update execution: {e}")
-        logging.error(traceback.format_exc())
-
-def background_scheduler():
-    """Runs the scheduler loop in a background thread."""
-    logging.info(f"Background scheduler started. Will run update task daily around {UPDATE_TIME}.")
-    
-    if run_daily_update is None:
-        logging.error("Background scheduler: daily_update.py could not be imported. Scheduler will not run tasks.")
-        return # Stop the thread if the core function isn't available
-
-    # Schedule the job
-    # schedule.every(UPDATE_INTERVAL_HOURS).hours.do(run_update_task) # Alternative: run every X hours
-    schedule.every().day.at(UPDATE_TIME).do(run_update_task)
-    logging.info(f"Scheduled daily update task for {UPDATE_TIME}.")
-
-    # --- Run once immediately on startup --- 
-    logging.info("Background task: Running initial update check on startup...")
-    run_update_task() # Call the task function directly
-    logging.info("Background task: Initial update check finished.")
-    # ---
-
-    while True:
-        schedule.run_pending()
-        time.sleep(60) # Check every 60 seconds if a task is due
-
-# Start the background scheduler thread only if this is the main process
-# This check helps prevent duplicate schedulers when using workers (like Gunicorn)
-# Note: This might not be perfectly reliable with all WSGI servers/configs.
-# Consider using a more robust method for ensuring single execution if needed (e.g., file lock, external process manager)
-if os.environ.get("WERKZEUG_RUN_MAIN") == "true" or os.environ.get("FLASK_ENV") != "development":
-    # Start only in main Werkzeug process OR if not in Flask development mode (like production with Gunicorn)
-    # Check if the function is available before starting thread
-    if run_daily_update is not None:
-        scheduler_thread = threading.Thread(target=background_scheduler, daemon=True)
-        scheduler_thread.start()
-        logging.info("Background scheduler thread started.")
-    else:
-        logging.warning("Background scheduler thread NOT started because daily_update.py failed to import.")
-else:
-    logging.info("Skipping background scheduler start in Werkzeug reloader process.")
-
-# --- End Background Update Task ---
-
 @app.route('/search', methods=['POST'])
 def search():
     """Handles search requests, embedding the query and searching the FAISS index."""
@@ -241,7 +152,7 @@ def search():
                 # --- Add description from model_data_json ---
                 model_id = metadata.get('model_id')
                 description = None
-                # Use the globally defined MODEL_DATA_DIR pointing to persistent storage
+                # Use the globally defined and corrected MODEL_DATA_DIR
                 if model_id and MODEL_DATA_DIR:
                     filename = model_id.replace('/', '_') + '.json'
                     filepath = os.path.join(MODEL_DATA_DIR, filename)

build_index.py

@@ -7,15 +7,10 @@ import pickle
 import json # Import json module
 from tqdm import tqdm
 
-# Define the base persistent storage path (must match other scripts)
-PERSISTENT_STORAGE_PATH = "/data" # <-- ADJUST IF YOUR PATH IS DIFFERENT
-
 # --- Configuration ---
-# Point to the JSON data within persistent storage
-MODEL_DATA_DIR = os.path.join(PERSISTENT_STORAGE_PATH, "model_data_json")
-# Save index and map to persistent storage
-INDEX_FILE = os.path.join(PERSISTENT_STORAGE_PATH, "index.faiss")
-MAP_FILE = os.path.join(PERSISTENT_STORAGE_PATH, "index_to_metadata.pkl")
+MODEL_DATA_DIR = "model_data_json"  # Path to downloaded JSON data
+INDEX_FILE = "index.faiss"
+MAP_FILE = "index_to_metadata.pkl" # Changed filename to reflect content
 EMBEDDING_MODEL = 'all-mpnet-base-v2'  # Efficient and good quality model
 ENCODE_BATCH_SIZE = 32  # Process descriptions in smaller batches
 # Tags to exclude from indexing text

huggingface_model_descriptions.py

@@ -10,11 +10,8 @@ from requests.exceptions import RequestException
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import pickle # Add pickle for caching
 
-# Define the base persistent storage path
-PERSISTENT_STORAGE_PATH = "/data" # <-- ADJUST IF YOUR PATH IS DIFFERENT
-
-# Create a directory to store JSON data within persistent storage
-OUTPUT_DIR = os.path.join(PERSISTENT_STORAGE_PATH, "model_data_json")
+# Create a directory to store JSON data
+OUTPUT_DIR = "model_data_json"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 # Number of worker threads for parallel processing - REDUCED
@@ -44,8 +41,7 @@ def clean_readme_content(text):
     return text
 # ---
 
-# Use persistent storage for the cache file
-MODELS_CACHE_FILE = os.path.join(PERSISTENT_STORAGE_PATH, "models_list_cache.pkl") # File to cache the raw model list
+MODELS_CACHE_FILE = "models_list_cache.pkl" # File to cache the raw model list
 
 def get_all_models_with_downloads(min_downloads=10000):
     """Fetch all models from Hugging Face with at least min_downloads, using a local cache for the list."""
@@ -70,7 +66,7 @@ def get_all_models_with_downloads(min_downloads=10000):
             api = HfApi()
             print("HfApi initialized. Calling list_models...")
             # Fetch the iterator
-            models_iterator = api.list_models(sort="downloads", direction=-1, fetch_config=False, cardData=False)
+            models_iterator = api.list_models(sort="downloads", direction=-1, fetch_config=False, cardData=True)
             print("list_models call returned. Converting iterator to list...")
             # Convert the iterator to a list TO ALLOW CACHING
             models_list = list(models_iterator)
@@ -158,9 +154,9 @@ def get_model_readme(model_id):
     return None
 
 def get_filename_for_model(model_id):
-    """Generate JSON filename for a model (uses global OUTPUT_DIR)"""
+    """Generate JSON filename for a model"""
     safe_id = model_id.replace("/", "_")
-    return os.path.join(OUTPUT_DIR, f"{safe_id}.json") # OUTPUT_DIR is already correct path
+    return os.path.join(OUTPUT_DIR, f"{safe_id}.json") # Change extension to .json
 
 def save_model_data(model_id, data):
     """Save model data (description, tags, downloads) to a JSON file."""

requirements.txt

@@ -4,6 +4,4 @@ sentence-transformers>=2.3.0
 numpy>=1.20.0
 faiss-cpu>=1.7.0 # Use faiss-gpu if you need GPU support on HF Spaces
 huggingface-hub>=0.15.1 # Version compatible with sentence-transformers >= 2.3.0
-gunicorn # Added for deployment on Hugging Face Spaces 
-openai>=1.0.0 # Added back for DeepSeek API via OpenAI client
-schedule>=1.0.0 # Added for in-app scheduling 
+gunicorn # Added for deployment on Hugging Face Spaces