Latest code changes committed

README.md

@@ -1 +1,63 @@
-# ATS-Crewai
+# ATS-Crewai
+
+Welcome to the ATS Flow project, powered by [crewAI](https://crewai.com). This example demonstrates how you can leverage Flows from crewAI to automate the process of scoring leads, including data collection, analysis, and scoring. By utilizing Flows, the process becomes much simpler and more efficient.
+
+## Overview
+
+This flow will guide you through the process of setting up an automated lead scoring system. Here's a brief overview of what will happen in this flow:
+
+1. **Load Leads**: The flow starts by loading job description and the multiple resumes of the candidates.
+
+2. **Score Leads**: The `ATS-CrewAI` is kicked off to score the loaded leads based on predefined criteria.
+
+3. **Human in the Loop**: The top 3 candidates are presented for human review, allowing for additional feedback or proceeding with writing emails.
+
+4. **Write and Save Emails**: Emails are generated and saved for all leads.
+
+By following this flow, you can efficiently automate the process of scoring leads, leveraging the power of multiple AI agents to handle different aspects of the lead scoring workflow.
+
+## Installation
+
+Ensure you have Python >=3.10 <=3.13 installed on your system. First, if you haven't already, install CrewAI:
+
+```bash
+pip install crewai
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+1. First lock the dependencies and then install them:
+
+```bash
+crewai install
+```
+
+### Customizing & Dependencies
+
+**Add your `OPENAI_API_KEY` into the `.env` file**  
+**Add your `SERPER_API_KEY` into the `.env` file**
+
+
+## Running the Project
+
+### Run the Flow
+
+To kickstart your crew of AI agents and begin task execution, run this from the root folder of your project:
+
+```bash
+crewai run
+```
+```bash
+uv run kickoff
+```
+### Plot the Flow
+
+```bash
+uv run plot
+```
+
+This command initializes the lead_score_flow, assembling the agents and assigning them tasks as defined in your configuration.
+
+When you kickstart the flow, it will orchestrate multiple crews to perform the tasks. The flow will first collect lead data, then analyze the data, score the leads and generate email drafts.
+
+

app.py

@@ -0,0 +1,203 @@
+# job_match_scorer_app.py
+import streamlit as st
+import os
+import tempfile
+from src.ats.main import employer_kickoff,candidate_kickoff,improve_resume_for_ats
+from src.ats.utils.candidateUtils import get_resume_text,display_resume
+from dotenv import load_dotenv
+load_dotenv()
+
+# Streamlit app
+st.set_page_config(
+    page_title="Resume Match Scorer",
+    layout="centered"
+)
+
+# Sidebar - Role selection (placed above API key input)
+st.sidebar.title("🧭 Select Role")
+selected_role = st.sidebar.selectbox("I am a...", ["Candidate", "Employer"])
+
+# Sidebar - API Key input
+st.sidebar.title("🔑 OpenAI API Key")
+api_key = st.sidebar.text_input("Enter your OpenAI API Key", type="password")
+# Conditional UI based on role
+if selected_role == "Employer":
+    st.title("ATS Match Tool (For Employer)")
+    st.info(
+        "Upload a **Job Description** and multiple **Candidate Resumes** (PDF or DOCX). The system will:\n"
+        "1. **Parse and match** each resume against the job description.\n"
+        "2. **Score and rank** the candidates.\n"
+        "3. **Send personalized emails** to each candidate – selected or rejected – based on their match score."
+    )
+
+    # Inputs
+    job_description = st.text_area("📝 Paste Job Description", height=300, placeholder="Paste the full job description here")
+
+    uploaded_resumes = st.file_uploader(
+        "📎 Upload Resume Files (PDF or DOCX)",
+        type=["pdf", "docx"],
+        accept_multiple_files=True
+    )
+
+    if st.button("🔍 Score Resumes"):
+        if not api_key:
+            st.error("Please enter your OpenAI API key in the sidebar.")
+        elif not job_description.strip():
+            st.error("Please enter the Job Description.")
+        elif not uploaded_resumes:
+            st.error("Please upload at least one resume.")
+        else:
+            os.environ["OPENAI_API_KEY"]=api_key
+
+            with st.spinner("Analyzing resumes... This may take a minute."):
+
+                try:
+                    resume_texts = []
+                    id=0
+                    if uploaded_resumes:
+                        for file in uploaded_resumes:
+                            id+=1
+                            text = get_resume_text(file)
+                            resume_texts.append({
+                                "id":str(id),
+                                "filename": file.name,
+                                "content": text
+                            })
+                    #Crewai flow
+                    agent=employer_kickoff(job_description,resume_texts)
+                    st.session_state.agent = agent  # Save for later use
+
+                    if hasattr(agent.state, "top_candidates"):
+                        st.markdown("## Top Candidates Identified")
+
+                        for c in agent.state.top_candidates:
+                            st.markdown(
+                                f"**Name:** {c.name}<br>"
+                                f"**Score:** {c.score}<br>"
+                                f"**Reason:** {c.reason}<br><hr>",
+                                unsafe_allow_html=True
+                            )                  
+
+                        st.success("✅ Email sent successfully to all candidates")
+
+                except Exception as e:
+                    st.error(f"Error processing files: {e}")
+
+elif selected_role == "Candidate":
+
+    # --- Title and Mode Selector ---
+    st.title("🎯 Resume Assistant: Score or Improve Your Resume")
+    st.info(
+        "This tool offers two powerful features:\n"
+        "1. **Score your resume against a job description** to see how well it fits.\n"
+        "2. **Review and rewrite your resume** to improve your ATS (Applicant Tracking System) compatibility.\n\n"
+        "➡️ Select your goal below to get started."
+    )
+
+    # --- Mode Selector ---
+    mode = st.radio(
+        "What would you like to do?",
+        options=["Score Resume Against Job Description", "Rewrite Resume for ATS Compatibility"],
+        index=0
+    )
+    # --- Page Logic Based on Mode ---
+    if mode == "Score Resume Against Job Description":
+        st.subheader("🧪 Resume Match Scorer (For Candidates)")
+
+        job_url = st.text_input("Job Posting URL", placeholder="Enter the full URL here")
+        uploaded_resume = st.file_uploader(
+            "📎 Upload Your Resume (PDF or DOCX)",
+            type=["pdf", "docx"],
+        )
+
+        if st.button("🔍 Score Resume"):
+            if not api_key:
+                st.error("Please enter your OpenAI API key in the sidebar.")
+            elif not job_url.strip():
+                st.error("Please enter the URL to parse.")
+            elif not uploaded_resume:
+                st.error("Please upload your resume.")
+            else:
+                os.environ["OPENAI_API_KEY"] = api_key
+
+                with st.spinner("Analyzing your resume... This may take a minute."):
+                    try:
+                        with tempfile.TemporaryDirectory() as temp_dir:
+                            temp_file_path = os.path.join(temp_dir, uploaded_resume.name)
+                            with open(temp_file_path, "wb") as f:
+                                f.write(uploaded_resume.getvalue())
+
+                            agent = candidate_kickoff(job_url, temp_file_path)
+                            st.session_state.agent = agent
+
+                        if hasattr(agent.state, "candidate_score"):
+                            st.title("Resume Scoring Summary")
+
+                            st.subheader("📊 Candidate Score")
+                            st.metric(label="ATS Score", value=f"{agent.state.candidate_score.score} / 100")
+
+                            with st.expander("📋 Detailed Evaluation Reasoning", expanded=True):
+                                st.write(agent.state.candidate_score.reason)
+
+                            if agent.state.candidate_score.score >= 80:
+                                st.success("Strong match — highly recommended for interview.")
+                            elif agent.state.candidate_score.score >= 60:
+                                st.warning("Moderate match — candidate shows potential, but has some gaps.")
+                            else:
+                                st.error("Low match — candidate lacks key qualifications for this role.")
+
+                    except Exception as e:
+                        st.error(f"Error processing files: {e}")
+
+    elif mode == "Rewrite Resume for ATS Compatibility":
+        st.subheader("🛠️ Resume Rewriter for ATS Compatibility")
+        uploaded_resume = st.file_uploader("📎 Upload Your Resume (PDF or DOCX)", type=["pdf", "docx"])
+        # Optional job description URL
+        job_url = st.text_input("🔗 Optional: Enter Job Description URL (for tailored rewriting)")
+
+        if st.button("🧠 Improve Resume"):
+            if not api_key:
+                st.error("Please enter your OpenAI API key in the sidebar.")
+            elif not uploaded_resume:
+                st.error("Please upload your resume.")
+            else:
+                os.environ["OPENAI_API_KEY"] = api_key
+
+                with st.spinner("Rewriting your resume... Please wait."):
+                    try:
+                        resume_data = get_resume_text(uploaded_resume)
+                        agent = improve_resume_for_ats(resume_data,job_url)
+                        if hasattr(agent.state, "initial_score") and agent.state.initial_score is not None:
+                            st.subheader("📊 Current Resume Score")
+                            st.metric(label="ATS Score", value=f"{agent.state.initial_score.score} / 100")
+
+                            with st.expander("📋 Detailed Evaluation Reasoning", expanded=True):
+                                st.write(agent.state.initial_score.reason)
+
+                        if hasattr(agent.state, "improved_resume") and agent.state.improved_resume is not None:
+                            st.subheader("📊 Improved Resume Score")
+                            st.metric(label="ATS Score", value=f"{agent.state.improved_resume.score} / 100")
+                            resume_score= int(agent.state.improved_resume.score)
+                            if resume_score<85:
+                                feedback="""We've made the maximum improvements to your resume.
+                                "While it's still scoring below the target of 85, this version reflects the most optimized 
+                                version based on your input. For further enhancement, 
+                                consider tailoring specific experiences or achievements more closely to the job role."""
+                            else:
+                                feedback="Here's a revised version of your resume with better ATS optimization:"
+                            st.success(feedback)
+                            st.markdown(agent.state.improved_resume.resume_data)
+                            with st.expander("📋 Detailed Evaluation Feedback", expanded=True):
+                                st.write(agent.state.improved_resume.feedback)
+                            improved_resume=agent.state.improved_resume.resume_data
+                            st.download_button(
+                                label="⬇️ Download Improved Resume",
+                                data=improved_resume.encode("utf-8"),
+                                file_name="Resume_New.md",
+                                mime="text/markdown"
+                            )
+                        else:
+                            st.success("Your resume is already highly optimized for Applicant Tracking Systems (ATS), with a strong compatibility score")
+
+                    except Exception as e:
+                        st.error(f"Error improving resume: {e}")

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "ats-crewai"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11,<3.12"
+dependencies = [
+    "crewai[tools]",
+    "langchain-tools",
+    "crewai-tools",
+    "google-auth-oauthlib",
+    "google-api-python-client",
+    "pyvis",
+    "asyncio",
+    "onnxruntime==1.15.0",
+    "numpy<2.0.0",
+    "streamlit",
+    "firecrawl-py",
+    "spacy>=3.0.0",
+    "nltk>=3.8",
+    "en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl",
+    "python-docx>=0.8.11",
+    "docx2txt>=0.9",
+    "pymupdf>=1.25.5",
+]
+
+[project.optional-dependencies]
+win = ["python-magic-bin>=0.4.14"]  # Windows-only
+linux = ["python-magic>=0.4.27"]    # Linux-only

src/ats/constants.py

@@ -0,0 +1,47 @@
+JOB_DESCRIPTION = """
+# Junior React Developer
+
+**Position:** Junior React Developer  
+**Duration:** 12-month contract with the possibility of extension based on performance and project needs.
+
+We are seeking a motivated Junior React Developer to join our team and assist in the development of our cutting-edge Next.js web application. This project integrates the Vercel AI SDK to enhance user experience with advanced AI-driven features. 
+
+**Key Responsibilities:**
+- Develop and maintain React components and Next.js applications.
+- Integrate AI-driven features using the Vercel AI SDK.
+- Collaborate with senior developers to design and implement new features.
+- Optimize application performance and ensure responsiveness across different devices.
+- Participate in code reviews and contribute to best practices.
+- Troubleshoot and debug issues to ensure the highest quality of the web application.
+
+**Qualifications:**
+- 1-2 years of experience in front-end development with React and Next.js.
+- Proficiency in JavaScript, TypeScript, CSS, and HTML.
+- Experience with Git and RESTful APIs.
+- Familiarity with Vercel AI SDK is a plus.
+- Strong problem-solving skills and attention to detail.
+- Excellent communication and teamwork abilities.
+- Ability to work independently and take initiative on projects.
+
+**What We Offer:**
+- Opportunity to work with cutting-edge technologies and AI integration.
+- Collaborative and supportive work environment.
+- Mentorship from senior developers to help grow your skills.
+- Potential for role extension and career advancement within the company.
+- Flexible working hours and the possibility of remote work.
+
+This role is ideal for someone looking to grow their skills in Next.js, React, and AI-powered web applications while contributing to impactful projects.
+"""
+
+SKILLS = [
+    "React",
+    "Next.js",
+    "JavaScript",
+    "TypeScript",
+    "Vercel AI SDK",
+    "CSS",
+    "HTML",
+    "Git",
+    "REST APIs",
+    "CrewAI",
+]

src/ats/crews/lead_filter_crew/config/agents.yaml

@@ -0,0 +1,11 @@
+hr_evaluation_agent:
+  role: >
+    Senior HR Evaluation Expert
+  goal: >
+    Evaluate candidates based on their ID, name, bio, skills, and years of experience, comparing them against the provided job description. 
+    Provide a matching score (out of 100) along with a detailed reasoning for the evaluation.
+  backstory: >
+    As a Senior HR Evaluation Expert, you have extensive experience in assessing candidate profiles for technical and non-technical roles. 
+    You specialize in evaluating candidates by analyzing their skills, years of experience, career summary, and overall potential fit 
+    with the job description. You prioritize clear, structured assessments with transparent scoring and actionable feedback.
+  llm: openai/gpt-4o-mini

src/ats/crews/lead_filter_crew/config/tasks.yaml

@@ -0,0 +1,38 @@
+evaluate_candidate:
+  description: >
+    Evaluate a candidate's bio, skills, and years of experience based on the provided job description.
+
+    Use your expertise to assess how well the candidate matches the job requirements. Focus only on:
+    - Skill match
+    - Relevant experience
+    - Cultural fit
+    - Growth potential
+
+    CANDIDATE INFORMATION
+    ---------------------
+    Candidate ID: {candidate_id}
+    Name: {name}
+    Bio:
+    {bio}
+    Skills:
+    {skills}
+    Years of Experience: {years_of_exp}
+
+    JOB DESCRIPTION
+    ----------------
+    {job_description}
+
+    ADDITIONAL INSTRUCTIONS
+    ------------------------
+    Your final answer MUST return a JSON object in the following format:
+    {
+      "id": "<candidate_id>",
+      "name":"<candidate_name>",
+      "result": "Pass" or "Fail",
+      "reason": detailed reasoning explaining the result is "Pass" or "Fail"
+    }
+    Do not include any explanation, score, or extra text outside this JSON object.
+
+  expected_output: >
+    A JSON object with "candidate_id" ,"result" ("Pass" or "Fail") and "reason" fields only.
+  agent: hr_evaluation_agent

src/ats/crews/lead_filter_crew/lead_filter_crew.py

@@ -0,0 +1,35 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from src.ats.types import CandidateFilter
+
+
+@CrewBase
+class LeadFilterCrew:
+    """Lead Filter Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def hr_evaluation_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["hr_evaluation_agent"],
+            verbose=True,
+        )
+
+    @task
+    def evaluate_candidate_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["evaluate_candidate"],
+            output_pydantic=CandidateFilter,
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Lead Filter Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/crews/lead_response_crew/config/agents.yaml

@@ -0,0 +1,10 @@
+email_followup_agent:
+  role: >
+    HR Coordinator
+  goal: >
+    Compose personalized follow-up emails to candidates based on their bio and whether they are being pursued for the job. 
+    If we are proceeding, request availability for a Zoom call. Otherwise, send a polite rejection email.
+  backstory: >
+    You are an HR professional named Sunitha L V who works at XYZ Technologies Pvt Ltd. You are known with excellent communication skills and a talent for crafting personalized and thoughtful
+    emails to job candidates. You understand the importance of maintaining a positive and professional tone in all correspondence.
+  llm: openai/gpt-4o-mini

src/ats/crews/lead_response_crew/config/tasks.yaml

@@ -0,0 +1,26 @@
+send_followup_email:
+  description: >
+    Compose personalized follow-up emails for candidates who applied to a specific job.
+
+    You will use the candidate's name, reason of acceptance or rejection, and whether the company wants to proceed with them to generate the email. 
+    If the candidate is proceeding, ask them for their availability for a Zoom call in the upcoming days. 
+    If not, send a polite rejection email.
+
+    CANDIDATE DETAILS
+    -----------------
+    Candidate ID: {candidate_id}
+    Name: {name}
+    Reason:
+    {reason}
+
+    PROCEEDING WITH CANDIDATE: {proceed_with_candidate}
+
+    ADDITIONAL INSTRUCTIONS
+    -----------------------
+    - If we are proceeding, ask for their availability for a Zoom call within the next few days.
+    - If we are not proceeding, send a polite rejection email, acknowledging their effort in applying and appreciating their time.
+
+  expected_output: >
+    A personalized email based on the candidate's information. It should be professional and respectful, 
+    either inviting them for a Zoom call or letting them know we are pursuing other candidates.
+  agent: email_followup_agent

src/ats/crews/lead_response_crew/lead_response_crew.py

@@ -0,0 +1,35 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+
+@CrewBase
+class LeadResponseCrew:
+    """Lead Response Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def email_followup_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["email_followup_agent"],
+            verbose=True,
+            allow_delegation=False,
+        )
+
+    @task
+    def send_followup_email_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["send_followup_email"],
+            verbose=True,
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Lead Response Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/crews/lead_score_crew/config/agents.yaml

@@ -0,0 +1,10 @@
+hr_evaluation_agent:
+  role: >
+    Senior HR Evaluation Expert
+  goal: >
+    Evaluate resumes by scoring them against job descriptions when available, or assessing ATS compliance when no job description is provided.
+  backstory: >
+    As a Senior HR Evaluation Expert, you have extensive experience in assessing candidate profiles. You excel at
+    evaluating how well candidates match job descriptions by analyzing their skills, experience, cultural fit, and
+    growth potential. Your professional background allows you to provide comprehensive evaluations with clear reasoning.
+  llm: openai/gpt-4o-mini

src/ats/crews/lead_score_crew/config/tasks.yaml

@@ -0,0 +1,40 @@
+evaluate_candidate:
+  description: >
+    Evaluate a candidate's resume using job description when available, or ATS best practices when no job description is provided.
+
+    ## Evaluation Modes:
+    A) When job description is provided:
+    - Calculate skill match percentage
+    - Assess experience relevance (years, domain expertise)
+    - Identify cultural fit indicators
+    - Evaluate growth potential
+
+    B) When no job description:
+    - Score ATS compliance (0-100)
+    - Check action verb density
+    - Count quantified achievements
+    - Assess formatting effectiveness
+    - Verify keyword optimization
+
+    CANDIDATE BIO
+    -------------
+    Candidate ID: {candidate_id}
+    Name: {name}
+    Bio:
+    {bio}
+
+    JOB DESCRIPTION
+    ---------------
+    {job_description?JOB DESCRIPTION:## No Job Description Provided - Using ATS Standards##}
+
+    ADDITIONAL INSTRUCTIONS
+    -----------------------
+    Your final answer MUST include:
+    - The candidates unique ID
+    - A score between 1 and 100. Don't use numbers like 100, 75, or 50. Instead, use specific numbers like 87, 63, or 42.
+    - A detailed reasoning, considering the candidate’s skill match, experience, cultural fit, and growth potential.
+    {additional_instructions}
+
+  expected_output: >
+    A very specific score from 1 to 100 for the candidate, along with a detailed reasoning explaining why you assigned this score.
+  agent: hr_evaluation_agent

src/ats/crews/lead_score_crew/lead_score_crew.py

@@ -0,0 +1,35 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from src.ats.types import CandidateScore
+
+
+@CrewBase
+class LeadScoreCrew:
+    """Lead Score Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def hr_evaluation_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["hr_evaluation_agent"],
+            verbose=True,
+        )
+
+    @task
+    def evaluate_candidate_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["evaluate_candidate"],
+            output_pydantic=CandidateScore,
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Lead Score Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/crews/resume_parser_crew/config/agents.yaml

@@ -0,0 +1,12 @@
+resume_parser_agent:
+  role: >
+    Resume Parser agent
+  goal: >
+    Parse and extract structured candidate personal and professional information from the given resume file.
+  backstory: >
+    You are an AI assistant specialized in processing resumes using natural language and automated parsing tools. 
+    Your job is to extract valuable candidate information from resume file for further evaluation by recruiters.
+  llm: openai/gpt-4o-mini
+
+
+

src/ats/crews/resume_parser_crew/config/tasks.yaml

@@ -0,0 +1,8 @@
+resume_parser_task:
+  description: >
+    Parse the given resume file and extract structured information like name, education, skills, and experience.
+    Resume file path :{file_path}
+
+  expected_output: >
+    A structured summary of the candidate’s resume including name, contact information, education, work experience, and key skills.
+  agent: resume_parser_agent

src/ats/crews/resume_parser_crew/resume_parser_crew.py

@@ -0,0 +1,38 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from src.ats.crews.resume_parser_crew.tools.resume_parser_tool import ResumeParserTool
+from src.ats.types import ResumeData
+
+
+@CrewBase
+class ResumeParserCrew:
+    """Resume Parser Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+    
+
+    @agent
+    def resume_parser_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["resume_parser_agent"],
+            verbose=True,
+        )
+
+    @task
+    def resume_parser_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["resume_parser_task"],
+            tools=[ResumeParserTool()],
+            output_pydantic=ResumeData
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Resume Parser Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/crews/resume_parser_crew/tools/resume_parser_tool.py

@@ -0,0 +1,213 @@
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+import os
+from typing import Type
+import re
+import docx2txt
+import fitz  # PyMuPDF
+
+class ResumeParserInput(BaseModel):
+    file_path: str = Field(
+        ..., 
+        description="Path to the resume file (PDF/DOCX) to be parsed."
+    )
+
+class ResumeParserTool(BaseTool):
+    name: str = "Custom Resume Parser"
+    description: str = (
+        "Parses resumes from a file path (PDF/DOCX) and returns structured markdown-formatted data "
+        "including name, email, phone, skills, education, experience, and social links."
+    )
+    args_schema: Type[BaseModel] = ResumeParserInput
+
+    def _extract_text(self, file_path: str) -> str:
+        if file_path.lower().endswith('.pdf'):
+            doc = fitz.open(file_path)
+            return "\n".join([page.get_text() for page in doc])
+        elif file_path.lower().endswith('.docx'):
+            return docx2txt.process(file_path)
+        else:
+            raise ValueError("Unsupported file type. Only PDF and DOCX are supported.")
+
+    def _extract_field(self, text: str) -> dict:
+        data = {}
+
+        # Basic fields using regex
+        data["email"] = re.search(r"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+", text)
+        print("TEXT : ",text)
+        # Phone number extraction 
+        phone_pattern = re.compile(r"""
+            (?:\+?\d{1,3}[-.\s]?)?              # Optional country code
+            \(?\d{3}\)?[-.\s]?                   # Area code with optional parentheses
+            \d{3}[-.\s]?                         # First 3 digits
+            \d{4}                                # Last 4 digits
+        """, re.VERBOSE)
+        
+        phone_match = phone_pattern.search(text)
+        data["mobile_number"] = phone_match if phone_match else None
+        
+
+        data["linkedin"] = re.search(r"(https?://)?(www\.)?linkedin\.com/[^\s]+", text)
+        data["github"] = re.search(r"(https?://)?(www\.)?github\.com/\S+", text)
+
+        # Extract name: heuristic (first non-empty line with more than one word)
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        data["name"] = lines[0] if lines and len(lines[0].split()) <= 5 else "Not found"
+
+        # Extract sections using keywords
+        lower_text = text.lower()
+
+        def split_experience_entries(experience_text):
+            job_entries = []
+
+            # Remove bullet characters and normalize spacing
+            cleaned = re.sub(r"[\u2022\u2023\u25E6\u2043\u2219\u00b7\u2027\u25CF\u25CB\u25A0\u25A1\u25AA\u25AB\uF0B7]", "-", experience_text)
+            cleaned = re.sub(r"\s{2,}", " ", cleaned)  # Collapse multiple spaces
+            cleaned = cleaned.replace('\n', ' ').strip()
+
+            # Match job entries like: Role | Company | Dates
+            job_pattern = re.compile(r'([^\|]+?\|\s*[^\|]+?\|\s*[^|]+?)(?=\s+[^\|]+?\s+\|\s+[^\|]+?\s+\||\Z)', re.DOTALL)
+
+            matches = job_pattern.findall(cleaned)
+            for match in matches:
+                job_entries.append(match.strip())
+
+            return job_entries
+        
+        def split_skills(text):
+            return [s.strip() for s in re.split(r'[,\n]', text) if s.strip()]
+        
+        def split_education_entries(text):
+            return [line.strip() for line in text.split('\n') if line.strip()]
+
+        def split_project_entries(text):
+            return [line.strip() for line in text.split('\n\n') if line.strip()]
+
+        def split_certifications(text):
+            return [line.strip() for line in text.split('\n') if line.strip()]
+        
+        # def extract_section(possible_keywords):
+        #     if isinstance(possible_keywords, str):
+        #         possible_keywords = [possible_keywords]
+
+        #     for keyword in possible_keywords:
+        #         idx = lower_text.find(keyword.lower())
+        #         if idx != -1:
+        #             end_idx = lower_text.find('\n\n', idx)
+        #             return text[idx:end_idx].strip() if end_idx != -1 else text[idx:].strip()
+        #     return "Not found"
+        
+        def extract_experience(text):       
+            experience_pattern = r"""
+                (?:(?:\bwith|\bpossess|\bover|\baround)?\s*)      # Common prefixes
+                (\d+(?:\.\d+)?)                                    # Number (e.g., 3 or 2.5)
+                \s*                                                # Optional space
+                (?:\+?\s*\d+)?                                     # Optional range like 3-5
+                \s*                                                # Optional space
+                (?:years?|yrs?)                                    # Variations of "years"
+                (?:\s+of\s+(?:total\s+)??experience)?              # Optional "of experience"
+            """
+            match = re.search(experience_pattern, text, re.IGNORECASE | re.VERBOSE)
+            if match:
+                try:
+                    return float(match.group(1))
+                except (ValueError, AttributeError):
+                    return None
+            return None
+        
+        def extract_section(text, section_keywords, all_headers):
+            if isinstance(section_keywords, str):
+                section_keywords = [section_keywords]
+
+            # Create a combined regex pattern for headers (used to detect section boundaries)
+            headers_pattern = '|'.join([re.escape(h) for h in all_headers])
+
+            for keyword in section_keywords:
+                # Regex to find the keyword as a header
+                pattern = re.compile(rf'({keyword})\s*\n', flags=re.IGNORECASE)
+                match = pattern.search(text)
+                if match:
+                    start_idx = match.start()
+
+                    # Match only when a known header appears alone or nearly alone on a line
+                    next_header_pattern = re.compile(
+                        rf'\n\s*({headers_pattern})\s*[:\-]?\s*\n',
+                        flags=re.IGNORECASE
+                    )
+                    next_match = next_header_pattern.search(text, pos=match.end())
+                    end_idx = next_match.start() if next_match else len(text)
+
+                    return text[start_idx:end_idx].strip()
+
+            return "Not found"
+        
+        # Common headers (all potential headers to detect section boundaries)
+        all_headers = ["Experience", "Education", "Skills", "Certifications", "Projects", "Summary", "Objective", "Achievements"]
+
+        objective_text = extract_section(
+            text,
+            section_keywords=["Objective", "Career Objective", "Professional Summary", "Summary"],
+            all_headers=all_headers
+        )
+        data["objective"] = objective_text if objective_text != "Not found" else None
+
+        skills_text = extract_section(
+            text,
+            section_keywords=["Skills", "Technical Skills", "Core Competencies"],
+            all_headers=all_headers
+        )
+        data["skills"] = split_skills(skills_text)
+
+        education_text = extract_section(
+            text,
+            section_keywords=["Education", "Academic Background", "Educational Qualifications"],
+            all_headers=all_headers
+        )
+        data["education"] = split_education_entries(education_text)
+
+        data["experience_years"] = extract_experience(text)
+
+        experience_text = extract_section(text,
+            section_keywords=["Experience", "Professional Experience", "Work Experience"],
+            all_headers=all_headers
+        )
+        if experience_text.lower().startswith(("professional experience", "work experience", "experience")):
+            experience_text = experience_text.split('\n', 1)[-1].strip()
+        data["experience_details"] = split_experience_entries(experience_text)
+
+        projects_text = extract_section(
+            text,
+            section_keywords=["Projects", "Key Projects", "Academic Projects"],
+            all_headers=all_headers
+        )
+        data["projects"] = split_project_entries(projects_text)
+        
+        certs_text = extract_section(
+            text,
+            section_keywords=["Certifications", "Licenses", "Certificates"],
+            all_headers=all_headers
+        )
+        data["certifications"] = split_certifications(certs_text)
+
+        # Post-process regex matches
+        for k in ["email", "mobile_number", "linkedin", "github"]:
+            if data[k]:
+                data[k] = data[k].group()
+            else:
+                data[k] = "Not found"
+
+        return data
+
+    def _run(self, file_path: str) -> str:
+        try:
+            if not os.path.isfile(file_path):
+                return f"❌ Error: File does not exist at {file_path}"
+
+            text = self._extract_text(file_path)
+            extracted = self._extract_field(text)
+
+            result = [f"**{k.replace('_', ' ').title()}**: {v}" for k, v in extracted.items()]
+            return "\n".join(result)
+
+        except Exception as e:
+            return f"❌ An error occurred during parsing: {str(e)}"

src/ats/crews/resume_score_crew/config/agents.yaml

@@ -0,0 +1,10 @@
+resume_score_agent:
+  role: >
+    Senior HR Evaluation Expert
+  goal: >
+    Evaluate a structured resume (as a ResumeData object) against a provided job description and return a score from 0 to 100, along with detailed reasoning for the score.
+  backstory: >
+    As a Senior HR Evaluation Expert, you have extensive experience in assessing structured resume data. 
+    You analyze resumes by comparing the candidate's skills, education, experience, certifications, projects, and online presence (LinkedIn/GitHub) against the job description. 
+    You account for relevance, depth, and alignment with the role. You deliver clear, structured, and insightful evaluations that help determine candidate-job fit.
+  llm: openai/gpt-4o-mini

src/ats/crews/resume_score_crew/config/tasks.yaml

@@ -0,0 +1,40 @@
+resume_score_task:
+  description: >
+    Evaluate a candidate's structured resume data against the provided job description.
+
+    Use your expertise to carefully assess how well the candidate fits the job requirements. Consider key factors such as:
+    - Skill match
+    - Relevant experience (years + project details)
+    - Educational background
+    - Certifications
+    - Project experience
+    - Cultural fit and growth potential (use LinkedIn/GitHub if available)
+
+    CANDIDATE RESUME DATA
+    ---------------------
+    Name: {name}
+    Email: {email}
+    Mobile Number: {mobile_number}
+    Skills: {skills}
+    Education: {education}
+    Objective: {objective}
+    Total Experience (Years): {experience_years}
+    Experience Details: {experience_details}
+    Projects: {projects}
+    Certifications: {certifications}
+    LinkedIn: {linkedin}
+    GitHub: {github}
+
+    JOB DESCRIPTION
+    ---------------
+    {job_description}
+
+    ADDITIONAL INSTRUCTIONS
+    -----------------------
+    Your final answer MUST include:
+    - A score between 1 and 100. Don't use numbers like 100, 75, or 50. Instead, use specific numbers like 87, 63, or 42.
+    - A detailed reasoning, considering the candidate’s skill match, experience, education, projects, and growth potential.
+  
+  expected_output: >
+    A specific score (1-100) and detailed reasoning for why that score was given based on the candidate's resume data and the job description.
+  agent: resume_score_agent

src/ats/crews/resume_score_crew/resume_score_crew.py

@@ -0,0 +1,35 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from src.ats.types import CandidateScore
+
+
+@CrewBase
+class ResumeScoreCrew:
+    """Resume Score Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def resume_score_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["resume_score_agent"],
+            #verbose=True,
+        )
+
+    @task
+    def resume_score_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["resume_score_task"],
+            output_pydantic=CandidateScore,
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Resume Score Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            #verbose=True,
+        )

src/ats/crews/rewrite_resume_crew/config/agents.yaml

@@ -0,0 +1,16 @@
+rewrite_resume_agent:
+  role: >
+    ATS Resume Rewriting Agent
+  goal: >
+    Rewrite the uploaded resume to improve its compatibility with Applicant Tracking Systems (ATS). 
+    If a job description is provided, tailor the resume to match it for higher alignment and score.
+  backstory: >
+    You are an AI assistant specializing in enhancing resumes for optimal ATS parsing and matching.
+    You understand how to structure content, use relevant keywords, and present skills in a format 
+    that improves visibility in automated screening systems. If a job description is available, 
+    you analyze it and strategically tailor the resume to reflect relevant skills, experiences, and keywords.
+    If not, you rewrite the resume with general best practices for ATS optimization.
+  llm: openai/gpt-4o-mini
+
+
+

src/ats/crews/rewrite_resume_crew/config/tasks.yaml

@@ -0,0 +1,11 @@
+rewrite_resume_task:
+  description: >
+    Rewrite the resume contents {resume_data} to improve its compatibility with Applicant Tracking Systems (ATS).
+    If a job description is provided via {job_description}, tailor the resume to align with the job requirements.
+    Otherwise, apply general ATS optimization best practices.
+
+  expected_output: >
+    A rewritten version of the resume that is optimized for ATS.
+    If a job description was provided, the output should be customized to highlight relevant experience, skills, and keywords matching the job.
+    Otherwise, the resume should be improved for general ATS compatibility.
+  agent: rewrite_resume_agent

src/ats/crews/rewrite_resume_crew/rewrite_resume_crew.py

@@ -0,0 +1,38 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from src.ats.crews.rewrite_resume_crew.tools.rewrite_resume_tool import RewriteResumeTool
+from src.ats.types import Resume_Final
+
+
+@CrewBase
+class RewriteResumeCrew:
+    """Rewrite Resume Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+    
+
+    @agent
+    def rewrite_resume_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["rewrite_resume_agent"],
+            verbose=True,
+        )
+
+    @task
+    def rewrite_resume_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["rewrite_resume_task"],
+            tools=[RewriteResumeTool()],
+            output_pydantic=Resume_Final,
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Rewrite Resume Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/crews/rewrite_resume_crew/tools/rewrite_resume_tool.py

@@ -0,0 +1,145 @@
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+from typing import Type,Optional,Union
+import re
+import spacy
+
+nlp = spacy.load("en_core_web_sm")
+
+
+class ResumeInput(BaseModel):
+    resume_data: Union[str, dict] = Field(..., description="Raw text of the resume or dictionary containing resume data")
+    job_description: Optional[Union[str, dict]] = Field(default=None, description="Job description text or dictionary containing job description")
+
+class RewriteResumeTool(BaseTool):
+    name: str = "ATS Resume Rewriter"
+    description: str = (
+        "Analyzes and rewrites a resume to align with a job description by integrating missing keywords "
+        "into relevant sections while preserving formatting."
+    )
+    args_schema: Type[BaseModel] = ResumeInput
+
+    def _extract_keywords(self, jd_text: str) -> set:
+        doc = nlp(jd_text)
+        return {
+            token.lemma_.lower()
+            for token in doc
+            if token.pos_ in {"NOUN", "PROPN", "ADJ", "VERB"} and not token.is_stop
+        }
+
+    def _check_missing_keywords(self, resume_text: str, jd_keywords: set) -> set:
+        resume_doc = nlp(resume_text.lower())
+        resume_tokens = {token.lemma_ for token in resume_doc if not token.is_stop}
+        return jd_keywords - resume_tokens
+
+    def _insert_keywords_contextually(self, resume: str, missing_keywords: set) -> str:
+        sections = self._split_sections(resume)
+        injected_keywords = set()
+        rewritten_sections = []
+
+        for header, content in sections:
+            section_lower = header.lower()
+
+            if section_lower in {"summary", "objective", "professional summary"}:
+                enriched = self._enrich_section(content, missing_keywords, injected_keywords)
+            elif section_lower in {"skills"}:
+                enriched = self._add_to_comma_list(content, missing_keywords, injected_keywords)
+            elif section_lower in {"experience", "work experience"}:
+                enriched = self._enrich_section(content, missing_keywords, injected_keywords)
+            else:
+                enriched = content
+
+            rewritten_sections.append(f"{header}\n{enriched}")
+
+        rewritten_resume = "\n\n".join(rewritten_sections)
+        return rewritten_resume.strip()
+
+    def _split_sections(self, resume_text: str) -> list:
+        # Match lines that look like section headers (title case, max ~40 chars)
+        pattern = re.compile(r"^(?:[A-Z][A-Za-z\s]{2,40})$", re.MULTILINE)
+        matches = list(pattern.finditer(resume_text))
+        sections = []
+
+        for i in range(len(matches)):
+            start = matches[i].end()
+            end = matches[i + 1].start() if i + 1 < len(matches) else len(resume_text)
+            header = matches[i].group().strip()
+            content = resume_text[start:end].strip()
+            sections.append((header, content))
+
+        return sections or [("Resume", resume_text)]
+
+
+    def _enrich_section(self, text: str, keywords: set, used_keywords: set) -> str:
+        doc = nlp(text)
+        sentences = [sent.text for sent in doc.sents]
+        enriched = []
+
+        for sentence in sentences:
+            enriched.append(sentence)
+
+        # Add new sentence if keyword is not used
+        new_sentences = []
+        for keyword in keywords - used_keywords:
+            new_sentences.append(f"Demonstrates strong proficiency in {keyword}.")
+            used_keywords.add(keyword)
+
+        if new_sentences:
+            enriched.append(" ".join(new_sentences))
+
+        return " ".join(enriched)
+
+    def _add_to_comma_list(self, text: str, keywords: set, used_keywords: set) -> str:
+        skills = [s.strip() for s in re.split(r"[,\n]", text) if s.strip()]
+        for kw in keywords:
+            if kw not in [s.lower() for s in skills]:
+                skills.append(kw)
+                used_keywords.add(kw)
+        return ", ".join(skills)
+
+    def _run(self, resume_data: Union[str, dict], job_description: Optional[Union[str, dict]] = None) -> dict:
+        try:
+            # Extract resume text
+            resume_text = resume_data.get('description') if isinstance(resume_data, dict) else resume_data
+
+            if not resume_text or not isinstance(resume_text, str):
+                return {"resume_data": "", "feedback": "❌ Error: Invalid resume data format"}
+
+            # Extract job description text
+            jd_text = None
+            if job_description:
+                jd_text = job_description.get('description') if isinstance(job_description, dict) else job_description
+                if not jd_text or not isinstance(jd_text, str):
+                    return {"resume_data": "", "feedback": "❌ Error: Invalid job description format"}
+
+            # If job description is provided
+            if jd_text:
+                jd_keywords = self._extract_keywords(jd_text)
+                missing_keywords = self._check_missing_keywords(resume_text, jd_keywords)
+                rewritten_resume = self._insert_keywords_contextually(resume_text, missing_keywords)
+
+                feedback = (
+                    f"✅ Resume rewritten based on provided job description.\n"
+                    f"📝 Missing Keywords Identified: {', '.join(sorted(missing_keywords)) or 'None'}\n"
+                    f"🔧 Keywords were integrated contextually into relevant sections (e.g., Summary, Skills, Experience).\n"
+                    f"🎯 ATS Optimization Complete."
+                )
+
+            else:
+                # Fallback to general enrichment (for now, return original)
+                rewritten_resume = resume_text  # You can optionally enhance for generic ATS optimization.
+                feedback = (
+                    "ℹ️ No job description provided. Resume kept unchanged.\n"
+                    "Consider tailoring your resume for each role to improve ATS compatibility."
+                )
+
+            return {
+                "resume_data": rewritten_resume,
+                "feedback": feedback
+            }
+
+        except Exception as e:
+            return {
+                "resume_data": "",
+                "feedback": f"❌ Error preparing resume data: {str(e)}"
+            }

src/ats/crews/web_scraper_crew/config/agents.yaml

@@ -0,0 +1,15 @@
+web_scraper_agent:
+  role: >
+    Web Scraper
+  goal: >
+    Use the ScrapeWebsiteTool to extract the full job description from the given URL.
+  backstory: >
+    A web scraping expert capable of extracting targeted web content using specialized tools. 
+    You are provided with a URL and expected to return relevant, readable job description content.
+  llm: openai/gpt-4o-mini
+  instructions: >
+    You must use the FirecrawlScrapeWebsiteTool provided to you to scrape the content of the job description from the URL.
+    Do not attempt to generate or guess the content — only use the tool's output. Your task is done when the job description content is extracted and clearly presented.
+
+
+

src/ats/crews/web_scraper_crew/config/tasks.yaml

@@ -0,0 +1,28 @@
+web_scraper_task:
+  description: >
+    Extract the job description from the given URL: {job_description}
+
+    Use ONLY the tool named `scrape_website`.
+
+    Format your response exactly like this:
+
+    ```
+    Thought: I need to extract content from the URL
+    Action: scrape_website
+    Action Input: {"url": "{job_description}"}
+    ```
+
+    Wait for the tool to complete.
+
+    Then return:
+
+    ```
+    Thought: I now can give a great answer
+    Final Answer: <the full extracted text>
+    ```
+
+    Do not call any tool not listed. Only one action at a time. Do not invent the answer.
+  
+  expected_output: >
+    The extracted job description as plain text.
+  agent: web_scraper_agent

src/ats/crews/web_scraper_crew/web_scraper_crew.py

@@ -0,0 +1,45 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+#from src.ats.crews.web_scraper_crew.tools.webscraper_tool import WebscraperTool
+from crewai_tools import ScrapeWebsiteTool
+import os
+
+
+@CrewBase
+class WebScraperCrew:
+    """Lead Filter Crew"""
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def web_scraper_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config["web_scraper_agent"],  
+            tools=[ScrapeWebsiteTool(
+                    args={
+                    'pageOptions': {
+                    'onlyMainContent': True,
+                    'includeHtml': False
+                    },
+                    'timeout': 60000  # 60 seconds
+                    }
+                    )],
+            verbose=True,
+        )
+
+    @task
+    def web_scraper_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["web_scraper_task"],
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Web Scraper Crew"""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )

src/ats/email_responses/Amelia Cole.txt

@@ -0,0 +1,18 @@
+Subject: Next Steps in Your Application Process
+
+Dear Amelia,
+
+I hope this message finds you well! Thank you for your application for the Senior Frontend Developer position at XYZ Technologies Pvt Ltd. 
+
+After reviewing your impressive resume, I am pleased to inform you that we would like to proceed with your application. Your expertise in React.js and Next.js, along with your quantifiable achievement of improving performance by 30% in your previous roles, strongly aligns with what we are seeking. We believe that your skills and potential will be a valuable addition to our team.
+
+To discuss this opportunity further, could you please provide your availability for a Zoom call in the upcoming days? We would love to connect and learn more about your experiences.
+
+Looking forward to hearing from you soon!
+
+Best regards,  
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Your Email Address]  
+[Your Phone Number]

src/ats/email_responses/Jacob Reed.txt

@@ -0,0 +1,20 @@
+Subject: Next Steps in Your Application for Junior React Developer Position
+
+Dear Jacob,
+
+I hope this message finds you well. 
+
+I am pleased to inform you that we were very impressed with your application for the Junior React Developer position at XYZ Technologies Pvt Ltd. Your three years of experience in frontend development, particularly with React.js and Next.js, truly exceeds the requirements we were looking for. Additionally, your track record at PixelSoft Labs in optimizing application performance and collaborating with UI/UX teams aligns perfectly with our expectations for this role. 
+
+We also appreciate your involvement in mentoring junior developers and your participation in code reviews, which indicates a great cultural fit with our collaborative work environment.
+
+We would love to move forward with your application and discuss this opportunity further. Could you please provide your availability for a Zoom call in the upcoming days?
+
+Looking forward to hearing from you soon.
+
+Best regards,
+
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Your Contact Information]

src/ats/email_responses/John Carter.txt

@@ -0,0 +1,17 @@
+Subject: Thank You for Your Application at XYZ Technologies
+
+Dear John,
+
+Thank you for taking the time to apply for the Junior React Developer position at XYZ Technologies. We appreciate the effort you put into your application and your keen interest in joining our team.
+
+After careful consideration, we have decided to move forward with candidates who more closely meet the experience requirements for this role. While we were impressed by your foundational knowledge and passion for front-end development, the absence of practical experience, particularly in collaborating on team projects and using key frameworks, was a determining factor in our decision.
+
+We encourage you to continue developing your skills and gaining experience in the field. Please feel free to apply for future opportunities that align with your qualifications, as we recognize the potential in your journey.
+
+Thank you once again for your interest in XYZ Technologies. We wish you the best of luck in your job search and future endeavors.
+
+Warm regards,  
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Your Contact Information]

src/ats/email_responses/Nora Blake.txt

@@ -0,0 +1,20 @@
+Subject: Thank You for Your Application at XYZ Technologies
+
+Dear Nora,
+
+I hope this message finds you well. 
+
+Thank you for taking the time to apply for the Junior React Developer position at XYZ Technologies Pvt Ltd. We sincerely appreciate the effort you put into your application and your interest in joining our team.
+
+After careful consideration, we have decided to pursue other candidates for this particular role. While your strong background as a Frontend Developer with 6 years of experience is impressive, we feel that your extensive skill set may align better with more senior positions rather than the junior level we are currently looking to fill. 
+
+Please know that this decision was not easy and reflects the specific criteria we have set for this role. We genuinely appreciate your time and effort in applying, and we encourage you to explore further opportunities with us in the future that may be a better fit for your skills and experience.
+
+Thank you once again for your interest in XYZ Technologies. We wish you all the best in your job search and future endeavors.
+
+Warm regards,
+
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Your Contact Information]

src/ats/email_responses/Owen Mitchell.txt

@@ -0,0 +1,18 @@
+Subject: Your Application at XYZ Technologies Pvt Ltd
+
+Dear Owen,
+
+Thank you very much for your application for the Junior React Developer position at XYZ Technologies Pvt Ltd. We truly appreciate the time and effort you put into your application and the impressive experience you have as a Python Developer.
+
+After careful consideration, we regret to inform you that we will not be moving forward with your application for this role. While your background in backend development is commendable, we are specifically seeking candidates with more extensive experience in front-end technologies such as React, Next.js, TypeScript, CSS, and HTML, as well as familiarity with Vercel AI SDK.
+
+We value your interest in our company, and we encourage you to keep an eye on future openings that may align more closely with your skill set. We will retain your resume on file for any suitable positions that may arise.
+
+Thank you again for considering a career with us. We wish you all the best in your job search and future professional endeavors.
+
+Warm regards,
+
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Your Contact Information]

src/ats/email_responses/Sophia Williams.txt

@@ -0,0 +1,17 @@
+Subject: Next Steps in Your Application Process  
+
+Dear Sophia,  
+
+I hope this message finds you well! I want to take a moment to express our appreciation for your interest in the position at XYZ Technologies Pvt Ltd and for the time you invested in the application process.  
+
+After reviewing your profile, I am pleased to inform you that we were impressed by your strong skill set in React/Next.js development, along with your valuable experience at TechNova Solutions and PixelSoft Labs. Your adaptability, capacity for growth, and openness to exploring emerging technologies are characteristics we highly value at our company.  
+
+We would love to discuss the next steps in the hiring process with you. Could you please share your availability for a Zoom call within the next few days? We look forward to the opportunity to connect and learn more about you and how you can contribute to our team.  
+
+Thank you once again for your interest in joining XYZ Technologies Pvt Ltd. We are excited about the possibility of working together!  
+
+Best regards,  
+Sunitha L V  
+HR Coordinator  
+XYZ Technologies Pvt Ltd  
+[Contact Information]

src/ats/main.py

@@ -0,0 +1,496 @@
+#!/usr/bin/env python
+import asyncio
+from typing import List,Dict
+
+from crewai.flow.flow import Flow, listen, or_, router, start
+from pydantic import BaseModel,Field
+from typing import Optional
+from src.ats.crews.lead_response_crew.lead_response_crew import LeadResponseCrew
+from src.ats.crews.lead_score_crew.lead_score_crew import LeadScoreCrew
+from src.ats.crews.lead_filter_crew.lead_filter_crew import LeadFilterCrew
+from src.ats.crews.web_scraper_crew.web_scraper_crew import WebScraperCrew
+from src.ats.crews.resume_parser_crew.resume_parser_crew import ResumeParserCrew
+from src.ats.crews.resume_score_crew.resume_score_crew import ResumeScoreCrew
+from src.ats.crews.rewrite_resume_crew.rewrite_resume_crew import RewriteResumeCrew
+from src.ats.types import Candidate, CandidateScore, ScoredCandidate,CandidateFilter,ResumeData,Resume_Final
+from src.ats.utils.candidateUtils import combine_candidates_with_scores,extract_candidate_info,get_resume_text,send_email
+import csv
+
+
+class LeadScoreState(BaseModel):
+    jd:str=""
+    candidate_resumes:List[Dict] = []
+    candidates: List[Candidate] = []
+    failed_candidates: List[CandidateFilter] = []
+    candidate_score: List[CandidateScore] = []
+    candidate_filters:List[CandidateFilter] = []
+    hydrated_candidates: List[ScoredCandidate] = []
+    top_candidates: List[ScoredCandidate] = []
+    scored_leads_feedback: str = ""
+
+class CandidateScoreState(BaseModel):
+    jd:str=""
+    file_path:str = ""
+    resume_data:ResumeData | None = None
+    candidate_score: CandidateScore | None = None
+
+class ImproveResumeState(BaseModel):
+    jd:str=""
+    resume_data:str = ""
+    initial_score:CandidateScore | None = None
+    improved_resume: Resume_Final | None = None
+    is_rewrite:bool=False
+    rewrite_count:int=0
+    rewrite_score:CandidateScore | None = None
+
+
+#Employer flow
+class LeadScoreFlow(Flow[LeadScoreState]):
+    @start()
+    def load_leads(self):
+        id=0
+        candidates=[]
+        for resume_file in self.state.candidate_resumes:
+            # Step 1: Extract structured candidate info
+            id+=1
+            candidate_info = extract_candidate_info(resume_file["content"],resume_file["id"])
+            candidates.append(candidate_info)
+        with open("candidates_info.csv", "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["id", "name", "email", "bio","years_of_exp","skills"])
+            for candidate in candidates:
+                writer.writerow(
+                    [
+                        candidate.id,
+                        candidate.name,
+                        candidate.email,
+                        candidate.bio,
+                        candidate.years_of_exp,
+                        candidate.skills
+                    ]
+                )
+        #print("Candidates info saved to candidates_info.csv")   
+        # Update the state with the loaded candidates
+        self.state.candidates = candidates
+    
+    @listen(load_leads)
+    async def filter_leads(self):
+        #print("First level filtering of leads")
+        tasks = []
+
+        async def filter_candidate(candidate: Candidate):
+            result = await (
+                LeadFilterCrew()
+                .crew()
+                .kickoff_async(
+                    inputs={
+                        "candidate_id": candidate.id,
+                        "name": candidate.name,
+                        "bio": candidate.bio,
+                        "years_of_exp": candidate.years_of_exp,
+                        "skills": candidate.skills,
+                        "job_description": self.state.jd,
+                    }
+                )
+            )
+    
+            self.state.candidate_filters.append(result.pydantic)
+
+        for candidate in self.state.candidates:
+            #print("Scoring candidate:", candidate.name)
+            task = asyncio.create_task(filter_candidate(candidate))
+            tasks.append(task)
+
+        candidate_filters = await asyncio.gather(*tasks)
+        #print("Finished filtering leads: ", len(candidate_filters))
+        with open("filtered_candidates.csv", "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["id", "result", "reason"])
+            for candidate in self.state.candidate_filters:
+                writer.writerow(
+                    [
+                        candidate.id,
+                        candidate.result,
+                        candidate.reason,
+                    ]
+                )
+        #print("Filtered Candidates info saved to filtered_candidates.csv")   
+
+        #Filter failed candidates as a seperate list 
+        self.state.failed_candidates = [
+            cand
+            for cand in self.state.candidate_filters
+            if cand.result == "Fail"
+        ]
+
+        # Create a lookup dictionary from candidates using their ID
+        id_to_email = {candidate.id: candidate.email for candidate in self.state.candidates}
+        # Set the email in failed_candidates by matching ID for email sending purpose
+        for candidate in self.state.failed_candidates:
+            candidate_id = candidate.id
+            candidate.email = id_to_email.get(candidate_id)
+        
+
+        #set of passed IDs
+        passed_ids = {
+            cf.id
+            for cf in self.state.candidate_filters
+            if cf.result == "Pass"
+        }
+        
+        #Filter candidates list based on passed ids
+        self.state.candidates = [
+            cand
+            for cand in self.state.candidates
+            if cand.id in passed_ids
+        ]
+
+    @listen(or_(filter_leads, "scored_leads_feedback"))
+    async def score_leads(self):
+        #print("Scoring leads")
+        #Create a lookup dictionary from resumes
+        resume_lookup = {resume["id"]: resume["content"] for resume in self.state.candidate_resumes}
+        # Update each candidate's bio using the lookup
+        for candidate in self.state.candidates:
+            if candidate.id in resume_lookup:
+                candidate.bio = resume_lookup[candidate.id]
+
+        tasks = []
+
+        async def score_single_candidate(candidate: Candidate):
+            result = await (
+                LeadScoreCrew()
+                .crew()
+                .kickoff_async(
+                    inputs={
+                        "candidate_id": candidate.id,
+                        "name": candidate.name,
+                        "bio": candidate.bio,
+                        "job_description": self.state.jd,
+                        "additional_instructions": self.state.scored_leads_feedback,
+                    }
+                )
+            )
+
+            self.state.candidate_score.append(result.pydantic)
+
+        for candidate in self.state.candidates:
+            #print("Scoring candidate:", candidate.name)
+            task = asyncio.create_task(score_single_candidate(candidate))
+            tasks.append(task)
+
+        candidate_scores = await asyncio.gather(*tasks)
+        #print("Finished scoring leads")
+        with open("scored_candidates.csv", "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["id", "score", "reason"])
+            for candidate in self.state.candidate_score:
+                writer.writerow(
+                    [
+                        candidate.id,
+                        candidate.score,
+                        candidate.reason,
+                    ]
+                )
+        #print("Scored Candidates info saved to scored_candidates.csv")   
+
+    @router(score_leads)
+    def human_in_the_loop(self):
+        #print("Finding the top 3 candidates for human to review")
+
+        # Combine candidates with their scores using the helper function
+        self.state.hydrated_candidates = combine_candidates_with_scores(
+            self.state.candidates, self.state.candidate_score
+        )
+
+        # Sort the scored candidates by their score in descending order
+        sorted_candidates = sorted(
+            self.state.hydrated_candidates, key=lambda c: c.score, reverse=True
+        )
+        self.state.hydrated_candidates = sorted_candidates
+
+        # Select the top 3 candidates
+        self.state.top_candidates = sorted_candidates[:3]
+
+        # Present options to the user
+        # print("\nPlease choose an option:")
+        # print("1. Quit")
+        # print("2. Redo lead scoring with additional feedback")
+        # print("3. Proceed with writing emails to all leads")
+        
+        #Commenting for execution without interruption
+        #choice = input("Enter the number of your choice: ")
+        choice="3"
+
+        if choice == "1":
+            #print("Exiting the program.")
+            exit()
+        elif choice == "2":
+            feedback = input(
+                "\nPlease provide additional feedback on what you're looking for in candidates:\n"
+            )
+            self.state.scored_leads_feedback = feedback
+            #print("\nRe-running lead scoring with your feedback...")
+            return "scored_leads_feedback"
+        elif choice == "3":
+            #print("\nProceeding to write emails to all leads.")
+            return "generate_emails"
+        else:
+            #print("\nInvalid choice. Please try again.")
+            return "human_in_the_loop"
+
+    @listen("generate_emails")
+    async def write_and_save_emails(self):
+        import re
+        from pathlib import Path
+
+        #print("Writing and saving emails for all leads.")
+
+        # Determine the top 3 candidates to proceed with
+        top_candidate_ids = {
+            candidate.id for candidate in self.state.hydrated_candidates[:3]
+        }
+
+        tasks = []
+
+        # Create the directory 'email_responses' if it doesn't exist
+        output_dir = Path(__file__).parent / "email_responses"
+        #print("output_dir:", output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        async def write_email(candidate):
+            # Check if the candidate is among the top 3
+            proceed_with_candidate = candidate.id in top_candidate_ids
+
+            # Kick off the LeadResponseCrew for each candidate
+            result = await (
+                LeadResponseCrew()
+                .crew()
+                .kickoff_async(
+                    inputs={
+                        "candidate_id": candidate.id,
+                        "name": candidate.name,
+                        "reason": candidate.reason,
+                        "proceed_with_candidate": proceed_with_candidate,
+                    }
+                )
+            )
+
+            # Sanitize the candidate's name to create a valid filename
+            safe_name = re.sub(r"[^a-zA-Z0-9_\- ]", "", candidate.name)
+            filename = f"{safe_name}.txt"
+            #print("Filename:", filename)
+
+            # Write the email content to a text file
+            file_path = output_dir / filename
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(result.raw)
+            
+            #Send the corresponding email to each candidate
+            send_email(file_path,candidate.email)
+
+            # Return a message indicating the email was saved
+            return f"Email sent for {candidate.name} as {filename} to {candidate.email}"
+        
+        #Create a composite list for all candidates 
+        candidate_list = self.state.hydrated_candidates + self.state.failed_candidates
+
+        # Create tasks for all candidates
+        for candidate in candidate_list:
+            task = asyncio.create_task(write_email(candidate))
+            tasks.append(task)
+
+        # Run all email-writing tasks concurrently and collect results
+        email_results = await asyncio.gather(*tasks)
+
+        # After all emails have been generated and saved
+        #print("\nAll emails have been written and saved to 'email_responses' folder.")
+        # for message in email_results:
+        #     print(message)
+    def reset(self):
+        self.agents = []
+        self.tasks = []
+        self.memory = None
+
+
+# Candidate flow
+class CandidateScoreFlow(Flow[CandidateScoreState]):
+    @start()
+    def extract_job_descrpn(self):
+        result = WebScraperCrew().crew().kickoff(
+                    inputs={
+                        "job_description": self.state.jd,
+                    }
+                )
+        # Extract the actual string
+        job_description = str(result)
+        #print("Extracted website content:", job_description)
+        #print(self.state.file_path)
+
+        # Save result to state
+        self.state.jd = job_description
+            
+    @listen(extract_job_descrpn)
+    def parse_resume(self):
+        #Extract data from resume
+        result =ResumeParserCrew().crew().kickoff(
+                    inputs={
+                        "file_path": self.state.file_path
+                    }
+                )
+        self.state.resume_data=result.pydantic
+        #print(self.state.resume_data)
+    
+    @listen(parse_resume)
+    def score_resume(self):
+        result = ResumeScoreCrew().crew().kickoff(
+            inputs={
+                    "name": self.state.resume_data.name,
+                    "email": self.state.resume_data.email,
+                    "mobile_number": self.state.resume_data.mobile_number,
+                    "skills": self.state.resume_data.skills,
+                    "education": self.state.resume_data.education,
+                    "objective": self.state.resume_data.objective,
+                    "experience_years": self.state.resume_data.experience_years,
+                    "experience_details": self.state.resume_data.experience_details,
+                    "projects": self.state.resume_data.projects,
+                    "certifications": self.state.resume_data.certifications,
+                    "linkedin": self.state.resume_data.linkedin,
+                    "github": self.state.resume_data.github,
+                    "job_description": self.state.jd,
+                }
+            )
+        
+    
+        self.state.candidate_score = result.pydantic
+    def reset(self):
+        self.agents = []
+        self.tasks = []
+        self.memory = None
+
+
+# Improve resume flow
+class ImproveResumeFlow(Flow[ImproveResumeState]):
+    @start()
+    def extract_job_descrpn(self):
+        if self.state.jd:
+            result = WebScraperCrew().crew().kickoff(
+                        inputs={
+                            "job_description": self.state.jd,
+                        }
+                    )
+            # Extract the actual string
+            job_description = str(result)
+        else:
+            job_description=""
+        #print("Extracted website content:", job_description)
+
+        # Save result to state
+        self.state.jd = job_description
+    
+    @listen(or_("extract_job_descrpn", "rewrite_resume"))
+    def score_resume(self):
+        if self.state.is_rewrite:
+            resume_data=self.state.improved_resume.resume_data
+        else:
+            resume_data=self.state.resume_data
+            
+        result = LeadScoreCrew().crew().kickoff(
+                inputs={
+                    "candidate_id": "1",
+                    "name": "",
+                    "bio": resume_data,
+                    "job_description": self.state.jd,
+                    "additional_instructions": "",
+                }
+            )   
+        if self.state.is_rewrite:
+            self.state.rewrite_score= result.pydantic
+            self.state.improved_resume.score=self.state.rewrite_score.score
+            #print("REWRITE SCORE IS ",self.state.improved_resume.score)
+        else:
+            self.state.initial_score= result.pydantic
+            #print("INITIAL SCORE IS ",self.state.initial_score.score)
+    @router("score_resume")
+    def rewrite_condition_check(self):
+        if self.state.is_rewrite:
+            resume_score=self.state.rewrite_score.score
+        else:
+            resume_score=self.state.initial_score.score
+        #print("REWRITE COUNT ",self.state.rewrite_count)
+        if int(resume_score) < 85 and self.state.rewrite_count<=2:
+            return "improve_resume"
+    
+    @listen("improve_resume")
+    def rewrite_resume(self):
+        #Rewrite resume
+        #print("IN REWRITE RESUME job description is : ",self.state.jd)
+        result =RewriteResumeCrew().crew().kickoff(
+                    inputs={
+                        "resume_data": self.state.resume_data,
+                        "job_description": self.state.jd,
+                    }
+                )
+        self.state.improved_resume=result.pydantic
+        self.state.is_rewrite=True
+        self.state.rewrite_count+=1
+    
+    def reset(self):
+        self.agents = []
+        self.tasks = []
+        self.memory = None
+
+def employer_kickoff(jd,candidate_resumes):
+    """
+    Run the flow.
+    """
+    lead_score_flow = LeadScoreFlow()
+    lead_score_flow.reset()
+    lead_score_flow.kickoff(inputs={"jd":jd,"candidate_resumes":candidate_resumes})
+    plot()
+    return lead_score_flow
+
+def candidate_kickoff(jd,file_path):
+    """
+    Run the flow.
+    """
+    cand_score_flow = CandidateScoreFlow()
+    cand_score_flow.reset()
+    cand_score_flow.kickoff(inputs={"jd":jd,"file_path":file_path})
+    cand_plot()
+    return cand_score_flow
+
+def improve_resume_for_ats(resume_data,jd):
+    """
+    Run the flow.
+    """
+    improve_resume_flow = ImproveResumeFlow()
+    improve_resume_flow.reset()
+    improve_resume_flow.kickoff(inputs={"jd":jd,"resume_data":resume_data})
+    improve_resume_plot()
+    return improve_resume_flow
+
+
+def plot():
+    """
+    Plot the flow.
+    """
+    lead_score_flow = LeadScoreFlow()
+    lead_score_flow.plot()
+
+def cand_plot():
+    """
+    Plot the flow.
+    """
+    cand_score_flow = CandidateScoreFlow()
+    cand_score_flow.plot()
+
+def improve_resume_plot():
+    """
+    Plot the flow.
+    """
+    improve_resume_flow = ImproveResumeFlow()
+    improve_resume_flow.plot()
+
+
+

src/ats/types.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel,Field , EmailStr, HttpUrl
+from typing_extensions import Literal
+from typing import List, Optional
+from datetime import datetime
+
+
+class JobDescription(BaseModel):
+    title: str
+    description: str
+    skills: str
+
+
+class Candidate(BaseModel):
+    id: str
+    name: str
+    email: str
+    bio: str
+    years_of_exp:str
+    skills: str
+
+class CandidateFilter(BaseModel):
+    id: str
+    name:str
+    email: str
+    result: Literal["Pass", "Fail"] = Field(
+        None, description="The Pass or Fail result"
+    )
+    reason:str
+
+class CandidateScore(BaseModel):
+    id: str
+    score: int
+    reason: str
+
+
+class ScoredCandidate(BaseModel):
+    id: str
+    name: str
+    email: str
+    bio: str
+    skills: str
+    score: int
+    reason: str
+
+
+class ResumeData(BaseModel):
+    name: str
+    email: str
+    mobile_number: str
+    skills: List[str]
+    education: List[str]
+    objective:Optional[List[str]]
+    experience_years: Optional[float]
+    experience_details: Optional[List[str]]
+    projects: Optional[List[str]]
+    certifications: Optional[List[str]]
+    linkedin: Optional[str]
+    github: Optional[str]
+
+class Resume_Final(BaseModel):
+    resume_data:str
+    feedback:str
+    score:str

src/ats/utils/candidateUtils.py

@@ -0,0 +1,181 @@
+from typing import List
+
+from src.ats.types import Candidate, CandidateScore, ScoredCandidate
+import csv
+from  openai import OpenAI,OpenAIError  
+import docx
+import pdfplumber
+import json
+import os
+import csv
+import smtplib
+from email.mime.text import MIMEText
+import base64
+import streamlit as st
+
+def extract_text_from_pdf(file):
+    text = ""
+    with pdfplumber.open(file) as pdf:
+        for page in pdf.pages:
+            text += page.extract_text() + "\n"
+    return text
+
+def extract_text_from_docx(file):
+    doc = docx.Document(file)
+    text = "\n".join([para.text for para in doc.paragraphs])
+    return text
+
+def get_resume_text(file):
+    if file.type == "application/pdf":
+        return extract_text_from_pdf(file)
+    elif file.type in ["application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/msword"]:
+        return extract_text_from_docx(file)
+    else:
+        return None
+
+def extract_candidate_info(resume_text,id)-> Candidate:
+    prompt = (
+        f"Extract the following information from the candidate resume:\n"
+        f"- Full Name\n"
+        f"- Email Address\n"
+        f"- A short biodata (concise 3-4 line professional summary)\n"
+        f"- Total Years of Professional Experience\n"
+        f"- List of Key Skills (comma-separated)\n\n"
+        f"Resume:\n{resume_text}\n\n"
+        f"Respond in the following JSON format:\n"
+        f"""{{
+            "name": "<name>",
+            "email": "<email>",
+            "biodata": "<biodata>",
+            "years_of_experience": "<years>",
+            "skills": ["<skill1>", "<skill2>", "..."],
+        }}"""
+    )
+
+    #To generate specific JSON structure from openai
+    candidate_schema = {
+    "name": "extract_candidate_info",
+    "description": "Extracts structured candidate information from a resume.",
+    "parameters": Candidate.model_json_schema()
+    }   
+    
+    client = OpenAI()
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are an expert resume screener and recruiter."},
+                {"role": "user", "content": prompt}
+            ],
+            functions=[candidate_schema],
+            function_call={"name": "extract_candidate_info"},
+        )
+
+        #print("RESPONSE : ",response)
+
+        # Get and parse the arguments
+        function_args = response.choices[0].message.function_call.arguments
+    except OpenAIError as e:
+        print(f"OpenAI API call failed: {e}")
+        return None
+
+    try:
+        data = json.loads(function_args)
+    except json.JSONDecodeError:
+        # fallback if model responds badly
+        return None
+    data["id"] = str(id)
+    return Candidate(**data)
+
+
+def combine_candidates_with_scores(
+    candidates: List[Candidate], candidate_scores: List[CandidateScore]
+) -> List[ScoredCandidate]:
+    """
+    Combine the candidates with their scores using a dictionary for efficient lookups.
+    """
+    print("COMBINING CANDIDATES WITH SCORES")
+    print("SCORES:", candidate_scores)
+    print("CANDIDATES:", candidates)
+    # Create a dictionary to map score IDs to their corresponding CandidateScore objects
+    score_dict = {score.id: score for score in candidate_scores}
+    print("SCORE DICT:", score_dict)
+
+    scored_candidates = []
+    for candidate in candidates:
+        score = score_dict.get(candidate.id)
+        if score:
+            scored_candidates.append(
+                ScoredCandidate(
+                    id=candidate.id,
+                    name=candidate.name,
+                    email=candidate.email,
+                    bio=candidate.bio,
+                    skills=candidate.skills,
+                    score=score.score,
+                    reason=score.reason,
+                )
+            )
+
+    print("SCORED CANDIDATES:", scored_candidates)
+    with open("lead_scores.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["id", "name", "email", "score"])
+        for candidate in scored_candidates:
+            writer.writerow(
+                [
+                    candidate.id,
+                    candidate.name,
+                    candidate.email,
+                    candidate.score
+                ]
+            )
+    print("Lead scores saved to lead_scores.csv")
+    return scored_candidates
+
+def send_email(file_path,to_email):
+    EMAIL_ADDRESS = os.getenv("EMAIL_ADDRESS")
+    EMAIL_PASSWORD = os.getenv("EMAIL_PASSWORD")
+    SMTP_SERVER = 'smtp.gmail.com'
+    SMTP_PORT = 587
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        if not lines[0].lower().startswith("subject:"):
+            raise ValueError(f"File {file_path} does not start with 'Subject:'")
+
+        subject = lines[0][8:].strip()
+        body = "".join(lines[1:]).strip()
+
+        msg = MIMEText(body)
+        msg['Subject'] = subject
+        msg['From'] = EMAIL_ADDRESS
+        msg['To'] = to_email
+
+        with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
+            server.starttls()
+            server.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
+            server.send_message(msg)
+            print(f"Email sent to {to_email}")
+
+    except Exception as e:
+        print(f"Error sending to {to_email}: {e}")
+
+
+def display_resume(file_bytes: bytes, file_name: str):
+    """Displays the uploaded PDF in an iframe."""
+    base64_pdf = base64.b64encode(file_bytes).decode("utf-8")
+    pdf_display = f"""
+    <iframe 
+        src="data:application/pdf;base64,{base64_pdf}" 
+        width="100%" 
+        height="600px" 
+        type="application/pdf"
+    >
+    </iframe>
+    """
+    st.markdown(f"### Preview of {file_name}")
+    st.markdown(pdf_display, unsafe_allow_html=True)
+
+