# Abstract Have you spent countless hours trying to tailor your resume for a specific job? Needless to say, it is one of the most tedious and boring tasks that you can ever do. Even if you have the right skills for the job, if your resume does not catch the eye of the Hiring Manager, it is rendered worthless. In the era of artificial intelligence, your resume will go through not only a human but also an applicant tracking system (ATS) that may not be able to parse your resume properly and may even reject you if it does not find the right set of keywords. Keeping all these things in mind, there was a need to develop a system that can generate resumes that are tailored to the job description, are easily understood by the ATS, and have a clean and professional outlook with minimal language errors. ResuMate is designed to produce such resumes within minutes and make job hunting easier for people in technology. ![landing1.png](landing1.png) # Introduction Most resumes get rejected by an automated Applicant Tracking well before they are seen by an Hiring Manager. These applicant tracking systems, may not be able to parse resumes that have a complex layout or contain too many unnecessary items other than text. Also, most HR deal with many resumes daily, and give at max 30 seconds of attention to any resume. Thus, it becomes inevitable to design a resume that not only looks professional but is also well understood by the Applicant Tracking Systems. ResuMate is an agentic workflow that uses LLMs to transform your existing resume to a professional-looking, minimalistic, and easily parseable PDF. The workflow can be accessed using the [Web App](https://resumate.namit.pp.ua/dashboard) interface. It has the following salient features: - Provides suggestions to improve your existing resume based on the parseability, language usage, job description. and actionable insights. - Generation of a clean single-column LaTeX-based PDF resume with all the suggestions incorporated. # Methodology This section explains the architecture of the application and workings of the agentic workflow. ## Workflow Architecture ![arc.svg](arc.svg) The figure above shows the architecture of the agentic workflow. It was created keeping three things in mind: - Accurate and reliable parsing of resumes with minimal errors - Minimizing the number of API calls to LLMs to reduce cost. - Transforming data into appropriate formats to ensure consistency and easier display on the frontend. ### User Input The user inputs the resume in pdf format along with an optional job description. The resume is first converted into jpg images (one image for each page) using [pdf2image](https://pypi.org/project/pdf2image/) and then converted to base64 strings that can be used to make API calls with the Multimodal Large Language Model (MLLM). Here we are using the Gemini Flash 2.0 model (see Experiments on why this model was selected) as the MLLM, which offers fast inference times and low hallucination rates. Below snippet shows the code for conversion: ```python from pdf2image import convert_from_path pdf_path = '/content/resume.pdf' images = convert_from_path(pdf_path) for i, image in enumerate(images): image.save(f'page_{i + 1}.jpg', 'JPEG') ``` --- ### Parsing PDF We use the [pdfminer.six](https://github.com/pdfminer/pdfminer.six) library to extract information such as the most commonly used font and its size. The font information can be used to alert the user if an unprofessional-looking font or a small font size is being used. Also, the [PyPDF2](https://pypi.org/project/PyPDF2/) library has been used to extract text from the PDF. This acts as a **fallback mechanism** in case the MLLM model fails to service the API call. Moreover, PyPDF extracts hyperlinks such as **Github** Account URL, **LinkedIn** Page URL, email address, and other important Links from the PDF. A sample snippet has been shown which extracts information using PyPDF: ```python def extract_text_num_pages_and_links(pdf_stream): reader = PdfReader(pdf_stream) text = "" links = [] num_pages = len(reader.pages) # Extract text from all pages for page in reader.pages: text += page.extract_text() or "" # extract links from annotations if '/Annots' in page: for annot in page['/Annots']: obj = annot.get_object() # Check if it's a link annotation if obj['/Subtype'] == '/Link': if '/A' in obj and '/URI' in obj['/A']: uri = obj['/A']['/URI'] links.append(uri) return { "resume_parsed_text": text, "resume_num_pages": num_pages, "resume_links": links, } ``` --- ### Prompt for Resume Section Parsing Resumes can be highly unstructured documents and may have completely different sections based on the candidate. Upon investigating many tech resumes, the most common sections present in tech resumes were found. For segregating the resume into the different sections the following prompt was used: ```markdown **Instruction:** Extract the following sections from the resume **if present** and output them **strictly in Markdown format**. Each section should have its own subheading (`##`). **Do not modify any text** from the resume—preserve all original formatting and wording. **Output only the extracted content in Markdown format, without any additional text.** ---------- **Resume Extraction Format:** ```markdown ## Candidate Name [Extracted Name] ## Location of Candidate [Extracted Location] ## Experience/Work History [Extracted Work History, including Freelance Experience] ## Education [Extracted Education Details] ## Position of Responsibilities [Extracted Responsibilities] ## Skills [Extracted Skills] ## Profile Summary / Objective [Extracted Profile Summary or Objective] ## Projects [Extracted Projects] ## Publications [Extracted Publications] ## Interests / Hobbies / Extracurricular Activities [Extracted Interests, Hobbies, or Extracurricular Activities] ## Awards / Achievements [Extracted Awards or Achievements] ## Certifications [Extracted Certifications] ## Languages Known [Extracted Languages] ## Relevant Coursework [Extracted Relevant Coursework] **Rules for Extraction:** - If a section is missing in the resume, **do not generate it** in the output. - **Do not add, modify, or infer** any information—strictly extract only what is present. - Maintain the **original text, order, and formatting** from the resume. - Ensure **only Markdown-formatted output** without any additional explanations or notes. ``` Having each section in Markdown format helps with easy display on the frontend side so that user can edit their resumes before improving them. --- ### Prompts for Markdown to JSON conversion ```markdown Take the given **Markdown-formatted resume** and extract its contents into a structured **JSON format** as shown below. **Ensure the response strictly follows JSON syntax**, and the output should be a valid Python dictionary. ### **Instructions:** - Extract information under the following sections: 1. **Education** 2. **Projects** 3. **Experience** (includes Work History and Freelance) 4. **Position of Responsibilities** - **If a section is missing**, include the key in the JSON but leave it as an **empty list (`[]`)**. - **Do not modify the original text**—preserve all content exactly as it appears in the resume. - **All dates must be formatted as "Abbreviated Month-Year" (e.g., "Jan-2023").** - **Strictly output only the JSON**—no additional text, explanations, or formatting. --- ### **Output Format:** { "Education": [ { "Degree": "", "Institution": "", "Location": "", "Period": { "Start": "", "End": "" } } ], "Experience": [ { "Role": "", "Company": "", "Location": "", "Period": { "Start": "", "End": "" }, "Description": "" } ], "Position of Responsibilities": [ { "Title": "", "Organization": "", "Location": "", "Period": { "Start": "", "End": "" }, "Description": "" } ], "Projects": [ { "Name": "", "Description": "", "Technologies": "", "Period": { "Start": "", "End": "" } } ] } - ### **Strict Rules:** **If a section is missing**, return an **empty list (`[]`)** instead of omitting it. **No explanations, additional text, or formatting**—**only valid JSON output**. **Preserve original text** exactly as found in the resume. **Ensure JSON is well-formed and can be parsed directly in Python.** --- ``` The above prompt converts a group of sections from Markdown to json. The sections are divided into multiple groups, and separate identical prompts are made for each group. This is done to avoid any conflicts between sections and make it easier for the LLM to generate accurate json responses. Although one could directly use the MLLM to generate JSON data but it would lead to a **higher number of API** calls to a much costlier MLLM. Each LLM response is then checked using [Pydantic AI](https://ai.pydantic.dev/) to ensure that only valid Json responses are received. Also, we use the Deepseek V3 model, which has a good balance of inference time and accuracy, performing well on general-purpose tasks with an [MMLU(General) score of 88.5%](https://www.vellum.ai/llm-leaderboard). --- ### Prompts for Enhancing Sections Now that we have structured sections in front of us, we can prepare specific prompts to enhance each section using certain guidelines. For example, take a look at the prompt which can be used to improve the 'Projects' section in a resume. ```markdown **Prompt:** You will receive **two inputs**: 1. A **Job Description (JD)** in text format. 2. A **JSON object** containing **projects** extracted from a resume in the following format: { "Projects": [ { "Name": "", "Description": "", "Technologies": "", "Period": { "Start": "", "End": "" } } ] } ### **Task:** - **Analyze the job description** and **align each project's description** according to it. - **Prioritize** projects that match the **technologies, skills, and keywords** found in the job description. The most relevant projects should appear **first** in the JSON. - **Modify the project descriptions** to subtly align them with the job description while keeping them **concise, clear, and well-structured**. - **Format the project descriptions in Markdown**, ensuring: - Use of **bullet points** for clarity. - **Bold formatting** (`**skill**`) for skills/technologies mentioned in both the **job description** and the **project**. - **Preserve all other data as is** (name, technologies, period, etc.), making no other modifications. --- ### **Output Format:** The output must be **strictly JSON**, preserving the original structure but with: 1. **Projects reordered** based on relevance to the job description. 2. **Descriptions formatted in Markdown** with relevant skills in **bold**. Example Output: { "Projects": [ { "Name": "AI Chatbot", "Description": "- Developed an AI-driven chatbot using **Python** and **TensorFlow**.\n- Integrated with **FastAPI** for real-time communication.\n- Implemented **NLP models** for enhanced user interactions.", "Technologies": "Python, TensorFlow, FastAPI, NLP", "Period": { "Start": "Jan-2023", "End": "Dec-2023" } }, { "Name": "E-commerce Website", "Description": "- Built a full-stack e-commerce platform with **React** and **Next.js**.\n- Implemented a **Node.js** backend with a **MongoDB** database.\n- Optimized performance and user experience with **server-side rendering (SSR)**.", "Technologies": "React, Next.js, Node.js, MongoDB, SSR", "Period": { "Start": "Mar-2022", "End": "Oct-2022" } } ] } --- ### **Strict Rules:** **Only output valid JSON**—no additional text, explanations, or formatting. **Preserve all original fields** (except reordering projects and modifying descriptions as instructed). **Descriptions must be formatted in Markdown**, using bullet points and **bolding** relevant skills. **No other modifications** beyond those explicitly stated. **Final instruction:** **Ensure the response is strictly JSON-compliant, ready to be parsed as a Python dictionary.** ``` Similarly, prompts are created for each section that is present in the resume. Also, the LLM responses are validated by Pydantic AI to ensure accuracy. ### Populating the LaTeX template With the enhanced resume sections ready, we populate the empty [LaTeX template](https://github.com/sb2nov/resume) with the extracted information and obtain a nice and minimalistic resume. ### Conversion to PDF After we have the LaTeX (.tex) file ready, we can compile it to PDF directly using [TinyTeX](https://yihui.org/tinytex/), which has a much smaller footprint ideal for resource-constrained servers. ```bash pdflatex document.tex ``` --- ## Query Optimization ```python async def get_llm_response(self, api_key, messages, temperature=1, top_p=1, max_retries=10, initial_backoff=1): """ Fetches a response from the API with retry logic to handle rate limits. Args: api_key (str): API key for authentication. messages (list): Messages to send to the model. temperature (float): Sampling temperature for the response. top p (float): top p value for the response. max_retries (int): Maximum number of retries in case of rate limit errors. initial_backoff (int): Initial backoff time in seconds. Returns: str: The content of the model response. """ attempt = 0 # Define the API URL url = "https://openrouter.ai/api/v1/chat/completions" # Define the headers for authentication headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json", } all_models = ["deepseek/deepseek-chat-v3-0324:free", "meta-llama/llama-3.1-70b-instruct:free","google/gemma-2-9b-it:free","meta-llama/llama-3.2-3b-instruct:free", "meta-llama/llama-3.1-405b-instruct:free", "mistralai/mistral-7b-instruct:free"] # Define the request payload payload = { "model": None, "messages": messages, "temperature": temperature, "top_p": 0.6, } async with aiohttp.ClientSession() as session: while attempt < max_retries: try: payload["model"] = all_models[attempt % len(all_models)] print(f"Attempt {attempt + 1} with API key: {api_key}") # proxy_list = await FreeProxy().get(count=1) async with session.post(url, headers=headers, data=json.dumps(payload), timeout=30, proxy=None) as response: if response.status == 200: data = await response.json() return data["choices"][0]["message"]["content"] else: print(f"Error: {response.status}, {await response.text()}") except aiohttp.ClientError as e: print(f"HTTP error: {e}") except Exception as e: print(f"Unexpected error: {e}") attempt += 1 wait_time = initial_backoff * (2 ** (attempt - 1)) # Exponential backoff print(f"Retrying in {wait_time} seconds (attempt {attempt}/{max_retries})...") await asyncio.sleep(wait_time) # Wait before retrying print(f"Max retries reached. Could not fetch response.") return None # Return None if all retries fail ``` The above snippet shows the mechanism for sending queries to LLM, it ensures that other fallback models are used in case of failure. Also, we use asynchronous programming to send multiple queries in an efficient way without blocking other queries. ## Tech Stack ### Backend - FastAPI ### Frontend - Next.js with React ### Other - Docker The web application was built using FastAPI for the backend and [Next.js with React](https://nextjs.org/) for the frontend. [FastAPI](https://fastapi.tiangolo.com/)is a modern, high-performance Python framework that leverages ASGI for faster execution, making it a popular choice for AI applications. Next.js was used for the frontend, providing a robust framework for building production-ready web applications. The whole prompt framework was designed from scratch without using any readily available agentic frameworks to ensure optimum performance and pinpoint customization. # Experiments This section describes the various experiments that were performed to finalize the various tools in the project. ## PDF Parsing Tools Accurately parsing resumes is a critical task in this project. PDF, while commonly used for resumes, presents significant challenges due to its complex layout and the fact that each character is positioned at a specific location in the document. Several tools are available for parsing PDFs in Python, which can be broadly categorized into non-AI-based and AI-based solutions. Non-AI-based tools, such as PyPDF2 and pdfminer.six, offer fast parsing capabilities but struggle with accuracy, especially when handling complex or unstructured layouts. On the other hand, AI-based solutions like MLLMs (Multimodal Large-Language Models) and marker-pdf, an open-source tool that converts PDFs into structured Markdown format, provide more accurate parsing but at the cost of speed. Below is a comparison of these tools based on speed, accuracy, and the availability of free APIs: | Tool | Speed | Accuracy | Free API Available | | ----------------- | --------- | --------- | ------------------ | | Non-AI-based Tools| High | Low | Not needed | | MLLM | Low | High | Yes | | marker-pdf | Moderate | Moderate | Yes (Limited) | While non-AI-based tools are fast, they fall short in terms of accuracy, which is crucial for parsing resumes accurately. Additionally, these tools do not directly output data in a structured format like Markdown. During experimentation, it was found that MLLM provided the best balance of high accuracy and usability, especially since it offers a free API with generous limits through [OpenRouter](https://openrouter.ai/). Therefore, MLLM was chosen for this project due to its superior overall performance compared to marker-pdf. ## Selection of MLLM The selection of MLLM was based mainly on two criteria: - Hallucination Rates - Inference Time Inference time of a Large Language Model (LLM) refers to the time it takes for the model to process input data (such as text, images, or both) and generate an output (e.g., a response, prediction, or transformation). Alongside inference time, the [hallucination rate](https://github.com/vectara/hallucination-leaderboard) —which measures how frequently an LLM generates inaccurate or non-factual information—is another critical metric, especially when tasks like document summarization are involved. Both of these metrics are essential: reducing hallucinations ensures the accuracy and reliability of generated content, while faster inference times improve API response times, contributing to a more efficient user experience. Considering both factors, the **Google Gemini Flash 2.0 model** was selected for its strong performance in minimizing hallucinations while delivering [fast inference times](https://www.vellum.ai/llm-leaderboard) as compared to other MLLMs, making it an ideal choice for this project. ## Optimizing Hyperparameters The two key hyperparameters considered were: - **Top P**: This parameter controls the cumulative probability distribution of the next token generated by the model. It restricts the token sampling to a subset of candidates that together make up the top P probability mass. A lower value (e.g., 0.4) makes the model more focused, while a higher value (e.g., 0.8) allows for more diverse token choices. - **Temperature**: Temperature controls the randomness of predictions. A lower temperature (e.g., 0.2) makes the model more deterministic and focused on high-probability tokens, while a higher temperature (e.g., 0.8) introduces more randomness and creativity in token selection. Both parameters were tested with values ranging from 0 to 1, in increments of 0.2. For the MLLM, a **top P value of 0.4** and **temperature of 0.2** were chosen to prioritize factual accuracy in responses. For the LLM, which required some degree of creativity to enhance the resume, the **temperature was set to 0.4** and **top P to 0.6** to allow for more diverse and creative outputs. # Future Work - Addition of different varieties of templates for users. - Safeguarding privacy by concealing sensitive information contained in resumes. ## Code and Resources - [Preview Website](https://resumate.namit.pp.ua/dashboard) - [Backend Code Repo](https://link.namit.pp.ua/rmate-b) [To be released soon] - [Frontend Code Repo](https://link.namit.pp.ua/rmate-f) [To be released soon] # References - [OpenRouter Docs](https://openrouter.ai/docs/quickstart) - [Hallucination Leaderboard](https://github.com/vectara/hallucination-leaderboard) - [Vellum LLM Leaderboard](https://www.vellum.ai/llm-leaderboard) - [DeepSeek V3 model info](https://openrouter.ai/deepseek/deepseek-chat:free) - [Gemini 2.0 Flash Model Info](https://openrouter.ai/chat?models=google/gemini-2.0-flash-exp:free)