Add application file

.gitignore

@@ -1,2 +1,2 @@
-__pycache__
-venv
+__pycache__
+venv

Dockerfile

@@ -1,20 +1,20 @@
-# Use an official Python runtime as a parent image
-FROM python:3.9-slim
-
-# Set the working directory in the container
-WORKDIR /app
-
-# Copy the requirements file and install dependencies first to leverage caching
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy all of your project files from the repository into the container
-COPY . .
-
-# Tell Docker that the container listens on port 7860
-# Hugging Face Spaces expects applications to run on this port
-EXPOSE 7860
-
-# Define the command to run your app
-# This assumes your main file is `main.py` and the FastAPI variable is `app`
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file and install dependencies first to leverage caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all of your project files from the repository into the container
+COPY . .
+
+# Tell Docker that the container listens on port 7860
+# Hugging Face Spaces expects applications to run on this port
+EXPOSE 7860
+
+# Define the command to run your app
+# This assumes your main file is `main.py` and the FastAPI variable is `app`
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Kevin Bramasta Arvyto Wardhana
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Kevin Bramasta Arvyto Wardhana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

api/index.py

@@ -1 +1 @@
-from app.main import app
+from app.main import app

app/api/routes/recommendations.py

@@ -1,15 +1,15 @@
-from fastapi import APIRouter
-from ...schemas.recommendation import ProfileRequest, RecommendationRequest
-from ...services import ranking
-
-router = APIRouter()
-
-@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("/recommend-internships", tags=["Predictions"])
-def recommend_internships(request: RecommendationRequest):
-    ranked_ids = ranking.get_ranked_internships(request)
-    return {"recommendations": ranked_ids}
+from fastapi import APIRouter
+from ...schemas.recommendation import ProfileRequest, RecommendationRequest
+from ...services import ranking
+
+router = APIRouter()
+
+@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("/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,85 +1,85 @@
-import joblib
-from sentence_transformers import SentenceTransformer
-import os
-import requests
-from huggingface_hub import snapshot_download # <-- Add this import
-
-TEMP_DIR = "/tmp"
-
-# This function for your .pkl files is still correct and needed
-def download_and_load_model(model_url, model_filename):
-    # ... (no changes needed in this function)
-    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
-
-# --- NEW FUNCTION FOR THE SENTENCE TRANSFORMER ---
-def get_sentence_transformer(model_name='all-MiniLM-L6-v2'):
-    """
-    Downloads the SentenceTransformer model to /tmp if it doesn't exist,
-    then loads it from there.
-    """
-    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}...")
-        # Use snapshot_download to get all files for the model from Hugging Face
-        try:
-            snapshot_download(repo_id=f"sentence-transformers/{model_name}",
-                              local_dir=local_model_path,
-                              local_dir_use_symlinks=False) # This is important for Vercel
-            print("Download complete.")
-        except Exception as e:
-            print(f"Failed to download SentenceTransformer model. Error: {e}")
-            return None
-
-    # Load the model from the local path in /tmp
-    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
-
-# --- Main Model Loading Logic ---
-try:
-    # Your .pkl model loading remains the same
-    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"
-
-    tfidf_vectorizer = download_and_load_model(TFIDF_URL, "tfidf_vectorizer.pkl")
-    le = download_and_load_model(LE_URL, "label_encoder.pkl")
-    rf_model = download_and_load_model(RF_MODEL_URL, "random_forest_model.pkl")
-
-    if all([tfidf_vectorizer, le, rf_model]):
-        print("Classification models loaded successfully.")
-    else:
-        print("One or more classification models failed to load.")
-
-    # --- THIS IS THE LINE TO CHANGE ---
-    # Old line: sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
-    # New line:
-    sentence_model = get_sentence_transformer()
-    if sentence_model:
-        print("SentenceTransformer model loaded successfully.")
-    else:
-        print("SentenceTransformer model failed to load.")
-
-except Exception as e:
-    print(f"An unexpected error occurred during model loading: {e}")
+import joblib
+from sentence_transformers import SentenceTransformer
+import os
+import requests
+from huggingface_hub import snapshot_download # <-- Add this import
+
+TEMP_DIR = "/tmp"
+
+# This function for your .pkl files is still correct and needed
+def download_and_load_model(model_url, model_filename):
+    # ... (no changes needed in this function)
+    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
+
+# --- NEW FUNCTION FOR THE SENTENCE TRANSFORMER ---
+def get_sentence_transformer(model_name='all-MiniLM-L6-v2'):
+    """
+    Downloads the SentenceTransformer model to /tmp if it doesn't exist,
+    then loads it from there.
+    """
+    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}...")
+        # Use snapshot_download to get all files for the model from Hugging Face
+        try:
+            snapshot_download(repo_id=f"sentence-transformers/{model_name}",
+                              local_dir=local_model_path,
+                              local_dir_use_symlinks=False) # This is important for Vercel
+            print("Download complete.")
+        except Exception as e:
+            print(f"Failed to download SentenceTransformer model. Error: {e}")
+            return None
+
+    # Load the model from the local path in /tmp
+    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
+
+# --- Main Model Loading Logic ---
+try:
+    # Your .pkl model loading remains the same
+    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"
+
+    tfidf_vectorizer = download_and_load_model(TFIDF_URL, "tfidf_vectorizer.pkl")
+    le = download_and_load_model(LE_URL, "label_encoder.pkl")
+    rf_model = download_and_load_model(RF_MODEL_URL, "random_forest_model.pkl")
+
+    if all([tfidf_vectorizer, le, rf_model]):
+        print("Classification models loaded successfully.")
+    else:
+        print("One or more classification models failed to load.")
+
+    # --- THIS IS THE LINE TO CHANGE ---
+    # Old line: sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
+    # New line:
+    sentence_model = get_sentence_transformer()
+    if sentence_model:
+        print("SentenceTransformer model loaded successfully.")
+    else:
+        print("SentenceTransformer model failed to load.")
+
+except Exception as e:
+    print(f"An unexpected error occurred during model loading: {e}")

app/main.py

@@ -1,14 +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"}
+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/schemas/recommendation.py

@@ -1,16 +1,16 @@
-from pydantic import BaseModel
-from typing import List, Optional
-
-class ProfileRequest(BaseModel):
-    profile_text: str
-
-class InternshipItem(BaseModel):
-    id: int
-    internship_text: str
-    location: str
-
-class RecommendationRequest(BaseModel):
-    profile_text: str
-    predicted_category: Optional[str] = None
-    preferred_location: str
-    internships: List[InternshipItem]
+from pydantic import BaseModel
+from typing import List, Optional
+
+class ProfileRequest(BaseModel):
+    profile_text: str
+
+class InternshipItem(BaseModel):
+    id: int
+    internship_text: str
+    location: str
+
+class RecommendationRequest(BaseModel):
+    profile_text: str
+    predicted_category: Optional[str] = None
+    preferred_location: str
+    internships: List[InternshipItem]

app/services/ranking.py

@@ -1,121 +1,121 @@
-from geopy.distance import geodesic
-import json
-import os
-from geopy.geocoders import Nominatim
-
-from ..core.models import tfidf_vectorizer, le, rf_model, sentence_model
-from ..schemas.recommendation import RecommendationRequest
-from ..utils.text import clean_resume
-
-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 = {}
-
-def load_geo_cache():
-    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 = {}
-
-def save_geo_cache():
-    with open(GEO_CACHE_FILE, "w") as f:
-        json.dump(GEO_CACHE, f)
-
-load_geo_cache()
-
-def geo_coords(city_name: str) -> tuple | None:
-    """
-    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]
-    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 as e:
-        print(f"Error geocoding {city_name}: {e}")
-        return None
-
-def get_category_prediction(profile_text: str) -> str:
-    """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]:
-    """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 []
-
-    internship_embeddings = sentence_model.encode(internship_texts)
-    cosine_score = sentence_model.similarity(profile_embedding, internship_embeddings)[0].tolist()
-
-    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
-
-        internship['final_score'] = final_score
-        final_ranked_list.append(internship)
-
-    final_ranked_list.sort(key=lambda x: x['final_score'], reverse=True)
-
-    final_ids = [item['id'] for item in final_ranked_list]
-
-    print(final_ranked_list)
-
-    return final_ids
+from geopy.distance import geodesic
+import json
+import os
+from geopy.geocoders import Nominatim
+
+from ..core.models import tfidf_vectorizer, le, rf_model, sentence_model
+from ..schemas.recommendation import RecommendationRequest
+from ..utils.text import clean_resume
+
+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 = {}
+
+def load_geo_cache():
+    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 = {}
+
+def save_geo_cache():
+    with open(GEO_CACHE_FILE, "w") as f:
+        json.dump(GEO_CACHE, f)
+
+load_geo_cache()
+
+def geo_coords(city_name: str) -> tuple | None:
+    """
+    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]
+    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 as e:
+        print(f"Error geocoding {city_name}: {e}")
+        return None
+
+def get_category_prediction(profile_text: str) -> str:
+    """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]:
+    """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 []
+
+    internship_embeddings = sentence_model.encode(internship_texts)
+    cosine_score = sentence_model.similarity(profile_embedding, internship_embeddings)[0].tolist()
+
+    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
+
+        internship['final_score'] = final_score
+        final_ranked_list.append(internship)
+
+    final_ranked_list.sort(key=lambda x: x['final_score'], reverse=True)
+
+    final_ids = [item['id'] for item in final_ranked_list]
+
+    print(final_ranked_list)
+
+    return final_ids

app/utils/text.py

@@ -1,17 +1,17 @@
-import re
-
-def clean_resume(text: str) -> str:
-    """
-    Cleans the input resume text by removing URLs, special characters,
-    and extra whitespace, and converting to lowercase.
-    """
-    # Remove URLs
-    text = re.sub(r'http\S+|www\S+', '', text)
-    # Remove non-alphanumeric characters (keeps only letters and spaces)
-    text = re.sub(r'[^A-Za-z\s]', '', text)
-    # Convert to lowercase
-    text = text.lower()
-    # Remove extra whitespace
-    text = re.sub(r'\s+', ' ', text).strip()
-
-    return text
+import re
+
+def clean_resume(text: str) -> str:
+    """
+    Cleans the input resume text by removing URLs, special characters,
+    and extra whitespace, and converting to lowercase.
+    """
+    # Remove URLs
+    text = re.sub(r'http\S+|www\S+', '', text)
+    # Remove non-alphanumeric characters (keeps only letters and spaces)
+    text = re.sub(r'[^A-Za-z\s]', '', text)
+    # Convert to lowercase
+    text = text.lower()
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+
+    return text

requirements.txt

@@ -1,17 +1,17 @@
-# Core FastAPI Framework
-fastapi
-uvicorn
-requests
-
-# Machine Learning & Data
-scikit-learn
-joblib
-sentence-transformers
-torch
-geopy
-huggingface-hub
-# Pydantic is a dependency of FastAPI, but we list it for clarity
-pydantic
-
-# Good practice for managing environment variables
-python-dotenv
+# Core FastAPI Framework
+fastapi
+uvicorn
+requests
+
+# Machine Learning & Data
+scikit-learn
+joblib
+sentence-transformers
+torch
+geopy
+huggingface-hub
+# Pydantic is a dependency of FastAPI, but we list it for clarity
+pydantic
+
+# Good practice for managing environment variables
+python-dotenv

vercel.json

@@ -1,14 +1,14 @@
-{
-  "functions": {
-    "api/index.py": {
-      "maxDuration": 60,
-      "memory": 3008
-    }
-  },
-  "routes": [
-    {
-      "src": "/(.*)",
-      "dest": "api/index.py"
-    }
-  ]
-}
+{
+  "functions": {
+    "api/index.py": {
+      "maxDuration": 60,
+      "memory": 3008
+    }
+  },
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "api/index.py"
+    }
+  ]
+}