agentProfile.py

import groq
from pdfextractor import extract_text_from_pdf
from models import Profile, SocialMedia, Project, Skill, Education
from typing import List, Dict, Any, Optional
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain_groq import ChatGroq
import json
from config import get_settings

settings = get_settings()

class ProfileExtractor:
    """
    Class for extracting profile information from resume text
    """
    def __init__(self):
        self.groq_api_key = settings.GROQ_API_KEY
        self.model_name = settings.MODEL_NAME
        self.temperature = settings.TEMPERATURE
        self.max_tokens = settings.MAX_TOKENS
        self.llm = self._initialize_llm()
    
    def _initialize_llm(self) -> ChatGroq:
        """Initialize the language model client"""
        return ChatGroq(
            groq_api_key=self.groq_api_key,
            model_name=self.model_name,
            temperature=self.temperature,
            max_tokens=self.max_tokens
        )
    
    def extract_profile(self, pdf_text: str) -> Profile:
        """
        Main method to extract profile information from PDF text
        
        Args:
            pdf_text: Text extracted from a resume PDF
            
        Returns:
            Profile object with extracted information
        """
        try:
            profile = self._extract_with_langchain(pdf_text)
            return profile
        except Exception as e:
            if settings.DEBUG:
                print(f"LangChain extraction failed: {e}")
            return self._extract_with_fallback(pdf_text)
    
    def _extract_with_langchain(self, pdf_text: str) -> Profile:
        """Extract profile with structured LangChain approach"""
        # Define the format instructions for the LLM
        format_instructions = """
        Extract the following information from the resume:
        1. Full name
        2. Professional title
        3. Email address
        4. Bio (a 50-100 word professional summary)
        5. Tagline (a short 5-10 word catchy phrase summarizing professional identity)
        6. Social media links (LinkedIn, GitHub, Instagram)
        7. Projects (with title, description, and tech stack)
        8. Skills
        9. Education history (with school, degree, field of study, start date and end date)
        
        Return the information in the following JSON format:
        {
            "name": "Full Name",
            "title": "Professional Title",
            "email": "email@example.com",
            "bio": "Professional biography...",
            "tagline": "Catchy professional tagline",
            "social": {
                "linkedin": "LinkedIn URL or null",
                "github": "GitHub URL or null",
                "instagram": "Instagram URL or null"
            },
            "projects": [
                {
                    "title": "Project Title",
                    "description": "Project Description",
                    "techStack": "Technologies used"
                }
            ],
            "skills": [
                {"name": "Skill 1"},
                {"name": "Skill 2"}
            ],
            "educations": [
                {
                    "school": "University Name",
                    "degree": "Degree Type (e.g., Bachelor's, Master's)",
                    "fieldOfStudy": "Major or Field",
                    "startDate": "Start Year",
                    "endDate": "End Year or Present"
                }
            ]
        }
        
        If any information is not available, use null for that field.
        """
        
        # Create the prompt template
        template = """
        You are a professional resume parser. Extract structured information from the following resume:
        
        {pdf_text}
        
        {format_instructions}
        """
        
        prompt = PromptTemplate(
            template=template,
            input_variables=["pdf_text"],
            partial_variables={"format_instructions": format_instructions}
        )
        
        # Get the structured information from the LLM
        chain = prompt | self.llm
        result = chain.invoke({"pdf_text": pdf_text})
        response_text = result.content
        
        # Extract JSON from the response text (in case the LLM adds extra text)
        json_start = response_text.find('{')
        json_end = response_text.rfind('}') + 1
        
        if json_start >= 0 and json_end > json_start:
            json_str = response_text[json_start:json_end]
            profile_dict = json.loads(json_str)
            
            # Create a Profile object from the dictionary
            profile = Profile.model_validate(profile_dict)
            
            # Check for missing information and try to extract it if necessary
            profile = self._fill_missing_information(profile, pdf_text)
            
            return profile
        else:
            raise ValueError("No JSON found in the response")
    
    def _fill_missing_information(self, profile: Profile, pdf_text: str) -> Profile:
        """
        Attempts to fill in any missing information in the profile
        """
        # Check and fill name if missing
        if not profile.name or profile.name == "N/A":
            try:
                response = self.llm.invoke("Extract only the full name from this resume text. Respond with just the name: " + pdf_text[:settings.CHUNK_SIZE])
                name = response.content.strip()
                if name and name != "N/A":
                    profile.name = name
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error extracting name: {e}")
        
        # Check and fill title if missing
        if not profile.title or profile.title == "N/A":
            try:
                response = self.llm.invoke("Extract only the professional title from this resume text. Respond with just the title: " + pdf_text[:settings.CHUNK_SIZE])
                title = response.content.strip()
                if title and title != "N/A":
                    profile.title = title
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error extracting title: {e}")
        
        # Check and fill email if missing
        if not profile.email or profile.email == "N/A":
            try:
                response = self.llm.invoke("Extract only the email address from this resume text. Respond with just the email: " + pdf_text)
                email = response.content.strip()
                if email and email != "N/A" and "@" in email:
                    profile.email = email
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error extracting email: {e}")
        
        # Check and fill bio if missing
        if not profile.bio or profile.bio == "N/A":
            try:
                response = self.llm.invoke("Create a short professional biography (around 50-100 words) based on this resume. Focus on skills and experience: " + pdf_text)
                bio = response.content.strip()
                if bio and bio != "N/A":
                    profile.bio = bio
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error creating bio: {e}")
        
        # Check for education if missing
        if not profile.educations:
            try:
                education_prompt = "Extract education history from this resume. For each education entry, provide the school name, degree type, field of study, start date, and end date. Format the response as a list of JSON objects."
                response = self.llm.invoke(education_prompt + "\n\n" + pdf_text)
                education_text = response.content.strip()
                
                # Try to extract JSON from the response
                json_start = education_text.find('[')
                json_end = education_text.rfind(']') + 1
                
                if json_start >= 0 and json_end > json_start:
                    edu_json = education_text[json_start:json_end]
                    educations = json.loads(edu_json)
                    
                    for edu in educations:
                        education = Education(
                            school=edu.get("school", "Unknown"),
                            degree=edu.get("degree", ""),
                            fieldOfStudy=edu.get("fieldOfStudy", ""),
                            startDate=edu.get("startDate", ""),
                            endDate=edu.get("endDate", "")
                        )
                        profile.educations.append(education)
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error extracting education: {e}")
        
        return profile
    
    def _extract_with_fallback(self, pdf_text: str) -> Profile:
        """Fallback method for profile extraction using direct API calls"""
        client = groq.Groq(api_key=self.groq_api_key)
        
        def get_llm_response(prompt: str) -> str:
            """Helper function to get a response from the LLM."""
            try:
                chat_completion = client.chat.completions.create(
                    messages=[{"role": "user", "content": prompt}],
                    model=self.model_name, 
                    temperature=settings.FALLBACK_TEMPERATURE,
                    max_tokens=settings.MAX_TOKENS
                )
                return chat_completion.choices[0].message.content
            except Exception as e:
                if settings.DEBUG:
                    print(f"Error during LLM call: {e}")
                return ""  # Return empty string on failure
        
        # Extract basic information
        name = get_llm_response(f"Extract the full name from the following text. If no name is present, respond with 'N/A'. Only respond with the name: {pdf_text}").strip()
        title = get_llm_response(f"Extract the professional title from the following text. If no title is present, respond with 'N/A'. Only respond with the title: {pdf_text}").strip()
        email = get_llm_response(f"Extract the email address from the following text. If no email is present, respond with 'N/A'. Only respond with the email: {pdf_text}").strip()
        bio = get_llm_response(f"Create a short professional biography (around 50-100 words) based on the following text. Focus on skills and experience. If no bio is possible, respond with 'N/A'. Provide only the biography itself: {pdf_text}").strip()
        tagline = get_llm_response(f"Create a short and catchy tagline (around 5-10 words) that summarizes the person's professional identity from the following text. If no tagline is possible, respond with 'N/A'. Provide only the tagline: {pdf_text}").strip()
        
        # Extract social media
        linkedin = get_llm_response(f"Extract the LinkedIn profile URL from the following text. If no LinkedIn URL is present, respond with 'N/A'. Only respond with the LinkedIn URL: {pdf_text}").strip()
        github = get_llm_response(f"Extract the GitHub profile URL from the following text. If no GitHub URL is present, respond with 'N/A'. Only respond with the GitHub URL: {pdf_text}").strip()
        instagram = get_llm_response(f"Extract the Instagram profile URL from the following text. If no Instagram URL is present, respond with 'N/A'. Only respond with the Instagram URL: {pdf_text}").strip()
        
        # Extract projects and skills
        project_info = get_llm_response(f"Extract information about projects from the following text in this format Project Title: Project Description: Tech Stack:. If no projects are present, respond with 'N/A': {pdf_text}").strip()
        skills_info = get_llm_response(f"Extract a list of skills from the following text, separated by commas. If no skills are present, respond with 'N/A'. Only respond with the skills: {pdf_text}").strip()
        
        # Extract education
        education_info = get_llm_response(f"Extract education history from the following resume. For each education entry, provide the school name, degree type, field of study, start date, and end date. Format as 'School: Degree: Field: StartDate: EndDate' with each education on a new line. If no education is found, respond with 'N/A': {pdf_text}").strip()
        
        # Process the extracted information
        social_media = SocialMedia(
            linkedin=linkedin if linkedin != 'N/A' else None,
            github=github if github != 'N/A' else None,
            instagram=instagram if instagram != 'N/A' else None
        )
        
        # Process projects
        projects = []
        if project_info != "N/A":
            project_lines = project_info.split("\n")
            for line in project_lines:
                if ":" in line:
                    try:
                        project_title, project_description_techstack = line.split(":", 1)
                        project_description, tech_stack = project_description_techstack.split("Tech Stack:", 1)
                        
                        projects.append(Project(
                            title=project_title.strip(),
                            description=project_description.strip(),
                            techStack=tech_stack.strip()
                        ))
                    except ValueError as e:
                        if settings.DEBUG:
                            print(f"Error parsing project: {line}. Error: {e}")
        
        # Process skills
        skills = []
        if skills_info != "N/A":
            skill_list = [skill.strip() for skill in skills_info.split(",")]
            for skill_name in skill_list:
                if skill_name:
                    skills.append(Skill(name=skill_name))
        
        # Process education
        educations = []
        if education_info != "N/A":
            education_lines = education_info.split("\n")
            for line in education_lines:
                if ":" in line:
                    try:
                        parts = line.split(":")
                        if len(parts) >= 5:
                            educations.append(Education(
                                school=parts[0].strip(),
                                degree=parts[1].strip(),
                                fieldOfStudy=parts[2].strip(),
                                startDate=parts[3].strip(),
                                endDate=parts[4].strip()
                            ))
                    except Exception as e:
                        if settings.DEBUG:
                            print(f"Error parsing education: {line}. Error: {e}")
        
        # Create the profile object
        profile = Profile(
            name=name if name != 'N/A' else "N/A",
            title=title if title != 'N/A' else "N/A",
            email=email if email != 'N/A' else "N/A",
            bio=bio if bio != 'N/A' else "N/A",
            tagline=tagline if tagline != 'N/A' else None,
            social=social_media if (social_media.github or social_media.instagram or social_media.linkedin) else None,
            chatbot=None,
            profileImg=None,
            heroImg=None,
            projects=projects,
            skills=skills,
            educations=educations
        )
        
        return profile


class GrammarCorrector:
    """Class for correcting grammar in text using LLM"""
    
    def __init__(self):
        self.groq_api_key = settings.GROQ_API_KEY
        self.model_name = settings.MODEL_NAME
        self.temperature = settings.GRAMMAR_CORRECTION_TEMPERATURE
    
    def correct_grammar(self, text: str) -> str:
        """
        Corrects grammar in user input using Groq's LLM.
        
        Args:
            text: The text to correct
            
        Returns:
            The corrected text
        """
        if not text:
            return text
            
        client = groq.Groq(api_key=self.groq_api_key)
        
        try:
            chat_completion = client.chat.completions.create(
                messages=[
                    {
                        "role": "user",
                        "content": f"Correct any grammar, spelling, or punctuation errors in the following text, but keep the meaning exactly the same: '{text}'"
                    }
                ],
                model=self.model_name,
                temperature=self.temperature,
                max_tokens=settings.MAX_TOKENS
            )
            return chat_completion.choices[0].message.content
        except Exception as e:
            if settings.DEBUG:
                print(f"Error during grammar correction: {e}")
            return text  # Return original text if correction fails


# Create module-level instances for easier imports
profile_extractor = ProfileExtractor()
grammar_corrector = GrammarCorrector()

# Export functions for backward compatibility
def extract_profile_information(pdf_text: str) -> Profile:
    """Legacy function for backward compatibility"""
    return profile_extractor.extract_profile(pdf_text)

def correct_grammar(text: str) -> str:
    """Legacy function for backward compatibility"""
    return grammar_corrector.correct_grammar(text)