fix

Dockerfile

@@ -17,4 +17,4 @@ EXPOSE 7860
 
 # --- CORRECTED COMMAND ---
 # This now correctly points to the 'app' variable inside the 'api/index.py' file
-CMD ["uvicorn", "api.index:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

api/index.py

@@ -1,29 +0,0 @@
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-# Absolute import from the project root
-from app.api.routes.recommendations import router as recommendations_router
-
-# This file is now the main entry point
-app = FastAPI(
-    title="Student Recommendation API",
-    description="API for student internship recommendations",
-    version="1.0.0"
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], # Allow all origins
-    allow_credentials=True,
-    allow_methods=["*"], # Allow all methods
-    allow_headers=["*"], # Allow all headers
-)
-
-@app.get("/", tags=["Root"])
-async def read_root():
-    """A simple endpoint to confirm the API is running."""
-    return {"message": "Welcome to the Student Recommendation API!"}
-
-# Include the routes from your recommendations module
-app.include_router(recommendations_router, prefix="/api")
-
-# The Vercel server will discover and run this 'app' object.

app/api/routes/recommendations.py

@@ -1,28 +1,15 @@
-from fastapi import APIRouter, HTTPException
-# --- Use absolute imports from 'app' ---
-from app.schemas.recommendation import RecommendationRequest, RecommendationResponse, CategoryResponse
-from app.services.ranking import get_ranked_internships, get_category_prediction
+from fastapi import APIRouter
+from ...schemas.recommendation import ProfileRequest, RecommendationRequest
+from ...services import ranking
 
 router = APIRouter()
 
-@router.post("/predict-category", response_model=CategoryResponse)
-def predict_category(request: RecommendationRequest):
-    """Predicts the job category based on the user's profile text."""
-    try:
-        predicted_category = get_category_prediction(request.profile_text)
-        return CategoryResponse(predicted_category=predicted_category)
-    except Exception as e:
-        # Log the error for debugging
-        print(f"Error in /predict-category: {e}")
-        raise HTTPException(status_code=500, detail="An error occurred during category prediction.")
+@router.post("/predict-category", tags=["Predictions"])
+def predict_category(request: ProfileRequest):
+    category = ranking.get_category_prediction(request.profile_text)
+    return {"predicted_category": category}
 
-@router.post("/rank-internships", response_model=RecommendationResponse)
-def rank_internships(request: RecommendationRequest):
-    """Ranks internships based on user profile and preferences."""
-    try:
-        ranked_ids = get_ranked_internships(request)
-        return RecommendationResponse(ranked_internship_ids=ranked_ids)
-    except Exception as e:
-        # Log the error for debugging
-        print(f"Error in /rank-internships: {e}")
-        raise HTTPException(status_code=500, detail="An error occurred during internship ranking.")
+@router.post("/recommend-internships", tags=["Predictions"])
+def recommend_internships(request: RecommendationRequest):
+    ranked_ids = ranking.get_ranked_internships(request)
+    return {"recommendations": ranked_ids}

app/core/models.py

@@ -1,89 +1,23 @@
-# app/core/models.py
-
 import joblib
 from sentence_transformers import SentenceTransformer
 import os
-import requests
-from huggingface_hub import snapshot_download
-
-TEMP_DIR = "/tmp"
-
-# --- Initialize models as None ---
-# They will be loaded into these global variables later.
-tfidf_vectorizer = None
-le = None
-rf_model = None
-sentence_model = None
-
-# This function remains the same
-def download_and_load_pkl_model(model_url, model_filename):
-    local_path = os.path.join(TEMP_DIR, model_filename)
-    if not os.path.exists(local_path):
-        print(f"Downloading model from {model_url} to {local_path}...")
-        try:
-            response = requests.get(model_url, stream=True)
-            response.raise_for_status()
-            with open(local_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            print("Download complete.")
-        except requests.exceptions.RequestException as e:
-            print(f"Failed to download model {model_filename}. Error: {e}")
-            return None
-    try:
-        return joblib.load(local_path)
-    except Exception as e:
-        print(f"Failed to load model {local_path}. Error: {e}")
-        return None
-
-# This function remains the same
-def get_sentence_transformer(model_name='all-MiniLM-L6-v2'):
-    local_model_path = os.path.join(TEMP_DIR, model_name)
-    if not os.path.exists(local_model_path):
-        print(f"Downloading SentenceTransformer model '{model_name}' to {local_model_path}...")
-        try:
-            snapshot_download(repo_id=f"sentence-transformers/{model_name}",
-                              local_dir=local_model_path,
-                              local_dir_use_symlinks=False)
-            print("Download complete.")
-        except Exception as e:
-            print(f"Failed to download SentenceTransformer model. Error: {e}")
-            return None
-    try:
-        print(f"Loading SentenceTransformer model from {local_model_path}...")
-        return SentenceTransformer(local_model_path)
-    except Exception as e:
-        print(f"Failed to load SentenceTransformer model from {local_model_path}. Error: {e}")
-        return None
-
-# --- NEW LAZY LOADING FUNCTION ---
-def load_all_models():
-    """
-    This function loads all models into the global variables.
-    It will only be called when the models are first needed.
-    """
-    global tfidf_vectorizer, le, rf_model, sentence_model
-    print("--- First request received, initiating model loading... ---")
 
-    # Load the classification models
-    TFIDF_URL = "https://pub-4a389a9b2dc842a2a55678d2db0ec0c6.r2.dev/tfidf_vectorizer.pkl"
-    LE_URL = "https://pub-4a389a9b2dc842a2a55678d2db0ec0c6.r2.dev/label_encoder.pkl"
-    RF_MODEL_URL = "https://pub-4a389a9b2dc842a2a55678d2db0ec0c6.r2.dev/random_forest_model.pkl"
+MODEL_DIR = "models"
 
-    tfidf_vectorizer = download_and_load_pkl_model(TFIDF_URL, "tfidf_vectorizer.pkl")
-    le = download_and_load_pkl_model(LE_URL, "label_encoder.pkl")
-    rf_model = download_and_load_pkl_model(RF_MODEL_URL, "random_forest_model.pkl")
+try:
+    tfidf_vectorizer = joblib.load(os.path.join(MODEL_DIR, "tfidf_vectorizer.pkl"))
+    le = joblib.load(os.path.join(MODEL_DIR, "label_encoder.pkl"))
+    rf_model = joblib.load(os.path.join(MODEL_DIR, "random_forest_model.pkl"))
+    print("Classification models loaded.")
 
-    if all([tfidf_vectorizer, le, rf_model]):
-        print("Classification models loaded successfully.")
-    else:
-        print("One or more classification models failed to load.")
+    sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
+    print("SentenceTransformer model loaded.")
 
-    # Load the sentence transformer
-    sentence_model = get_sentence_transformer()
-    if sentence_model:
-        print("SentenceTransformer model loaded successfully.")
-    else:
-        print("SentenceTransformer model failed to load.")
+except FileNotFoundError as e:
+    print(f"MODEL LOADING ERROR: {e}")
+    print("Make sure the .pkl files are in the 'models' directory.")
+    # In a real production app, you might want the app to exit or handle this more gracefully.
+    tfidf_vectorizer, le, rf_model, sentence_model = None, None, None, None
 
-    print("--- Model loading complete. ---")
+except Exception as e:
+    print(f"An unexpected error occurred during model loading: {e}")

app/main.py

@@ -0,0 +1,14 @@
+from fastapi import FastAPI
+from .api.routes import recommendations
+
+app = FastAPI(
+    title="Student Recommendation API",
+    description="An API that uses machine learning to predict job categories and recommend internships.",
+    version="1.0.0"
+)
+
+app.include_router(recommendations.router, prefix="/api/v1")
+
+@app.get("/", tags=["Root"])
+def read_root():
+    return {"message": "Welcome to the Student Recommendation API"}

app/services/ranking.py

@@ -1,82 +1,121 @@
-# app/services/ranking.py
-
 from geopy.distance import geodesic
 import json
 import os
 from geopy.geocoders import Nominatim
 
-# --- Use absolute imports from 'app' ---
-from app.core.models import load_all_models, tfidf_vectorizer, le, rf_model, sentence_model
-from app.schemas.recommendation import RecommendationRequest
-from app.utils.text import clean_resume
-
-print("--- Loading app/services/ranking.py module ---")
+from ..core.models import tfidf_vectorizer, le, rf_model, sentence_model
+from ..schemas.recommendation import RecommendationRequest
+from ..utils.text import clean_resume
 
-# This geo-caching logic is fine
 geolocator = Nominatim(user_agent="student_recommendation_api_v1")
+
 GEO_CACHE_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "GEO_CACHE.txt")
 GEO_CACHE = {}
-_geo_cache_loaded = False
 
 def load_geo_cache():
-    global GEO_CACHE, _geo_cache_loaded
-    if _geo_cache_loaded: return
+    global GEO_CACHE
     if os.path.exists(GEO_CACHE_FILE):
         with open(GEO_CACHE_FILE, "r") as f:
-            try: GEO_CACHE = json.load(f)
-            except json.JSONDecodeError: GEO_CACHE = {}
-    _geo_cache_loaded = True
+            try:
+                GEO_CACHE = json.load(f)
+            except json.JSONDecodeError:
+                GEO_CACHE = {}
 
 def save_geo_cache():
-    with open(GEO_CACHE_FILE, "w") as f: json.dump(GEO_CACHE, f)
+    with open(GEO_CACHE_FILE, "w") as f:
+        json.dump(GEO_CACHE, f)
+
+load_geo_cache()
 
 def geo_coords(city_name: str) -> tuple | None:
-    load_geo_cache()
+    """
+    Geocodes a city name to (latitude, longitude).
+    Uses an in-memory cache to avoid repeated API calls.
+    """
     city_name = city_name.lower().strip()
-    if city_name in GEO_CACHE: return GEO_CACHE[city_name]
+    if city_name in GEO_CACHE:
+        return GEO_CACHE[city_name]
     try:
+        print(f"--- Geocoding and caching new city: {city_name} ---")
         location = geolocator.geocode(f"{city_name}, Indonesia")
+
         if location:
             coords = (location.latitude, location.longitude)
             GEO_CACHE[city_name] = coords
             save_geo_cache()
             return coords
         else:
+            print(f"Location not found for {city_name}")
             GEO_CACHE[city_name] = None
             save_geo_cache()
             return None
-    except Exception: return None
+    except Exception as e:
+        print(f"Error geocoding {city_name}: {e}")
+        return None
 
 def get_category_prediction(profile_text: str) -> str:
-    if rf_model is None: load_all_models()
+    """Processes text and predicts the job category."""
     cleaned_text = profile_text.lower()
     vectorized_text = tfidf_vectorizer.transform([cleaned_text])
     prediction_encoded = rf_model.predict(vectorized_text)[0]
     category = le.inverse_transform([prediction_encoded])[0]
     return category
 
-def get_ranked_internships(request: RecommendationRequest) -> list[int]:
-    if sentence_model is None: load_all_models()
+def  get_ranked_internships(request: RecommendationRequest) -> list[int]:
+    """Performs two-stage ranking with dynamic geocoding."""
+
     profile_text_to_encode = request.profile_text
+
     if request.predicted_category:
         profile_text_to_encode = f"The user's predicted job category is {request.predicted_category}. Based on that, consider their profile: {request.profile_text}"
+
     profile_embedding = sentence_model.encode(profile_text_to_encode)
     internship_texts = [internship.internship_text for internship in request.internships]
-    if not internship_texts: return []
+
+    if not internship_texts:
+        return []
+
     internship_embeddings = sentence_model.encode(internship_texts)
     cosine_score = sentence_model.similarity(profile_embedding, internship_embeddings)[0].tolist()
-    ranked_by_similarity = [{"id": i.id, "similarity_score": s, "location": i.location} for i, s in zip(request.internships, cosine_score)]
+
+    print("--- FastAPI Debugging ---")
+    print(f"Received {len(internship_texts)} internships to rank.")
+    print(f"Calculated Cosine Scores: {cosine_score}")
+    print("--------------------------")
+
+    ranked_by_similarity = []
+    for i, internship in enumerate(request.internships):
+        ranked_by_similarity.append({
+            "id": internship.id,
+            "similarity_score": cosine_score[i],
+            "location": internship.location,
+        })
+
     final_ranked_list = []
     user_coords = geo_coords(request.preferred_location)
+
+    print(user_coords, request.preferred_location)
+
+
     for internship in ranked_by_similarity:
         final_score = internship['similarity_score']
+
         if user_coords:
             internship_coords = geo_coords(internship['location'])
             if internship_coords:
                 distance_km = geodesic(user_coords, internship_coords).kilometers
-                if distance_km < 1: final_score += 2.0
-                elif distance_km < 150: final_score += 0.75
+                if distance_km < 1:
+                    final_score += 2.0
+                elif distance_km < 150:
+                    final_score += 0.75
+
         internship['final_score'] = final_score
         final_ranked_list.append(internship)
+
     final_ranked_list.sort(key=lambda x: x['final_score'], reverse=True)
-    return [item['id'] for item in final_ranked_list]
+
+    final_ids = [item['id'] for item in final_ranked_list]
+
+    print(final_ranked_list)
+
+    return final_ids

models/label_encoder.pkl

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

models/random_forest_model.pkl

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

models/tfidf_vectorizer.pkl

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

requirements.txt

@@ -1,7 +1,6 @@
 # Core FastAPI Framework
 fastapi
 uvicorn
-requests
 
 # Machine Learning & Data
 scikit-learn
@@ -9,7 +8,7 @@ joblib
 sentence-transformers
 torch
 geopy
-huggingface-hub
+
 # Pydantic is a dependency of FastAPI, but we list it for clarity
 pydantic