How rakshitkhajuria/job-recomendation works
Project Type & Purpose
• The project is a full-stack, data-driven job recommendation system. Its core purpose is to bridge the gap between job seekers and recruiters by using advanced technologies like Optical Character Recognition (OCR) and Natural Language Processing (NLP) to process resumes and job postings.
• The README and file tree indicate that the application is built using Python with a Streamlit front-end, integrating modules for data collection, preprocessing, recommendation logic, and additional features like resume analysis.
File Structure
• Key directories/components:
• Top-level modules:
• JobRecommendation folder: Contains all the core backend modules (e.g., animation, config, courses, NLP preprocessing via text_preprocessing, utilities, and sidebar management) which encapsulate business logic.
• MongoDB_function subdirectory: Houses utility functions for interactions with MongoDB and managing database operations.
• Data Directory:
• Contains CSV files of preprocessed, concatenated, and KNN-based structured data, indicating that the project uses file-based persistence along with MongoDB.
• Notebook Directory:
• Contains Jupyter notebooks related to data concatenation, experimentation, OCR, and even an OCR demo—useful for prototyping and analysis.
• Pages Directory:
• Contains Streamlit pages (e.g., Candidate, Recruiter, Resume Analyzer), demonstrating the multi-page front-end structure for different user roles.
• Documentation Directory:
• Contains high-level, low-level architecture design documents and wireframes that might provide more insights for in-depth diagramming.
• Configuration Files:
• Dockerfile, .gitignore, requirements.txt, and setup.py indicate deployment and dependency management.
Main Components and Their Relationships
• Frontend/UI Layer (Streamlit):
• Components include the HOME.py and multiple page scripts (e.g., for candidates, recruiters, resume analyzer).
• These pages interact with the backend to display recommendations, analytics, resume details, and visual components (using sidebar, animations, lottie, etc.).
• Backend/Processing Layer:
• Core business logic is encapsulated in the JobRecommendation module:
• OCR Module: Processes uploaded resumes into text (as evident from OCR notebooks and README explanation).
• NLP and Preprocessing: Modules like text_preprocessing convert text inputs into tokens, remove stop words, lemmatize, and possibly extract bigrams.
• Recommendation Engine: Utilizing processed resume data (computed similarity against preprocessed job postings) to recommend jobs and candidates.
• Utility Modules: For supporting tasks like distance_calculation and course recommendations.
• Animation and UI components: Modules like animation.py, sidebar.py, and side_logo.py provide enhanced UI elements.
• Data Layer:
• Database: MongoDB (along with separate collections as mentioned: Resume_Data, all_locations_Data, preprocessed_jobs_Data, Resume_from_CANDIDATE, and Resume_from_RESUME_ANALYZER).
• Data Files: CSV files stored within data/concatenated_data and scrapped_data directories. Indicate interaction between preprocessing modules and file-based data stores.
• External Services & Integration:
• Cloud build/deployment: Docker and Streamlit configurations indicate container/pipeline layers.
• Possibly represent external libraries like OCR and NLP libraries (e.g., if using Tesseract or similar) that support these processing steps.
Architectural Patterns & Design Principles
• Separation of concerns is applied between UI (front-end), processing (business logic with OCR, NLP, and recommendation), and data storage (MongoDB and CSV files).
• Modular design as indicated by the clear split into different directories for utilities, configuration, and functionalities.
• Pipeline flow from resume upload → OCR conversion → NLP processing → recommendation generation.
• Clearly labeled nodes for each module/component.
• Frontend (Streamlit) → Backend modules (OCR, NLP, Recommendation Engine).
• Backend modules ↔ Data Layer (MongoDB and CSV files).
• External Service Integration (Apify for data scraping).
• Annotations or notes that detail architectural patterns like modular separation, the use of pipelines (OCR → NLP → ML Recommendation), and integration with external APIs.