Upload 28 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+resume_analyzer.db filter=lfs diff=lfs merge=lfs -text

agents/interview_scheduler.py

@@ -0,0 +1,100 @@
+# agents/interview_scheduler.py
+
+import datetime
+from typing import Optional, Dict, Any
+
+class InterviewScheduler:
+    def __init__(self, candidate_name: str):
+        self.candidate_name = candidate_name
+
+    def generate_interview_slots(self, start_date: datetime.datetime, days_ahead: int = 7) -> list:
+        """Generate available interview slots for the next week"""
+        slots = []
+        current_date = start_date
+        
+        # Generate slots for the next week
+        for _ in range(days_ahead):
+            # Morning slots (9 AM to 12 PM)
+            for hour in range(9, 12):
+                slot = current_date.replace(hour=hour, minute=0)
+                slots.append(slot)
+            
+            # Afternoon slots (2 PM to 5 PM)
+            for hour in range(14, 17):
+                slot = current_date.replace(hour=hour, minute=0)
+                slots.append(slot)
+            
+            current_date += datetime.timedelta(days=1)
+        
+        return slots
+
+    def generate_invite(self, 
+                       job_title: str,
+                       interview_date: datetime.datetime,
+                       interviewer: str,
+                       meeting_link: Optional[str] = None,
+                       additional_notes: Optional[str] = None) -> Dict[str, Any]:
+        """Generate a professional interview invitation"""
+        
+        # Format the date and time
+        formatted_date = interview_date.strftime("%A, %B %d, %Y")
+        formatted_time = interview_date.strftime("%I:%M %p")
+        
+        # Generate the invitation message
+        message = f"""
+Dear {self.candidate_name},
+
+Thank you for your interest in the {job_title} position. We are pleased to invite you for an interview.
+
+Interview Details:
+- Date: {formatted_date}
+- Time: {formatted_time}
+- Interviewer: {interviewer}
+{f'- Meeting Link: {meeting_link}' if meeting_link else ''}
+
+{f'Additional Notes: {additional_notes}' if additional_notes else ''}
+
+Please confirm your availability for this interview slot. If this time doesn't work for you, please let us know your preferred time slots.
+
+Best regards,
+{interviewer}
+"""
+        
+        return {
+            "candidate_name": self.candidate_name,
+            "job_title": job_title,
+            "interview_date": interview_date,
+            "interviewer": interviewer,
+            "meeting_link": meeting_link,
+            "additional_notes": additional_notes,
+            "message": message.strip(),
+            "status": "pending"
+        }
+
+    def generate_follow_up(self, 
+                         interview_date: datetime.datetime,
+                         interviewer: str,
+                         feedback: Optional[str] = None) -> Dict[str, Any]:
+        """Generate a follow-up message after the interview"""
+        
+        message = f"""
+Dear {self.candidate_name},
+
+Thank you for taking the time to interview with us for the position. We appreciate your interest in joining our team.
+
+{f'Interview Feedback: {feedback}' if feedback else 'We will review your interview and get back to you soon with next steps.'}
+
+If you have any questions in the meantime, please don't hesitate to reach out.
+
+Best regards,
+{interviewer}
+"""
+        
+        return {
+            "candidate_name": self.candidate_name,
+            "interview_date": interview_date,
+            "interviewer": interviewer,
+            "feedback": feedback,
+            "message": message.strip(),
+            "status": "follow_up"
+        }

agents/jd_summarizer.py

@@ -0,0 +1,9 @@
+# agents/jd_summarizer.py
+
+class JobDescriptionSummarizer:
+    def __init__(self, job_description: str):
+        self.job_description = job_description
+
+    def get_summary(self):
+        # Placeholder: In future, use LLM to generate a true summary
+        return self.job_description.strip()

agents/matcher.py

@@ -0,0 +1,102 @@
+import json
+from models.llm_client import LLMClient
+
+class ResumeJDMatcher:
+    def __init__(self, llm: LLMClient):
+        self.llm = llm
+
+    def match_resume_to_job(self, resume_text, job_description):
+        if not resume_text or not job_description:
+            raise ValueError("Both resume text and job description are required")
+
+        prompt = f"""You are a resume matching assistant. Your task is to analyze how well a resume matches a job description and return a JSON response.
+
+IMPORTANT: You must ONLY return a JSON object. No other text, explanations, or code blocks.
+
+Resume to analyze:
+{resume_text}
+
+Job Description:
+{job_description}
+
+Return a single JSON object with these exact fields:
+{{
+    "skills_match": (number 0-100),
+    "experience_match": (number 0-100),
+    "education_match": (number 0-100),
+    "certifications_match": (number 0-100),
+    "summary": "Brief analysis of the match"
+}}"""
+
+        try:
+            response = self.llm.generate_text(
+                prompt,
+                temperature=0.3
+            )
+
+            # Log raw response for debugging
+            print(f"[DEBUG] Raw response: {response}")
+            with open("llm_raw_output.txt", "w") as f:
+                f.write(response)
+
+            parsed = self._clean_and_parse_response(response)
+
+            required_fields = ["skills_match", "experience_match", "education_match", "certifications_match", "summary"]
+            for field in required_fields:
+                if field not in parsed:
+                    raise ValueError(f"Missing required field: {field}")
+                if field != "summary":
+                    if not isinstance(parsed[field], (int, float)):
+                        raise ValueError(f"Invalid value type for {field}: {parsed[field]}")
+                    if parsed[field] < 0 or parsed[field] > 100:
+                        raise ValueError(f"Score out of range for {field}: {parsed[field]}")
+
+            return parsed
+
+        except Exception as e:
+            print(f"[ERROR] Matching failed: {str(e)}")
+            return {
+                "skills_match": 0,
+                "experience_match": 0,
+                "education_match": 0,
+                "certifications_match": 0,
+                "summary": f"Error during matching: {str(e)}"
+            }
+
+    def _clean_and_parse_response(self, response: str) -> dict:
+        """Clean and parse the LLM response into a JSON object."""
+        try:
+            response = response.strip()
+
+            # Remove known prefixes that LLM might include
+            for prefix in ["Example:", "Response:", "Answer:", "Here's the JSON:"]:
+                if response.startswith(prefix):
+                    response = response[len(prefix):].strip()
+
+            # Find the JSON object boundaries
+            start_idx = response.find('{')
+            end_idx = response.rfind('}')
+
+            if start_idx == -1 or end_idx == -1:
+                raise ValueError("No JSON object found in response")
+
+            json_str = response[start_idx:end_idx + 1].strip()
+
+            # Log the sanitized string before parsing
+            print("[DEBUG] JSON to parse:", json_str)
+
+            # Parse into dict
+            result = json.loads(json_str)
+
+            # Convert numeric fields safely
+            for key in ["skills_match", "experience_match", "education_match", "certifications_match"]:
+                if key in result:
+                    try:
+                        result[key] = float(result[key])
+                    except (ValueError, TypeError):
+                        raise ValueError(f"Invalid numeric value for {key}: {result[key]}")
+
+            return result
+
+        except Exception as e:
+            raise ValueError(f"Failed to parse response: {str(e)}")

agents/resume_extractor.py

@@ -0,0 +1,10 @@
+# agents/resume_extractor.py
+
+from utils.pdf_utils import extract_text_from_pdf
+
+class ResumeExtractor:
+    def __init__(self, uploaded_file):
+        self.uploaded_file = uploaded_file
+
+    def get_resume_text(self):
+        return extract_text_from_pdf(self.uploaded_file)

agents/shortlister.py

@@ -0,0 +1,20 @@
+# agents/shortlister.py
+
+import re
+
+class Shortlister:
+    def __init__(self, threshold=70):
+        self.threshold = threshold
+
+    def compute_final_score(self, scores):
+        return round(
+            0.4 * scores.get("skills_match", 0) +
+            0.3 * scores.get("experience_match", 0) +
+            0.2 * scores.get("education_match", 0) +
+            0.1 * scores.get("certifications_match", 0),
+            2
+        )
+
+    def is_shortlisted(self, final_score, threshold=60.0):
+        return final_score >= threshold
+

db/database.py

@@ -0,0 +1,190 @@
+# db/database.py
+
+import sqlite3
+from datetime import datetime
+import json
+
+class ResumeMatchDB:
+    def __init__(self, db_path="resume_analyzer.db"):
+        self.db_path = db_path
+        self._init_db()
+
+    def _init_db(self):
+        """Initialize database tables"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Candidates table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS candidates (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    email TEXT,
+                    resume_path TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            
+            # Job Descriptions table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS job_descriptions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    title TEXT NOT NULL,
+                    description TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            
+            # Matches table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS matches (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    candidate_id INTEGER,
+                    job_id INTEGER,
+                    match_score REAL,
+                    skills_match REAL,
+                    experience_match REAL,
+                    education_match REAL,
+                    certifications_match REAL,
+                    summary TEXT,
+                    is_shortlisted BOOLEAN,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (candidate_id) REFERENCES candidates (id),
+                    FOREIGN KEY (job_id) REFERENCES job_descriptions (id)
+                )
+            ''')
+            
+            # Interviews table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS interviews (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    candidate_id INTEGER,
+                    job_id INTEGER,
+                    scheduled_date TIMESTAMP,
+                    status TEXT DEFAULT 'pending',
+                    interviewer TEXT,
+                    meeting_link TEXT,
+                    notes TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (candidate_id) REFERENCES candidates (id),
+                    FOREIGN KEY (job_id) REFERENCES job_descriptions (id)
+                )
+            ''')
+            
+            conn.commit()
+
+    def insert_candidate(self, name, email, resume_path):
+        """Insert a new candidate"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO candidates (name, email, resume_path) VALUES (?, ?, ?)",
+                (name, email, resume_path)
+            )
+            return cursor.lastrowid
+
+    def insert_job_description(self, title, description):
+        """Insert a new job description"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO job_descriptions (title, description) VALUES (?, ?)",
+                (title, description)
+            )
+            return cursor.lastrowid
+
+    def insert_match_result(self, candidate_id, job_id, match_data):
+        """Insert match results"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT INTO matches (
+                    candidate_id, job_id, match_score, skills_match,
+                    experience_match, education_match, certifications_match,
+                    summary, is_shortlisted
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                candidate_id, job_id,
+                match_data['match_score'],
+                match_data['skills_match'],
+                match_data['experience_match'],
+                match_data['education_match'],
+                match_data['certifications_match'],
+                match_data['summary'],
+                match_data['is_shortlisted']
+            ))
+            return cursor.lastrowid
+
+    def schedule_interview(self, candidate_id, job_id, scheduled_date, interviewer, meeting_link=None, notes=None):
+        """Schedule an interview"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT INTO interviews (
+                    candidate_id, job_id, scheduled_date,
+                    interviewer, meeting_link, notes
+                ) VALUES (?, ?, ?, ?, ?, ?)
+            ''', (candidate_id, job_id, scheduled_date, interviewer, meeting_link, notes))
+            return cursor.lastrowid
+
+    def get_candidate_matches(self, candidate_id):
+        """Get all matches for a candidate"""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT m.*, j.title as job_title, j.description as job_description
+                FROM matches m
+                JOIN job_descriptions j ON m.job_id = j.id
+                WHERE m.candidate_id = ?
+                ORDER BY m.match_score DESC
+            ''', (candidate_id,))
+            return [dict(row) for row in cursor.fetchall()]
+
+    def get_scheduled_interviews(self, status=None):
+        """Get all scheduled interviews, optionally filtered by status"""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row  # This makes the cursor return dictionaries
+            cursor = conn.cursor()
+            if status:
+                cursor.execute('''
+                    SELECT i.*, c.name as candidate_name, c.email as candidate_email,
+                           j.title as job_title
+                    FROM interviews i
+                    JOIN candidates c ON i.candidate_id = c.id
+                    JOIN job_descriptions j ON i.job_id = j.id
+                    WHERE i.status = ?
+                    ORDER BY i.scheduled_date
+                ''', (status,))
+            else:
+                cursor.execute('''
+                    SELECT i.*, c.name as candidate_name, c.email as candidate_email,
+                           j.title as job_title
+                    FROM interviews i
+                    JOIN candidates c ON i.candidate_id = c.id
+                    JOIN job_descriptions j ON i.job_id = j.id
+                    ORDER BY i.scheduled_date
+                ''')
+            return [dict(row) for row in cursor.fetchall()]
+
+    def update_interview_status(self, interview_id, status, notes=None):
+        """Update interview status and notes"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            if notes:
+                cursor.execute('''
+                    UPDATE interviews
+                    SET status = ?, notes = ?
+                    WHERE id = ?
+                ''', (status, notes, interview_id))
+            else:
+                cursor.execute('''
+                    UPDATE interviews
+                    SET status = ?
+                    WHERE id = ?
+                ''', (status, interview_id))
+            conn.commit()
+
+    def close(self):
+        """Close database connection"""
+        pass  # SQLite connections are automatically closed

llm_raw_output.txt

@@ -0,0 +1,7 @@
+{
+    "skills_match": 100,
+    "experience_match": 100,
+    "education_match": 100,
+    "certifications_match": 100,
+    "summary": "Perfect match: Resume directly aligns with job requirements including specific technologies (Python, FastAPI, RAG, FAISS, DeepSeek, Llama), cloud deployment (GCP), and experience building AI automation systems and real-time intelligence layers."
+}

main.py

@@ -0,0 +1,437 @@
+# main.py
+
+import streamlit as st
+import pandas as pd
+import PyPDF2  
+import json
+import os
+import re
+import datetime
+from dotenv import load_dotenv
+from models.llm_client import LLMClient
+from agents.resume_extractor import ResumeExtractor
+from agents.jd_summarizer import JobDescriptionSummarizer
+from agents.matcher import ResumeJDMatcher
+from agents.shortlister import Shortlister
+from agents.interview_scheduler import InterviewScheduler
+from db.database import ResumeMatchDB
+
+# Load environment variables
+load_dotenv()
+
+# === Streamlit UI ===
+st.set_page_config(page_title="AI Resume Analyzer", page_icon="📋", layout="wide")
+st.title("📋 AI Resume Analyzer")
+
+# Initialize session state
+if 'results' not in st.session_state:
+    st.session_state.results = []
+if 'scheduled_interviews' not in st.session_state:
+    st.session_state.scheduled_interviews = []
+if 'interview_data' not in st.session_state:
+    st.session_state.interview_data = {}
+if 'search_query' not in st.session_state:
+    st.session_state.search_query = ""
+
+# === LLM Configuration (DeepSeek) ===
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+DEEPSEEK_MODEL = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
+DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
+
+if not DEEPSEEK_API_KEY:
+    st.error("❌ DEEPSEEK_API_KEY not found. Please set it in your .env file.")
+    st.stop()
+
+# === Upload Resume ===
+st.subheader("📂 Upload Resumes")
+uploaded_files = st.file_uploader("Upload multiple resumes (PDF)", type=["pdf"], accept_multiple_files=True)
+
+# === Job Description Input ===
+st.subheader("📝 Job Description")
+jd_input_type = st.radio("Select input method:", ["Text Input", "Upload File"], horizontal=True)
+job_descriptions = []
+
+if jd_input_type == "Text Input":
+    job_description = st.text_area("Enter job description:", height=200)
+    if job_description:
+        job_descriptions.append({"title": "Job Description", "content": job_description})
+
+elif jd_input_type == "Upload File":
+    jd_file = st.file_uploader("Upload job description file (PDF, TXT, or CSV)", type=["pdf", "txt", "csv"])
+    
+    if jd_file:
+        if jd_file.type == "application/pdf":
+            reader = PyPDF2.PdfReader(jd_file)
+            content = " ".join(page.extract_text() for page in reader.pages)
+            job_descriptions.append({"title": jd_file.name, "content": content})
+            
+        elif jd_file.type == "text/plain":
+            content = jd_file.read().decode("utf-8")
+            job_descriptions.append({"title": jd_file.name, "content": content})
+            
+        elif jd_file.type == "text/csv":
+            try:
+                encodings = ['utf-8', 'cp1252', 'latin1', 'iso-8859-1']
+                df = None
+                
+                for encoding in encodings:
+                    try:
+                        jd_file.seek(0)
+                        df = pd.read_csv(jd_file, encoding=encoding)
+                        break
+                    except UnicodeDecodeError:
+                        continue
+                
+                if df is None:
+                    st.error("❌ Could not read CSV file with any supported encoding")
+                elif 'Job Title' in df.columns and 'Job Description' in df.columns:
+                    job_descriptions = [{"title": row['Job Title'], "content": row['Job Description']} 
+                                     for _, row in df.iterrows()]
+                else:
+                    st.error("❌ CSV must contain 'Job Title' and 'Job Description' columns")
+            except Exception as e:
+                st.error(f"❌ Error reading CSV file: {str(e)}")
+
+# Database status indicator
+try:
+    db = ResumeMatchDB()
+    st.sidebar.success("✅ Database Connected")
+except Exception as e:
+    st.sidebar.error("❌ Database Connection Error")
+
+# Search functionality
+st.sidebar.subheader("🔍 Search Candidates")
+
+# ✅ Initialize session state key if not already present
+if "search_query" not in st.session_state:
+    st.session_state.search_query = ""
+
+# 🔍 Display search input
+st.session_state.search_query = st.sidebar.text_input("Search by name or role", st.session_state.search_query)
+
+def format_date(date_str):
+    """Format date string for better readability"""
+    try:
+        date = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
+        return date.strftime("%B %d, %Y at %I:%M %p")
+    except:
+        return date_str
+
+def display_statistics():
+    """Display basic statistics"""
+    if st.session_state.results:
+        total_candidates = len(st.session_state.results)
+        shortlisted = sum(1 for r in st.session_state.results if r['best_match']['is_shortlisted'])
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Total Candidates", total_candidates)
+        with col2:
+            st.metric("Shortlisted", shortlisted)
+
+def filter_results(results, query):
+    """Filter results based on search query"""
+    if not query:
+        return results
+    query = query.lower()
+    return [
+        r for r in results 
+        if query in r['candidate_name'].lower() or 
+           query in r['best_match']['job_title'].lower()
+    ]
+
+def extract_candidate_info(resume_text):
+    """Extract candidate name and email from resume text"""
+    email_pattern = r'[\w\.-]+@[\w\.-]+\.\w+'
+    email = re.search(email_pattern, resume_text)
+    email = email.group(0) if email else "Not found"
+    
+    lines = resume_text.split('\n')
+    name = "Not found"
+    
+    name_patterns = [
+        r'^[A-Z][a-z]+\s+[A-Z][a-z]+$',
+        r'^[A-Z][a-z]+\s+[A-Z]\.\s+[A-Z][a-z]+$',
+        r'^[A-Z][a-z]+\s+[A-Z][a-z]+\s+[A-Z][a-z]+$'
+    ]
+    
+    for line in lines:
+        line = line.strip()
+        if line and '@' not in line:
+            for pattern in name_patterns:
+                if re.match(pattern, line):
+                    name = line
+                    break
+            if name != "Not found":
+                break
+                
+    return name, email
+
+def analyze_resumes():
+    """Analyze resumes and store results in session state"""
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    with st.spinner("Analyzing resumes..."):
+        results = []
+        total_steps = len(uploaded_files) * len(job_descriptions)
+        current_step = 0
+        
+        db = ResumeMatchDB()
+        
+        for uploaded_file in uploaded_files:
+            status_text.text(f"📄 Processing {uploaded_file.name}...")
+            extractor = ResumeExtractor(uploaded_file)
+            resume_text = extractor.get_resume_text()
+            candidate_name, candidate_email = extract_candidate_info(resume_text)
+            
+            candidate_id = db.insert_candidate(
+                name=candidate_name,
+                email=candidate_email,
+                resume_path=uploaded_file.name
+            )
+            
+            resume_results = []
+            for jd in job_descriptions:
+                current_step += 1
+                progress = current_step / total_steps
+                progress_bar.progress(progress)
+                
+                status_text.text(f"🔍 Matching with {jd['title']}...")
+                jd_agent = JobDescriptionSummarizer(jd['content'])
+                jd_summary = jd_agent.get_summary()
+                
+                llm = LLMClient(api_key=DEEPSEEK_API_KEY, model_name=DEEPSEEK_MODEL, base_url=DEEPSEEK_BASE_URL)
+                matcher = ResumeJDMatcher(llm)
+                shortlister = Shortlister(threshold=70.0)
+                
+                match_result = matcher.match_resume_to_job(resume_text, jd_summary)
+                match_percent = shortlister.compute_final_score(match_result)
+                is_shortlisted = shortlister.is_shortlisted(match_percent)
+                
+                job_id = db.insert_job_description(
+                    title=jd['title'],
+                    description=jd['content']
+                )
+                
+                match_data = {
+                    'match_score': match_percent,
+                    'skills_match': match_result['skills_match'],
+                    'experience_match': match_result['experience_match'],
+                    'education_match': match_result['education_match'],
+                    'certifications_match': match_result['certifications_match'],
+                    'summary': match_result['summary'],
+                    'is_shortlisted': is_shortlisted
+                }
+                db.insert_match_result(candidate_id, job_id, match_data)
+                
+                resume_results.append({
+                    "job_title": jd['title'],
+                    "match_score": match_percent,
+                    "is_shortlisted": is_shortlisted,
+                    "details": match_result,
+                    "job_id": job_id
+                })
+            
+            best_match = max(resume_results, key=lambda x: x['match_score'])
+            
+            results.append({
+                "candidate_name": candidate_name,
+                "candidate_email": candidate_email,
+                "resume_name": uploaded_file.name,
+                "best_match": best_match,
+                "candidate_id": candidate_id
+            })
+        
+        progress_bar.empty()
+        status_text.empty()
+        st.session_state.results = results
+
+def display_results():
+    """Display analysis results and handle interview scheduling"""
+    if not st.session_state.results:
+        return
+    
+    # Display statistics
+    display_statistics()
+    
+    st.subheader("🎯 Analysis Results")
+    
+    # Filter results based on search
+    filtered_results = filter_results(st.session_state.results, st.session_state.search_query)
+    
+    # Create a list to store all candidates for download
+    all_candidates = []
+    
+    for result in filtered_results:
+        with st.expander(f"📄 {result['candidate_name']} ({result['candidate_email']})"):
+            st.write(f"**Resume:** {result['resume_name']}")
+            
+            match = result['best_match']
+            st.subheader(f"Best Match: {match['job_title']}")
+            st.metric("Match Score", f"{match['match_score']:.1f}%")
+            
+            all_candidates.append({
+                "Name": result['candidate_name'],
+                "Email": result['candidate_email'],
+                "Resume": result['resume_name'],
+                "Best Match Role": match['job_title'],
+                "Match Score": f"{match['match_score']:.1f}%",
+                "Status": "Shortlisted" if match['is_shortlisted'] else "Not Shortlisted"
+            })
+            
+            if match['is_shortlisted']:
+                st.success("✅ Shortlisted")
+                handle_interview_scheduling(result, match)
+            else:
+                st.warning("⚠️ Not Shortlisted")
+            
+            display_match_details(match['details'])
+    
+    # Add download button for candidate list
+    if all_candidates:
+        df_candidates = pd.DataFrame(all_candidates)
+        csv = df_candidates.to_csv(index=False).encode('utf-8')
+        st.download_button(
+            label="📥 Download Candidate List",
+            data=csv,
+            file_name="candidate_list.csv",
+            mime="text/csv"
+        )
+
+def handle_interview_scheduling(result, match):
+    """Handle interview scheduling for a candidate"""
+    st.subheader("📅 Schedule Interview")
+    
+    interview_key = f"interview_{result['candidate_id']}"
+    if interview_key not in st.session_state.interview_data:
+        st.session_state.interview_data[interview_key] = {
+            "interviewer": "",
+            "meeting_link": "",
+            "notes": "",
+            "selected_slot": None
+        }
+    
+    data = st.session_state.interview_data[interview_key]
+    
+    data["interviewer"] = st.text_input(
+        "Interviewer Name",
+        value=data["interviewer"],
+        key=f"interviewer_{result['candidate_id']}"
+    )
+    
+    data["meeting_link"] = st.text_input(
+        "Meeting Link (optional)",
+        value=data["meeting_link"],
+        key=f"meeting_{result['candidate_id']}"
+    )
+    
+    data["notes"] = st.text_area(
+        "Additional Notes",
+        value=data["notes"],
+        key=f"notes_{result['candidate_id']}"
+    )
+    
+    scheduler = InterviewScheduler(result['candidate_name'])
+    start_date = datetime.datetime.now() + datetime.timedelta(days=1)
+    slots = scheduler.generate_interview_slots(start_date)
+    
+    data["selected_slot"] = st.selectbox(
+        "Select Interview Slot",
+        options=slots,
+        format_func=lambda x: x.strftime("%A, %B %d, %Y at %I:%M %p"),
+        key=f"slot_{result['candidate_id']}",
+        index=slots.index(data["selected_slot"]) if data["selected_slot"] in slots else 0
+    )
+    
+    if st.button("Schedule Interview", key=f"schedule_{result['candidate_id']}"):
+        if data["selected_slot"] and data["interviewer"]:
+            schedule_interview(result, match, data)
+        else:
+            st.error("Please provide interviewer name and select a time slot")
+
+def schedule_interview(result, match, data):
+    """Schedule an interview and update session state"""
+    db = ResumeMatchDB()
+    scheduler = InterviewScheduler(result['candidate_name'])
+    
+    invite = scheduler.generate_invite(
+        job_title=match['job_title'],
+        interview_date=data["selected_slot"],
+        interviewer=data["interviewer"],
+        meeting_link=data["meeting_link"],
+        additional_notes=data["notes"]
+    )
+    
+    db.schedule_interview(
+        candidate_id=result['candidate_id'],
+        job_id=match['job_id'],
+        scheduled_date=data["selected_slot"],
+        interviewer=data["interviewer"],
+        meeting_link=data["meeting_link"],
+        notes=data["notes"]
+    )
+    
+    st.session_state.scheduled_interviews.append({
+        "candidate_id": result['candidate_id'],
+        "candidate_name": result['candidate_name'],
+        "job_title": match['job_title'],
+        "interview_date": data["selected_slot"],
+        "interviewer": data["interviewer"]
+    })
+    
+    st.success("✅ Interview Scheduled!")
+    st.write("**Interview Invitation:**")
+    st.write(invite['message'])
+
+def display_match_details(details):
+    """Display match details in a clean format"""
+    col1, col2 = st.columns(2)
+    with col1:
+        st.metric("Skills Match", f"{details['skills_match']}%")
+        st.metric("Experience Match", f"{details['experience_match']}%")
+    with col2:
+        st.metric("Education Match", f"{details['education_match']}%")
+        st.metric("Certifications Match", f"{details['certifications_match']}%")
+    
+    st.write("**Summary:**")
+    st.write(details['summary'])
+
+def display_scheduled_interviews():
+    """Display scheduled interviews and handle feedback"""
+    st.subheader("📅 Upcoming Interviews")
+    db = ResumeMatchDB()
+    interviews = db.get_scheduled_interviews(status='pending')
+    
+    if interviews:
+        for interview in interviews:
+            with st.expander(f"Interview with {interview['candidate_name']} for {interview['job_title']}"):
+                st.write(f"**Date:** {format_date(interview['scheduled_date'])}")
+                st.write(f"**Interviewer:** {interview['interviewer']}")
+                if interview['meeting_link']:
+                    st.write(f"**Meeting Link:** {interview['meeting_link']}")
+                if interview['notes']:
+                    st.write(f"**Notes:** {interview['notes']}")
+                
+                feedback = st.text_area("Interview Feedback", key=f"feedback_{interview['id']}")
+                if st.button("Submit Feedback", key=f"submit_{interview['id']}"):
+                    if feedback:
+                        db.update_interview_status(
+                            interview_id=interview['id'],
+                            status='completed',
+                            notes=feedback
+                        )
+                        st.success("✅ Feedback submitted!")
+                    else:
+                        st.error("Please provide feedback")
+    else:
+        st.info("No upcoming interviews scheduled.")
+
+# Main execution
+if uploaded_files and job_descriptions:
+    if st.button("🔍 Analyze Resumes"):
+        analyze_resumes()
+
+if st.session_state.results:
+    display_results()
+    display_scheduled_interviews()

models/llm_client.py

@@ -0,0 +1,50 @@
+# models/llm_client.py
+
+from openai import OpenAI
+
+
+class LLMClient:
+    def __init__(self, api_key: str, model_name: str = "deepseek-chat", base_url: str = "https://api.deepseek.com/v1"):
+        if not api_key:
+            raise ValueError("API key is required")
+
+        # Initialize OpenAI-compatible client for DeepSeek
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.model_name = model_name
+
+    def generate_text(self, prompt: str, max_tokens: int = 300, temperature: float = 0.7) -> str:
+        """Generate text using DeepSeek Chat (OpenAI-compatible API).
+
+        Args:
+            prompt: The input prompt
+            max_tokens: Maximum number of tokens to generate
+            temperature: Temperature for sampling (higher = more random)
+
+        Returns:
+            str: The generated text response
+        """
+        try:
+            print(f"[DEBUG] Prompt sent to LLM: {prompt[:200]}...")
+
+            completion = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant for resume and job description analysis."},
+                    {"role": "user", "content": prompt},
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+
+            if not completion or not completion.choices:
+                raise ValueError("Empty response from LLM API")
+
+            generated_text = (completion.choices[0].message.content or "").strip()
+
+            if not generated_text:
+                raise ValueError("Empty response from LLM API")
+
+            return generated_text
+
+        except Exception as e:
+            raise RuntimeError(f"LLM API error: {str(e)}")

resume_analyzer.db

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

utils/pdf_utils.py

@@ -0,0 +1,13 @@
+# utils/pdf_utils.py
+
+import PyPDF2
+
+def extract_text_from_pdf(uploaded_file):
+    try:
+        reader = PyPDF2.PdfReader(uploaded_file)
+        resume_text = " ".join(
+            [page.extract_text() for page in reader.pages if page.extract_text()]
+        )
+        return resume_text.strip()
+    except Exception as e:
+        raise RuntimeError(f"Failed to extract PDF text: {e}")