Your commit message

.env

@@ -0,0 +1,3 @@
+MODEL = "gpt-4o-mini"
+OPENAI_API_KEY = "sk-gwsGNkYyB3dt2mnJTG1ALWeZQqUGuP48gbFNdVjURvT3BlbkFJfnriz0muCX7jgtf98uHUnM_suaZre22pH0II1drJ8A"
+OPENAI_MODEL = "gpt-4o-mini"

app.py

@@ -0,0 +1,253 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+import PyPDF2
+from docx import Document
+import io
+from typing import Dict, Any, List
+from pydantic import BaseModel, Field
+import plotly.graph_objects as go
+import json
+import re
+from docx.shared import Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+import plotly.io as pio
+from mh_aspects import agent as aspects_agent
+from mh_classification import agent as clarification_agent
+from mh_evaluation import MHEvaluationAgent as mh_eval_agent
+
+# Load environment variables
+load_dotenv()
+
+# Get model from environment
+OPENAI_MODEL = os.getenv('OPENAI_MODEL', 'gpt-3.5-turbo')
+
+# Initialize evaluation agent
+mh_eval_agent = mh_eval_agent()
+
+def test_api_connection():
+    """Test if the OpenAI API is working"""
+    try:
+        # Create a test job description
+        test_jd = """Test Job Description
+        Position: Software Engineer
+        Requirements:
+        - 3+ years of Python experience
+        - Bachelor's degree in Computer Science
+        - Experience with web development
+        """
+        
+        # Try to get a response from the aspects agent
+        response = aspects_agent.run(input=f"Analyze this job description and generate key must-have aspects only:\n\n{test_jd}")
+        
+        if response:
+            st.success("✅ API connection successful!")
+            return True
+        else:
+            st.error("❌ API connection failed: No response received")
+            return False
+    except Exception as e:
+        st.error(f"❌ API connection failed: {str(e)}")
+        return False
+
+# Pydantic model for must-have requirements
+class MustHaveAnalysis(BaseModel):
+    category: str = Field(..., description="Category (1: No must-haves mentioned, 2: Meets Requirements, 3: Does Not Meet)")
+    evidence: List[str] = Field(default_factory=list, description="Evidence supporting the categorization")
+    confidence: float = Field(default=0.8, description="Confidence score between 0 and 1")
+
+# Set page config
+st.set_page_config(
+    page_title="JD & Resume Analyzer",
+    page_icon="📄",
+    layout="wide"
+)
+
+# Initialize session state
+if 'analysis_result' not in st.session_state:
+    st.session_state.analysis_result = None
+if 'aspects' not in st.session_state:
+    st.session_state.aspects = None
+if 'clarifications' not in st.session_state:
+    st.session_state.clarifications = None
+
+def create_gauge_chart(value, title):
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': title},
+        gauge={
+            'axis': {'range': [0, 100]},
+            'bar': {'color': "rgb(50, 168, 82)"},
+            'steps': [
+                {'range': [0, 33], 'color': "lightgray"},
+                {'range': [33, 66], 'color': "gray"},
+                {'range': [66, 100], 'color': "darkgray"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 80
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        height=250,
+        margin=dict(l=10, r=10, t=50, b=10),
+        paper_bgcolor="rgba(0,0,0,0)",
+        font={'color': "#31333F"}
+    )
+    return fig
+
+def extract_text_from_pdf(file):
+    try:
+        pdf_reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text() + "\n"
+        return text.strip()
+    except Exception as e:
+        st.error(f"Error reading PDF: {str(e)}")
+        return None
+
+def extract_text_from_docx(file):
+    try:
+        doc = Document(io.BytesIO(file.read()))
+        text = ""
+        for paragraph in doc.paragraphs:
+            text += paragraph.text + "\n"
+        return text.strip()
+    except Exception as e:
+        st.error(f"Error reading DOCX: {str(e)}")
+        return None
+
+def read_file_content(file):
+    if file is None:
+        return None
+        
+    file_extension = file.name.split('.')[-1].lower()
+    
+    try:
+        if file_extension == 'pdf':
+            file_copy = io.BytesIO(file.read())
+            file.seek(0)
+            return extract_text_from_pdf(file_copy)
+        elif file_extension == 'docx':
+            return extract_text_from_docx(file)
+        elif file_extension == 'txt':
+            return file.read().decode('utf-8').strip()
+        else:
+            raise ValueError(f"Unsupported file type: {file_extension}")
+    except Exception as e:
+        st.error(f"Error reading file {file.name}: {str(e)}")
+        return None
+
+def analyze_must_haves(jd_text: str, resume_text: str) -> Dict:
+    """Analyze must-have requirements using the three-step process"""
+    try:
+        # Step 1: Generate must-have aspects from JD
+        aspects = aspects_agent.run(input=f"Analyze this job description and generate key must-have aspects only:\n\n{jd_text}")
+        st.session_state.aspects = aspects
+        
+        # Step 2: Generate clarifications from resume
+        input_text = f"""Checkpoints:
+{aspects}
+
+Resume:
+{resume_text}"""
+        clarifications = clarification_agent.run(input=input_text)
+        st.session_state.clarifications = clarifications
+        
+        # Step 3: Final evaluation
+        evaluation = mh_eval_agent.forward(
+            job_description=jd_text,
+            profile=resume_text,
+            checkpoints=aspects,
+            answer_script=clarifications
+        )
+        
+        return {
+            'aspects': aspects,
+            'clarifications': clarifications,
+            'evaluation': evaluation
+        }
+    except Exception as e:
+        st.error(f"Error in analysis pipeline: {str(e)}")
+        return None
+
+def display_analysis_result(result: Dict):
+    if not result:
+        st.error("Analysis failed")
+        return
+
+    st.title("Must-Have Requirements Analysis")
+    
+    # Display aspects
+    with st.expander("🎯 Must-Have Requirements", expanded=True):
+        st.write(result['aspects'])
+    
+    # Display clarifications
+    with st.expander("🔍 Clarifications", expanded=True):
+        st.write(result['clarifications'])
+    
+    # Display evaluation
+    st.header("📊 Final Evaluation")
+    evaluation = result['evaluation']
+    
+    # Display the evaluation in the requested format
+    st.write(evaluation)
+
+def main():
+    st.title("📄 JD & Resume Must-Have Requirements Analyzer")
+    
+    # Test API connection when the page loads
+    if not test_api_connection():
+        st.warning("⚠️ Please check your API key and model configuration in the .env file")
+        return
+        
+    st.write("Upload a job description and resume to analyze if the candidate meets the must-have requirements.")
+    
+    # Display the model being used
+    st.sidebar.info(f"Using model: {OPENAI_MODEL}")
+
+    # File uploaders
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        jd_file = st.file_uploader("Upload Job Description (PDF, DOCX, or TXT)", type=['pdf', 'docx', 'txt'])
+        if jd_file:
+            st.text_area("Job Description Content", read_file_content(jd_file), height=300)
+    
+    with col2:
+        resume_file = st.file_uploader("Upload Resume (PDF, DOCX, or TXT)", type=['pdf', 'docx', 'txt'])
+        if resume_file:
+            st.text_area("Resume Content", read_file_content(resume_file), height=300)
+
+    # Process button
+    if st.button("Analyze Must-Have Requirements"):
+        if jd_file and resume_file:
+            with st.spinner("Analyzing documents..."):
+                try:
+                    jd_text = read_file_content(jd_file)
+                    resume_text = read_file_content(resume_file)
+                    
+                    if jd_text and resume_text:
+                        analysis = analyze_must_haves(jd_text, resume_text)
+                        st.session_state.analysis_result = analysis
+                        display_analysis_result(analysis)
+                    else:
+                        st.error("Failed to extract text from one or both files.")
+                    
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+        else:
+            st.warning("Please upload both a job description and resume.")
+
+    # Display previous results if available
+    if st.session_state.analysis_result and not (jd_file and resume_file):
+        display_analysis_result(st.session_state.analysis_result)
+
+if __name__ == "__main__":
+    main()

mh_aspects.py

@@ -0,0 +1,115 @@
+import os
+import time
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.agents import initialize_agent, AgentType
+from langchain.tools import Tool
+from langchain.agents import Tool
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+
+# Load environment variables
+load_dotenv()
+
+# Set environment variables for model API key and model type
+os.environ.setdefault("DSP_CACHEBOOL", "false")
+
+# Get API key
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is not set")
+
+# Initialize the chat model
+model = ChatOpenAI(
+    model=os.getenv("MODEL", "gpt-4o-mini"),
+    openai_api_key=api_key,
+    temperature=0.0,
+    max_tokens=4000
+)
+
+# Define your tool to process the job description
+class JobDescriptionProcessor(Tool):
+    def __init__(self, name: str, description: str, func):
+        super().__init__(name=name, func=func, description=description)
+
+    def _run(self, job_description: str):
+        return self.func(job_description)
+
+# Define a function to generate aspects based on job description
+def generate_aspects(job_description: str) -> str:
+    # Create a prompt for the model
+    prompt = f"""
+    You are an expert recruiter specialized in analyzing resumes against job descriptions (JDs). Your task is to formulate checkpoints that focus on verifying criteria that are explicitly mentioned as must-have in the JD. These checkpoints will help generate insightful responses in the next step, ensuring the resume is analyzed against the critical, non-negotiable requirements, if any, outlined in the JD.
+
+    **Input**: The input for this task will be the job description (JD).
+    **Output**: Formulate 2 to 3 evaluation checkpoints/criteria focused solely on the must-have requirements. These checkpoints/criteria will serve as evaluation criteria for the next stage, where the candidate's resume will be checked for evidence and reasoning.
+
+    ### Steps:
+    1) Understand the JD and determine the number of checkpoints (between 2-3) required depending on the specifications from the JD and the context of the role. For freshers/career beginners, the number of checkpoints could be less in number.
+    2) With a holistic and pragmatic approach, formulate the checkpoints that cover the verifiable aspects usually available from resumes. Note that the cultural aspects or thinking process or future plans of the candidate should not be part of this exercise.
+
+    **Guidelines**:
+    1. Identify parameters explicitly marked as must-have in the JD.
+        a. Consider the context and include aspects labeled as “required,” “mandatory,” “essential,” “prerequisite,” or similar if appropriate to be considered as must-have.
+        b. Focus only on very critical criteria that, if missing, should lead to disqualification of the candidate.
+    2. Clearly differentiate between must-haves and good-to-haves/preferences.
+        a. Exclude any parameters described as “preferred,” “nice-to-have,” or optional.
+    3. If specific education, certification, or experience is not explicitly mentioned as a must-have, do not include it in this section.
+    
+    **Output Format:**
+    Checkpoint 1: [Description of checkpoint]
+    Checkpoint 2: [Description of checkpoint]"""
+    
+    # Get response from the model
+    response = model.invoke([HumanMessage(content=prompt)])
+    return response.content
+
+# Define the agent tools
+tools = [
+    JobDescriptionProcessor(
+        name="JobDescriptionProcessor",
+        description="Process job descriptions and generate aspects",
+        func=generate_aspects,
+    ),
+]
+
+# Initialize the LangChain agent
+agent = initialize_agent(
+    tools, model, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
+)
+
+# Main logic to execute the agent with job description input
+if __name__ == "__main__":
+    good_jd = """
+    Job Description
+    Workday FIN Consultant
+    Sentient Solutions is a rapidly growing accounting outsourcing firm with clients across the United States. Sentient's highly experienced team of experts based in the US, India, and Mexico offer fully customized solutions to suit the specific business needs of CPA Firms. With AI, process automation, and a suite of scalable services, we promise success to CPA firms.
+    Location: Jubilee Hills, Hyderabad
+    Experience: 3 to 7 years
+    Website: https://sentientsolutions.io/
+    Job Summary :
+    1. Ensure a smooth transition and onboarding of new partner firms  and tuck-ins into our Workday Financials landscape.
+    Ensure newly acquired firms and tuck-ins are live on Workday financials on Day 1 of deal closure
+    Demonstrate strong service orientation, change management skills, and overall dedication to stakeholder success at our Partner Firms
+    Seek to drive process and automation-based improvements to minimize the time to delivery for onboarding and the resources required to onboard new acquisitions.
+    Participate in overall partner firm integration and lead the conversations around financials integration.  Maintain an updated playbook for all requirements to onboard an acquisition effectively.
+    2. Demonstrate strong knowledge in multiple Workday Financials areas to include core financials, suppliers, accounts payable, expenses, payroll, banking, assets, report writing.
+    Perform as a subject matter expert in the aforementioned Workday areas.
+    Act as the first point of service for Workday Financials related support questions
+    Escalate as necessary, to our external partners, manage the use of the external partnership to support workday Financials.
+    3. Monitor and maintain all Workday financials integrations and workflows.
+    Proactively resolve errors in integration and workflows
+    Provide suggestions to the change committee for improving integration and workflows to maximize efficiency and reduce opportunities for error.
+    4. Achieve an NPS score > 70 by the end of the first year for Partner Firm Experience with Workday onboarding
+    Maximize the Partner Firm experience by embodying our values and committing to excellent customer service.
+    5. VALUES & CULTURE: Uphold and embody Ascend values
+    Own it. We seize growth opportunities with the passion, speed and accountability of an entrepreneur.
+    Serve whole-heartedly. We love our people and serve them with positivity and kindness.
+    Be excellent. We set a high bar because our mission matters.
+    Win together. We stay in sync, achieve as a team and celebrate each other.
+    Bring the sunshine. We have fun and bring enthusiasm to make the journey joyful.
+    """
+
+    # Run the LangChain agent to get the results
+    ans = agent.run(job_description=good_jd)
+    print("\n\ncriteria : \n", ans)

mh_clarification.py

@@ -0,0 +1,101 @@
+import os
+import time
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.agents import initialize_agent, AgentType
+from langchain.tools import Tool
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+
+# Load environment variables
+load_dotenv()
+
+# Set environment variables for model API key and model type
+os.environ.setdefault("DSP_CACHEBOOL", "false")
+
+# Get API key
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is not set")
+
+# Initialize the chat model
+model = ChatOpenAI(
+    model=os.getenv("MODEL", "gpt-3.5-turbo"),
+    openai_api_key=api_key,
+    temperature=0.0,
+    max_tokens=4000
+)
+
+# Define the clarification prompt
+clarification_prompt = PromptTemplate(
+    input_variables=["checkpoints", "resume"],
+    template="""
+    You are an expert recruiter specializing in reading resumes against job descriptions. Your task is to read the checkpoints provided and extract objective and factual information (if available) from the resume to clarify these checkpoints.
+
+    **Guidelines:**
+    1. Analyze both explicit and implicit meanings from the resume.
+    2. For must-have certifications, consider only those explicitly mentioned. Do not assume.
+    3. For industry relevance, assess the organizations listed and determine their industries.
+    4. For education and certifications, verify if they match stated requirements.
+    5. Provide objective reasoning with factual pointers from the resume.
+    6. Do not hallucinate or include information not grounded in the resume.
+    7. If the resume lacks enough information, mention this explicitly.
+
+    **Checkpoints:**
+    {checkpoints}
+
+    **Resume:**
+    {resume}
+
+    **Output Format:**
+    Checkpoint 1: [Factual reasoning from resume based on checkpoint]
+    Checkpoint 2: [Factual reasoning from resume based on checkpoint]
+    """
+)
+
+# Define a tool to process checkpoints and resume
+class ClarificationProcessor(Tool):
+    def __init__(self, name: str, description: str, func):
+        super().__init__(name=name, func=func, description=description)
+
+    def _run(self, input: str):
+        # Extract checkpoints and resume from the input string
+        try:
+            # Split by "Resume:" and ensure we have both parts
+            parts = input.split("Resume:")
+            if len(parts) != 2:
+                return "Error: Input must contain both checkpoints and resume sections"
+            
+            # Extract checkpoints and resume, removing any extra whitespace
+            checkpoints = parts[0].replace("Checkpoints:", "").strip()
+            resume = parts[1].strip()
+            
+            if not checkpoints or not resume:
+                return "Error: Both checkpoints and resume sections must not be empty"
+                
+            return self.func(checkpoints, resume)
+        except Exception as e:
+            return f"Error processing input: {str(e)}"
+
+# Define a function to generate clarifications based on checkpoints and resume
+def generate_clarifications(checkpoints: str, resume: str) -> str:
+    # Create the prompt
+    prompt_text = clarification_prompt.format(checkpoints=checkpoints, resume=resume)
+    
+    # Get response from the model
+    response = model.invoke([HumanMessage(content=prompt_text)])
+    return response.content
+
+# Define the agent tools
+tools = [
+    ClarificationProcessor(
+        name="ClarificationProcessor",
+        description="Generate clarifications based on the provided checkpoints and resume.",
+        func=generate_clarifications,
+    ),
+]
+
+# Initialize the LangChain agent
+agent = initialize_agent(
+    tools, model, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
+) 

mh_classification.py

@@ -0,0 +1,118 @@
+import os
+import time
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.agents import initialize_agent, AgentType
+from langchain.tools import Tool
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+from prompts.mh_clarification import clarification_prompt
+
+# Load environment variables
+load_dotenv()
+
+# Set environment variables for model API key and model type
+os.environ.setdefault("DSP_CACHEBOOL", "false")
+
+# Get API key
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is not set")
+
+# Initialize the chat model
+model = ChatOpenAI(
+    model=os.getenv("MODEL", "gpt-3.5-turbo"),
+    openai_api_key=api_key,
+    temperature=0.0,
+    max_tokens=4000
+)
+
+# Define a tool to process job descriptions
+class JobDescriptionProcessor(Tool):
+    def __init__(self, name: str, description: str, func):
+        super().__init__(name=name, func=func, description=description)
+
+    def _run(self, input: str):
+        try:
+            # Extract key aspects from the job description
+            aspects = self.func(input)
+            return aspects
+        except Exception as e:
+            return f"Error processing job description: {str(e)}"
+
+# Define a function to extract key aspects from job description
+def extract_key_aspects(jd: str) -> str:
+    try:
+        # Create a prompt for extracting key aspects
+        prompt = f"""Extract the key aspects from this job description. Focus on:
+1. Position title
+2. Required qualifications
+3. Experience requirements
+4. Key skills
+5. Must-have requirements
+
+Job Description:
+{jd}
+
+Format the output as a clear list of key aspects."""
+        
+        # Get response from the model
+        response = model.invoke([HumanMessage(content=prompt)])
+        return response.content
+    except Exception as e:
+        return f"Error extracting key aspects: {str(e)}"
+
+# Define a tool to process checkpoints and resume
+class ClarificationProcessor(Tool):
+    def __init__(self, name: str, description: str, func):
+        super().__init__(name=name, func=func, description=description)
+
+    def _run(self, input: str):
+        # Extract checkpoints and resume from the input string
+        try:
+            # Split by "Resume:" and ensure we have both parts
+            parts = input.split("Resume:")
+            if len(parts) != 2:
+                return "Error: Input must contain both checkpoints and resume sections"
+            
+            # Extract checkpoints and resume, removing any extra whitespace
+            checkpoints = parts[0].replace("Checkpoints:", "").strip()
+            resume = parts[1].strip()
+            
+            if not checkpoints or not resume:
+                return "Error: Both checkpoints and resume sections must not be empty"
+                
+            return self.func(checkpoints, resume)
+        except Exception as e:
+            return f"Error processing input: {str(e)}"
+
+# Define a function to generate clarifications based on checkpoints and resume
+def generate_clarifications(checkpoints: str, resume: str) -> str:
+    try:
+        # Create the prompt
+        prompt_text = clarification_prompt.format(checkpoints=checkpoints, resume=resume)
+        
+        # Get response from the model
+        response = model.invoke([HumanMessage(content=prompt_text)])
+        return response.content
+    except Exception as e:
+        return f"Error generating clarifications: {str(e)}"
+
+# Define the agent tools
+tools = [
+    JobDescriptionProcessor(
+        name="JobDescriptionProcessor",
+        description="Extract key aspects from a job description.",
+        func=extract_key_aspects,
+    ),
+    ClarificationProcessor(
+        name="ClarificationProcessor",
+        description="Generate clarifications based on the provided checkpoints and resume.",
+        func=generate_clarifications,
+    ),
+]
+
+# Initialize the LangChain agent
+agent = initialize_agent(
+    tools, model, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
+)

mh_evaluation.py

@@ -0,0 +1,114 @@
+import os
+import time
+from typing import List, Optional
+from langchain_openai import ChatOpenAI
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+
+# Load environment variables
+load_dotenv()
+
+class BaseAgent:
+    def __init__(self, tools: Optional[List] = None):
+        # Get API key
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is not set")
+            
+        self.model = ChatOpenAI(
+            model=os.getenv("MODEL", "gpt-3.5-turbo"),
+            openai_api_key=api_key,
+            max_tokens=4000,
+            temperature=0.0, 
+            top_p=1
+        )
+
+class MHEvaluationAgent(BaseAgent):
+    def __init__(self, tools: Optional[List] = None):
+        super().__init__(tools)
+        
+        # Define the evaluation prompt
+        self.evaluation_prompt = PromptTemplate(
+            input_variables=["job_description", "candidates_profile", "checkpoints", "answer_script"],
+            template="""
+            You are an expert recruiter specializing in evaluating resumes against job descriptions.
+            Your task is to evaluate and assign a categorisation for the candidate's resume based on the "checkpoints" and "answer_script" provided to understand how well it aligns with the JD. Also provide a brief reasoning. You are required to take a pragmatic and holistic approach considering the context of the resume and understand the implied aspects as well.  For example, if the JD specifies requirement of Graduation and the resume mentions post-graduation, it is implied that the person holds graduation and should be considered as such.
+
+            Think step by step and follow the instructions provided below:
+
+            *Input*: The input for this task will be "Checkpoints" and " Answer Script" and "Job  Description".
+            *Output*: The output should be category of the resume and a summary of evidence and reasoning explaining the observation and the reasons for the categorisation.
+
+            ### Steps:
+
+            Step1 : *Understand the Job Description along with checkpoints and answer script provided*
+
+            Step 2 : Analyse if the answers from the checkpoints and answer script satisfy the must-haves while considering the following aspects :
+
+            a)	If there are any checkpoints related to years of experience, do not strictly focus on just the number of years in the literary sense. The number of years should be given due importance, but more importantly, considered holistically  taking into account the context of the role, responsibilities handled by the candidate, etc. Minor deviations in number of years of experience should not lead to disqualification.
+
+            b)	While considering the other checkpoints and answers, take a holistic and a pragmatic approach in understanding and give due importance to both the explicit and implied experiences and skills based on the role/responsibilities, context of the roles and past experiences of the individual. 
+
+            C) If there are any checkpoints related to Education, consider the context while evaluating. For example, if the JD specifies requirement of Graduation and the resume mentions post-graduation, it is implied that the person qualifies for that checkpoint.
+
+            Step 3 : Based on the understanding from Step 1 and Step 2, categorise the resume following the criteria specified below :
+
+            a)	Category I : JD does not explicitly or implicitly specify any must-haves or essentials for the resume to be considered for the role.
+            b)	Category II: Satisfies all must-haves explicitly or implicitly. If there is slight uncertainty, give benefit of doubt to the candidate and place him/her in Category II.
+            c)	Category III: Lacks one or more must-haves mentioned in the JD.
+
+            Step 4. *Provide factual evidence:*
+            Provide reasoning for the rating along with observations and explaining why the candidate has been assigned to a particular category. Include specific examples from the "checkpoints" and "Answer script" to support your categorisation.
+
+            ### Output Format:
+            ### Output Format:
+            **category**: category I/II/III based on the evidence.
+            **evidence**: Provide a concise justification for categorization in only 40-50 words explaining why the candidate's relevant skills and expertise does or does not align with the skills required for the role outlined in the job description.
+
+            Job Description:
+            {job_description}
+
+            Candidate's Resume:
+            {candidates_profile}
+
+            Checkpoints:
+            {checkpoints}
+
+            Answer Script:
+            {answer_script}
+            """
+        )
+    
+    def forward(
+        self, 
+        job_description: Optional[str] = None,
+        profile: Optional[str] = None,
+        checkpoints: Optional[str] = None,
+        answer_script: Optional[str] = None,
+        retries: int = 5
+    ) -> Optional[str]:
+        if job_description:
+            for _ in range(retries):
+                try:
+                    # Create the prompt
+                    prompt_text = self.evaluation_prompt.format(
+                        job_description=job_description,
+                        candidates_profile=profile or "",
+                        checkpoints=checkpoints or "",
+                        answer_script=answer_script or ""
+                    )
+                    
+                    # Get response from the model
+                    response = self.model.invoke([HumanMessage(content=prompt_text)])
+                    return response.content
+                except Exception as e:
+                    print(e)
+                    time.sleep(3)
+        return None
+
+if __name__ == "__main__":
+    agent = MHEvaluationAgent()
+    ans = agent.forward(job_description="good_jd", profile="profile")
+    print("\n\nResult:", ans)

prompts/mh_aspects.py

@@ -0,0 +1,41 @@
+from typing import List, Dict
+from pydantic import BaseModel
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain.llms import OpenAI
+
+class AspectsStructure(BaseModel):
+    checkpoints: List[str]
+
+prompt_template = PromptTemplate(
+    input_variables=["job_description"],
+    template="""
+    You are an expert recruiter specialized in analyzing resumes against job descriptions (JDs). Your task is to formulate checkpoints that focus on verifying criteria that are explicitly mentioned as must-have in the JD. These checkpoints will help generate insightful responses in the next step, ensuring the resume is analyzed against the critical, non-negotiable requirements, if any, outlined in the JD.
+
+    **Input**: The input for this task will be the job description (JD).
+    **Output**: Formulate 2 to 3 evaluation checkpoints/criteria focused solely on the must-have requirements. These checkpoints/criteria will serve as evaluation criteria for the next stage, where the candidate's resume will be checked for evidence and reasoning.
+
+    ### Steps:
+    1) Understand the JD and determine the number of checkpoints (between 2-3) required depending on the specifications from the JD and the context of the role. For freshers/career beginners, the number of checkpoints could be less in number.
+    2) With a holistic and pragmatic approach, formulate the checkpoints that cover the verifiable aspects usually available from resumes. Note that the cultural aspects or thinking process or future plans of the candidate should not be part of this exercise.
+
+    **Guidelines**:
+    1. Identify parameters explicitly marked as must-have in the JD.
+        a. Consider the context and include aspects labeled as “required,” “mandatory,” “essential,” “prerequisite,” or similar if appropriate to be considered as must-have.
+        b. Focus only on very critical criteria that, if missing, should lead to disqualification of the candidate.
+    2. Clearly differentiate between must-haves and good-to-haves/preferences.
+        a. Exclude any parameters described as “preferred,” “nice-to-have,” or optional.
+    3. If specific education, certification, or experience is not explicitly mentioned as a must-have, do not include it in this section.
+    
+    **Output Format:**
+    Checkpoint 1: [Description of checkpoint]
+    Checkpoint 2: [Description of checkpoint]
+    """
+)
+
+class MhAspectsSignature:
+    def __init__(self, llm: OpenAI):
+        self.chain = LLMChain(llm=llm, prompt=prompt_template)
+
+    def generate_checkpoints(self, job_description: str) -> str:
+        return self.chain.run(job_description=job_description)

prompts/mh_clarification.py

@@ -0,0 +1,33 @@
+from typing import List, Dict
+from langchain.prompts import PromptTemplate
+
+# Define the prompt template
+clarification_prompt = PromptTemplate(
+    input_variables=["checkpoints", "resume"],
+    template="""
+    You are an expert recruiter specializing in reading resumes against job descriptions. Your task is to read the checkpoints provided and extract objective and factual information (if available) from the resume to clarify these checkpoints.
+
+    **Guidelines:**
+    1. Analyze both explicit and implicit meanings from the resume.
+    2. For must-have certifications, consider only those explicitly mentioned. Do not assume.
+    3. For industry relevance, assess the organizations listed and determine their industries.
+    4. For education and certifications, verify if they match stated requirements.
+    5. Provide objective reasoning with factual pointers from the resume.
+    6. Do not hallucinate or include information not grounded in the resume.
+    7. If the resume lacks enough information, mention this explicitly.
+
+    **Checkpoints:**
+    {checkpoints}
+
+    **Resume:**
+    {resume}
+
+    **Output Format:**
+    [✅ Must-Haves
+    Category: 2 ✅ Meets Requirements
+    Evidence:
+    • [List specific evidence points for each must-have requirement]
+    "musthave": "[List the must-have requirements exactly as provided]"
+    "musthave": "[Provide detailed analysis of each must-have requirement]"]
+    """
+)

prompts/mh_evaluation_prompt.py

@@ -0,0 +1,75 @@
+from typing import List
+from pydantic import BaseModel
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain.chat_models import ChatOpenAI
+
+# Define the structured output model
+class MHEvaluationResult(BaseModel):
+    category: str  # Category I, II, or III
+    evidence: str  # Justification for the categorization
+
+# Define the prompt template
+resume_evaluation_prompt = PromptTemplate(
+    input_variables=["job_description", "candidates_profile", "checkpoints", "answer_script"],
+    template="""
+You are an expert recruiter specializing in evaluating resumes against job descriptions.
+Your task is to evaluate and assign a categorization for the candidate's resume based on the "checkpoints" and "answer_script" provided to understand how well it aligns with the JD. Also, provide a brief reasoning. You are required to take a pragmatic and holistic approach considering the context of the resume and implied aspects.
+
+### Steps:
+Step 1: Understand the Job Description along with the checkpoints and answer script.
+Step 2: Analyze if the answers from the checkpoints and answer script satisfy the must-haves while considering the following aspects:
+- Years of experience: Consider responsibilities and role context rather than strictly adhering to a numeric limit.
+- Education: If a post-graduate degree is mentioned, assume the person has an undergraduate degree.
+- Implicit and explicit matches: Identify if relevant skills and experience satisfy the role.
+
+Step 3: Based on analysis, categorize the resume into:
+- **Category I:** JD does not explicitly or implicitly specify any must-haves.
+- **Category II:** Satisfies all must-haves explicitly or implicitly.
+- **Category III:** Lacks one or more must-haves.
+
+Step 4: Provide evidence supporting the categorization.
+
+**Job Description:**
+{job_description}
+
+**Candidate's Resume:**
+{candidates_profile}
+
+**Checkpoints:**
+{checkpoints}
+
+**Answer Script:**
+{answer_script}
+
+### Output Format:
+- **category**: (I/II/III)
+- **evidence**: A concise 70-100 word justification.
+
+Output:
+- Category: [Assign category]
+- Evidence: [Provide justification]
+"""
+)
+
+# Initialize the LLM (e.g., GPT-4)
+llm = ChatOpenAI(model_name="gpt-4o-mini", temperature=0)
+
+# Create an LLMChain
+resume_evaluation_chain = LLMChain(llm=llm, prompt=resume_evaluation_prompt)
+
+# Example input
+job_description = "Looking for a Data Scientist with 3+ years of experience in Python and ML. A Master's degree is preferred."
+candidates_profile = "John Doe has a Master's in Data Science and 4 years of Python experience in ML projects."
+checkpoints = "1. Must have Python experience. 2. Must have a Master's degree. 3. Must have 3+ years of ML experience."
+answer_script = "John Doe explicitly mentions 4 years of Python and ML experience, along with a Master's degree."
+
+# Run the evaluation
+response = resume_evaluation_chain.run(
+    job_description=job_description,
+    candidates_profile=candidates_profile,
+    checkpoints=checkpoints,
+    answer_script=answer_script
+)
+
+print(response)

requirements.txt

@@ -0,0 +1,8 @@
+streamlit
+langchain
+langchain-openai
+python-dotenv
+openai
+PyPDF2
+python-docx
+langchain[openai]