Build a Smart Hiring Assistant with Django, OpenAI, and SendGrid

# Create project directory
mkdir Hiring-assistant
cd Hiring-assistant
# Create and activate virtual environment
python -m venv resume-parser
resume-parser\Scripts\activate 
#On Mac:  
python3 -m venv resume-parser
source resume-parser/bin/activate

# Install dependencies
pip install django openai python-dotenv sendgrid pdfminer.six python-magic

django-admin startproject smart_hiring_assistant
cd smart_hiring_assistant
python manage.py startapp Screener

INSTALLED_APPS = [
    ...
    'Screener',
]

from pathlib import Path
import os
from dotenv import load_dotenv
from django.conf import settings
from django.conf.urls.static import static
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
load_dotenv()

OPENAI_API_KEY=your_openai_api_key_here
SENDGRID_API_KEY=your_verified_sendgrid_api_key_here
FROM_EMAIL=your_verified_sendgrid_email@example.com
MAIL_FROM_NAME=recruiter_email_name
RECRUITER_EMAIL=youremail@example.com

from django.db import models
class Resume(models.Model):
    name = models.CharField(max_length=255)
    email = models.EmailField()
    resume_file = models.FileField(upload_to='resumes/')
    resume_text = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    def __str__(self):
        return f"{self.name} - {self.email}"

python manage.py makemigrations
python manage.py migrate

from django.urls import path
from . import views
app_name = 'Screener'
urlpatterns = [
    path('', views.upload_resume, name='upload_resume'),
]

from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('Screener.urls')),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

from django import forms
from .models import Resume
class ResumeUploadForm(forms.ModelForm):
    class Meta:
        model = Resume
        fields = ['name', 'email', 'resume_file']
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['name'].widget.attrs.update({
            'class': 'form-control',
            'placeholder': 'Enter your full name'
        })
        self.fields['email'].widget.attrs.update({
            'class': 'form-control',
            'placeholder': 'Enter your email address'
        })
        self.fields['resume_file'].widget.attrs.update({
            'class': 'form-control',
            'accept': '.pdf'
        })
    def clean_resume_file(self):
        resume_file = self.cleaned_data.get('resume_file')
        if resume_file:
            if not resume_file.name.endswith('.pdf'):
                raise forms.ValidationError('Only PDF files are allowed.')
            if resume_file.size > 2 * 1024 * 1024:  # 2MB limit
                raise forms.ValidationError('File size must be under 2MB.')
        return resume_file

from pdfminer.high_level import extract_text
import os
class PDFParserService:
    @staticmethod
    def extract_text_from_pdf(pdf_path):
        try:
            text = extract_text(pdf_path)
            if not text:
                raise Exception("Failed to extract text from PDF")
            # Clean the extracted text 
            text = ' '.join(text.split())
            return text[:15000]  # Limit to 15000 characters
        except Exception as e:
            print(f"PDF extraction failed: {str(e)}")
            return 'Failed to extract text from resume.'

from openai import OpenAI
import os
from django.conf import settings
class OpenAIService:
    def __init__(self):
        self.client = OpenAI(
            api_key=os.getenv('OPENAI_API_KEY')
        )
    def generate_chat_completion(self, messages):
        try:
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=messages
            )
            return response
        except Exception as e:
            print(f"OpenAI API Error: {str(e)}")
            raise

class RAGService:
    def __init__(self, openai_service):
        self.openai_service = openai_service
        self.job_requirements = """
        Education: Bachelor's or Master's degree in computer science, engineering, mathematics, or related fields; coursework in machine learning or data science is preferred.
        Programming: 2+ years of experience with Python, R, or similar languages; proficiency in TensorFlow, PyTorch, or other ML frameworks.
        Machine Learning: 2+ years of practical experience with ML algorithms, model deployment, and optimization.
        Software Engineering: Familiarity with Git, Agile methodologies, and collaborative tools; experience in software development teams for at least 2-3 years.
        Problem-Solving: Strong analytical skills, with a track record of solving complex problems using machine learning techniques.
        Communication: Effective communicator across technical and non-technical audiences; experience working in cross-functional teams.
        Portfolio: Demonstrated projects in machine learning through work experience, academic research, or personal projects; contributions to open-source projects or participation in hackathons.
        """
    def process_resume(self, resume_text):
        try:
            context = self._combine_context(resume_text)
            assessment_response = self._generate_assessment(context)
            # Parse the assessment focusing only on the final decision
            if "OVERALL_DECISION:" not in assessment_response:
                return {
                    'detailed_assessment': "Error: Assessment response missing required format",
                    'meets_requirements': False,
                    'raw_response': assessment_response
                }
            # Split at OVERALL_DECISION: and take only the parts we need
            parts = assessment_response.split("OVERALL_DECISION:")
            if len(parts) != 2:
                return {
                    'detailed_assessment': "Error: Invalid assessment format",
                    'meets_requirements': False,
                    'raw_response': assessment_response
                }
            detailed_assessment = parts[0].strip()
            final_decision = parts[1].strip().lower()
            # Only check for exact match of 'qualified' in the final decision
            is_qualified = final_decision.strip() == 'qualified'
            return {
                'detailed_assessment': detailed_assessment,
                'meets_requirements': is_qualified,
                'raw_response': assessment_response
            }
        except Exception as e:
            print(f"RAG processing failed: {str(e)}")
            return {
                'detailed_assessment': 'Unable to complete resume assessment due to an error.',
                'meets_requirements': False,
                'raw_response': str(e)
            }
    def _combine_context(self, resume_text):
        context = f"""
        Job Requirements Analysis Guidelines:
        - Requirements listed are minimum qualifications
        - Candidates exceeding minimum requirements should be considered qualified
        - Related skills and experience should be considered equivalent
        - More years of experience than required is a positive factor
        - Different but relevant degree fields are acceptable
        - Consider the overall strength of the candidate
        Job Requirements:
        {self.job_requirements}
        Applicant's Resume:
        {resume_text}
        """
        return context
    def _generate_assessment(self, context):
        messages = [
            {
                'role': 'system',
                'content': '''You are an experienced technical recruiter evaluating candidates for a machine learning engineer position.
                Your goal is to identify qualified candidates who meet or exceed the minimum requirements, including those with equivalent or superior qualifications.
                Assessment Guidelines:
                1. Consider both direct matches and relevant equivalent qualifications
                2. More experience than required is a positive factor
                3. Related degrees and skills should be evaluated favorably
                4. Look for potential and demonstrated capability, not just exact matches
                5. Consider the candidate holistically
                Format your response as follows:
                1. Start with a detailed analysis of each requirement:
                   - Education assessment
                   - Programming experience assessment
                   - Machine learning experience assessment
                   - Software engineering experience assessment
                   - Problem-solving skills assessment
                   - Communication skills assessment
                   - Portfolio assessment
                2. Provide a summary of strengths and weaknesses
                3. End your response with exactly one of these two lines:
                   OVERALL_DECISION: qualified
                   or
                   OVERALL_DECISION: not_qualified
                A candidate should be marked as qualified if they:
                - Meet or exceed the core technical requirements (even with equivalent experience)
                - Show strong potential in required areas
                - Have demonstrated relevant skills, even if through different technologies or roles'''
            },
            {
                'role': 'user',
                'content': f"""{context}
                Please evaluate this candidate considering both direct matches and equivalent qualifications.
                For each requirement:
                1. State if it is met, exceeded, or partially met
                2. List relevant evidence from the resume
                3. Consider equivalent experience or qualifications
                4. Note any exceptional strengths
                End with exactly:
                OVERALL_DECISION: qualified
                or
                OVERALL_DECISION: not_qualified
                """
            }
        ]
        response = self.openai_service.generate_chat_completion(messages)
        return response.choices[0].message.content

import os
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail, Content
class SendGridService:
    def __init__(self):
        self.sg = SendGridAPIClient(os.getenv('SENDGRID_API_KEY'))
        self.from_email = os.getenv('FROM_EMAIL')
        self.from_name = os.getenv('MAIL_FROM_NAME')
    def send_rejection_email(self, to_email, name):
        message = Mail(
            from_email=(self.from_email, self.from_name),
            to_emails=to_email,
            subject='Application Status Update',
            plain_text_content=f"""
            Dear {name},
            Thank you for your interest in our company. After careful consideration, 
            we regret to inform you that we will not be moving forward with your 
            application at this time. We appreciate your time and effort in applying.
            Best regards,
            Recruitment Team
            """
        )
        try:
            response = self.sg.send(message)
            return response.status_code
        except Exception as e:
            print(f"Failed to send rejection email: {str(e)}")
            return False
    def forward_successful_applicant(self, to_email, applicant_data, assessment):
        html_content = f"""
        <p>Name: {applicant_data['name']}</p>
        <p>Email: {applicant_data['email']}</p>
        <p>Resume Path: <a href="{applicant_data['resume_path']}">View Resume</a></p>
        <p>Assessment:</p>
        <p>{assessment}</p>
        """
        plain_content = f"""
        Name: {applicant_data['name']}
        Email: {applicant_data['email']}
        Resume Path: {applicant_data['resume_path']}
        Assessment:
        {assessment}
        """
        message = Mail(
            from_email=(self.from_email, self.from_name),
            to_emails=to_email,
            subject=f"Successful Applicant: {applicant_data['name']}",
            plain_text_content=plain_content,
            html_content=html_content
        )
        try:
            response = self.sg.send(message)
            return response.status_code
        except Exception as e:
            print(f"Failed to send successful applicant email: {str(e)}")
            return False

from django.shortcuts import render, redirect
from django.contrib import messages
from .forms import ResumeUploadForm
from .services.openai_service import OpenAIService
from .services.rag_service import RAGService
from .services.sendgrid_service import SendGridService
from django.conf import settings
import logging
from pdfminer.high_level import extract_text
import re
import os
from datetime import datetime
# Configure log and load recruiter email
logger = logging.getLogger(__name__)
RECRUITER_EMAIL = os.getenv('RECRUITER_EMAIL')

def upload_resume(request):
    """Handle resume upload and processing with enhanced evaluation capabilities."""
    if request.method == 'POST':
        form = ResumeUploadForm(request.POST, request.FILES)
        if form.is_valid():
            try:
                # Here you save the form instance
                resume = form.save()
                logger.info(f"Resume uploaded successfully for {resume.name}")
                # Initialize all the services
                try:
                    openai_service = OpenAIService()
                    rag_service = RAGService(openai_service)
                    sendgrid_service = SendGridService()
                except Exception as e:
                    logger.error(f"Failed to initialize services: {str(e)}")
                    messages.error(request, 'Service initialization failed. Please contact support.')
                    return redirect('Screener:upload_resume')
                #Must process the resume
                applicant_data = {
                    'name': resume.name,
                    'email': resume.email,
                    'resume_path': resume.resume_file.path,
                    'position_applied': resume.position_applied if hasattr(resume, 'position_applied') else 'ML Engineer'
                }
                assessment_result = screen_resume(applicant_data, rag_service, sendgrid_service)
                if assessment_result.get('success', False):
                    if assessment_result.get('meets_requirements', False):
                        message = ('Thank you for applying! Your qualifications look promising, '
                                 'and our recruitment team will be in touch shortly.')
                    else:
                        message = ('Thank you for your interest. We have carefully reviewed your application '
                                 'and will keep your resume on file for future opportunities.')
                    messages.success(request, message)
                else:
                    message = ('We encountered an issue processing your application. '
                             'Our team has been notified and will review it manually.')
                    messages.warning(request, message)
                # Store assessment details for future reference
                try:
                    store_assessment_results(resume, assessment_result)
                except Exception as e:
                    logger.error(f"Failed to store assessment results: {str(e)}")
                return redirect('Screener:upload_resume')
            except Exception as e:
                logger.error(f'Resume upload failed: {str(e)}')
                messages.error(request, 'Failed to process resume. Please try again later.')
                return redirect('Screener:upload_resume')
    else:
        form = ResumeUploadForm()
    return render(request, 'Screener/upload.html', {'form': form})

def screen_resume(applicant_data, rag_service, sendgrid_service):
    """
    Screen a resume with enhanced evaluation capabilities.
    Returns a dict with success status, detailed assessment, and scoring information.
    """
    try:
        # Extract text from PDF with on cleaning
        resume_text = extract_text_from_pdf(applicant_data['resume_path'])
        if not resume_text:
            logger.error("PDF extraction failed - empty text returned")
            return {
                'success': False,
                'error': 'Failed to extract text from resume',
                'assessment': None
            }
        # Process resume using RAG service
        assessment_result = rag_service.process_resume(resume_text)
        if not isinstance(assessment_result, dict):
            logger.error("RAG service returned invalid response format")
            return {
                'success': False,
                'error': 'Invalid assessment format',
                'assessment': None
            }
        # Logging with assessment
        qualification_status = "qualified" if assessment_result['meets_requirements'] else "not qualified"
        logger.info(f"Applicant {applicant_data['name']} assessed as {qualification_status} with detailed evaluation")
        try:
            if assessment_result['meets_requirements']:
                # Email for successful applicants with detailed assessment
                email_sent = sendgrid_service.forward_successful_applicant(
                    RECRUITER_EMAIL,
                    applicant_data,
                    format_detailed_assessment(assessment_result['detailed_assessment'])
                )
                if not email_sent:
                    logger.error(f"Failed to send recruiter email for {applicant_data['name']}")
            else:
                # Send the rejection email 
                email_sent = sendgrid_service.send_rejection_email(
                    applicant_data['email'],
                    applicant_data['name']
                )
                if not email_sent:
                    logger.error(f"Failed to send rejection email to {applicant_data['name']}")
        except Exception as e:
            logger.error(f"Email sending failed: {str(e)}")
            # Continue to process even if email fails
        return {
            'success': True,
            'assessment': assessment_result['detailed_assessment'],
            'meets_requirements': assessment_result['meets_requirements'],
            'raw_response': assessment_result.get('raw_response', ''),
            'error': None
        }
    except Exception as e:
        logger.error(f'Resume screening error: {str(e)}')
        return {
            'success': False,
            'error': str(e),
            'assessment': None
        }

def extract_text_from_pdf(path):
    """
    Extract and clean text from a PDF file with enhanced cleaning capabilities.
    Returns cleaned text or raises an exception if extraction fails.
    """
    try:
        if not os.path.exists(path):
            raise FileNotFoundError(f"PDF file not found at path: {path}")
        # Extract text from PDF
        text = extract_text(path)
        if not text:
            raise Exception("No text extracted from PDF")
        # Text cleaning
        # Remove extra whitespace and normalize spaces
        text = re.sub(r'\s+', ' ', text)
        # Remove non-ASCII characters but preserve common special characters
        text = re.sub(r'[^\x20-\x7E\n]', '', text)
        # Normalize bullet points and special characters
        text = re.sub(r'[•●■◆▪]', '- ', text)
        # Fix common OCR issues
        text = text.replace('|', 'I')  # Common OCR mistake
        text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)  # Add space between camelCase
        # Remove duplicate dash indicators
        text = re.sub(r'-\s*-\s*-', '-', text)
        # Remove leading/trailing whitespace
        text = text.strip()
        # Verify meaningful content
        if len(text.split()) < 10:
            raise Exception("Extracted text appears to be too short to be a valid resume")
        # Limit to 15000 characters to avoid token limits
        return text[:15000]
    except Exception as e:
        logger.error(f'PDF extraction failed for {path}: {str(e)}')
        raise Exception(f"Failed to extract text from resume: {str(e)}")

def format_detailed_assessment(assessment):
    """Format the detailed assessment for email communication."""
    try:
        formatted_text = assessment.replace('\n\n', '\n').strip()
        # Add HTML formatting for better readability
        formatted_text = f"<div style='font-family: Arial, sans-serif;'>{formatted_text}</div>"
        return formatted_text
    except Exception as e:
        logger.error(f"Failed to format assessment: {str(e)}")
        return assessment

..\resume-parser\Scripts\activate && python manage.py runserver

source ../resume-parser/bin/activate && python manage.py runserver