{"id":1662,"date":"2025-02-05T07:03:00","date_gmt":"2025-02-05T07:03:00","guid":{"rendered":"https:\/\/mailitics.com\/index.php\/2025\/02\/05\/from-resume-to-cover-letter-using-ai-and-llm-with-python-and-streamlit\/"},"modified":"2025-02-05T07:03:00","modified_gmt":"2025-02-05T07:03:00","slug":"from-resume-to-cover-letter-using-ai-and-llm-with-python-and-streamlit","status":"publish","type":"post","link":"https:\/\/mailitics.com\/index.php\/2025\/02\/05\/from-resume-to-cover-letter-using-ai-and-llm-with-python-and-streamlit\/","title":{"rendered":"From Resume to Cover Letter Using AI and LLM, with Python and Streamlit"},"content":{"rendered":"

From Resume to Cover Letter Using AI and LLM, with Python and Streamlit
\n \t

\n
<\/BR>
\n
\n \t

\n
<\/BR><\/p>\n

\n
\n

DISCLAIMER<\/strong>: The idea of doing Cover Letter or even Resume with AI does not obviously start with me. A lot of people have done this before<\/strong> (very successfully) and have built websites and even companies from the idea. This is just a tutorial<\/strong> on how to build your own Cover Letter AI Generator App using Python and a few lines of code. All the code you will say in this blog post can be found in my public Github folder<\/a>. Enjoy.\u00a0\"\ud83d\ude42\"\u00a0<\/p>\n<\/blockquote>\n

Pep Guardiola is a (very successful) Manchester City football<\/strong> coach. During Barcelona\u2019s Leo Messi years, he invented a way of playing football known as \u201cTiki-Taka<\/em><\/strong>\u201d. This means that as soon as you receive the ball, you pass the ball, immediately, without even controlling it. You can pass the ball 30\u201340 times before scoring a goal.<\/p>\n

More than a decade later, we can see how the way of playing football made Guardiola and his Barcelona famous is gone. If you look at a Manchester City match, they take the ball and immediately look for the striker or the winger. You only need a few, vertical passes, immediately looking for the opportunity. It is more predictable, but you do it so many times that you will eventually find the space to hit the target.<\/p>\n

I think that the job market<\/strong> has somehow gone in the same direction.\u00a0<\/p>\n

Before you had the opportunity to go to the company, hand in your resume, talk to them, be around them, schedule an interview, and actively talk to people. You would spend weeks preparing for that trip, polishing your resume, and reviewing questions and answers.\u00a0<\/p>\n

For many, this old-fashioned strategy still works, and I<\/strong> believe it<\/strong>. If you have a good networking opportunity, or the right time and place, the handing the resume thing works very well. We love the human connection, and it is very effective to actually know<\/strong> someone.\u00a0<\/p>\n

It is important to consider that there is a whole other approach as well. Companies like LinkedIn<\/strong>, Indeed, <\/strong>and even in general the internet<\/strong> completely changed the game. You can send so many resumes to so many companies and find a job out of statistics. AI is changing this game<\/strong> a little bit further. There are a lot of AI tools to tailor your resume for the specific company, make your resume more impressive, or build the job specific cover letter<\/strong>. There are indeed many companies<\/strong> that sell this kind of services to people that are looking for jobs.<\/p>\n

Now, believe me, I have got nothing<\/strong> against these companies, at all, but the AI that they are using it\u2019s not really \u201ctheir AI<\/em><\/strong>\u201d. What I mean by that is that if you use ChatGPT<\/a>, Gemini, or the super new DeepSeek to do the exact task you will very likely not<\/strong> get a worse response than the (paid) tool that you are using on their website. You are really paying for the \u201ccommodity<\/strong>\u201d of having a backend API that does what we would have to do through ChatGPT. And that\u2019s fair.\u00a0<\/p>\n

Nonetheless, I want to show you that it is indeed very simple and cheap<\/strong> to make your own \u201cresume assistant\u201d using Large Language Models<\/strong>. In particular, I want to focus on cover letters<\/strong>. You give me your resume and the job description, and I give you your cover letter you can copy and paste to LinkedIn, Indeed, or your email<\/strong>.<\/p>\n

In one image, it will look like this:<\/p>\n

\"\"
Image made by the author, credits on the\u00a0image<\/figcaption><\/figure>\n

Now, Large Language Models (LLMs) are specific AI models that produce text. More specifically, they are HUGE<\/strong> Machine Learning models (even the small ones are very big).\u00a0<\/p>\n

This means that building your own LLM or training one from scratch is very, very<\/strong> expensive. We won\u2019t do anything like that. We will use a perfectly working LLM and we will smartly instruct it to perform our task. More specifically, we will do that in Python<\/strong> and using some APIs. Formally, it is a paid API. Nonetheless, since I started the whole project (with all the trial and error process) I spent less than 30 cents<\/em><\/strong>. You will likely spend 4 <\/strong>or 5 cents on it. \u00a0<\/strong><\/p>\n

Additionally, we will make a working web app<\/strong> that will allow you to have your cover letter in a few clicks. It will be an effort of a couple hundred lines of code (with spaces \"\ud83d\ude42\").<\/p>\n

To motivate you, here are screenshots of the final app:<\/p>\n

\"\"<\/figure>\n
\"\"<\/figure>\n
\"\"<\/figure>\n
\"\"
Images made by the\u00a0author<\/figcaption><\/figure>\n

Pretty cool right? It took me less than 5 hours to build the whole thing from scratch. Believe me: it\u2019s that simple<\/em><\/strong>. In this blog post, we will describe, in order:<\/p>\n

    \n
  1. The LLM API Strategy.<\/strong> This part will help the reader understand what LLM Agents we are using and how we are connecting them.<\/li>\n
  2. The LLM Object<\/strong>. This is the implementation of the LLM API strategy above using Python<\/strong>.\u00a0<\/li>\n
  3. The Web App and results<\/strong>. <\/strong>The LLM Object is then transferred into a web app using Streamlit<\/strong>. I\u2019ll show you how to access it and some results.\u00a0<\/li>\n<\/ol>\n

    I\u2019ll try to be as specific as possible so that you have everything <\/strong>you need to make it yourself, but if this stuff gets too technical, feel free to skip to part 3 and just enjoy the sunset \"\ud83d\ude43\".<\/p>\n

    Let\u2019s get started!<\/p>\n

    1. LLM API\u00a0Strategy<\/h3>\n

    This is the Machine Learning System Design part of this project, which I kept extremely <\/strong>light, because I wanted to maximize the readability of the whole approach (and because it honestly didn\u2019t need to be more complicated than that).<\/p>\n

    We will use two APIs:<\/p>\n

      \n
    1. \nA Document Parser LLM API <\/strong>will read the Resume<\/a> and extract all the meaningful information.<\/strong> This information will be put in a\u00a0.json file so that, in production, we will have the resume already processed and stored somewhere in our memory.<\/li>\n
    2. \nA cover letter LLM API. <\/strong>This API will read the parsed resume (the output of the previous API) and the job description <\/strong>and it will output the Cover Letter.<\/li>\n<\/ol>\n
      \"\"
      Image made by the author, credits on the\u00a0image<\/figcaption><\/figure>\n

      Two main points:<\/p>\n

        \n
      1. \nWhat is the best LLM for this task? <\/strong>For text extraction and summarization, LLama<\/strong><\/a> or Gemma<\/strong><\/a> are known to be a reasonably cheap and efficient LLM. As we are going to use LLama for the summarization task, in order to keep consistency, we can adopt it for the other API as well. If you want to use another model, feel free to do so.<\/li>\n
      2. \nHow do we connect the APIs<\/strong>? There are a variety of ways you can do that. I decided to give it a try to Llama API<\/strong><\/a>. The documentation is not exactly extensive, but it works well and it allows you to play with many models. You will need to log in, buy some credit ($1 is more than sufficient for this task), and save your API key. Feel free to switch to another solution (like Hugging Face<\/a> or Langchain<\/a>) if you feel like it.<\/li>\n<\/ol>\n

        Ok, now that we know what <\/strong>to do, we just need to actually implement it in Python.\u00a0<\/p>\n

        2. LLM\u00a0Object<\/h3>\n

        The first thing that we need is the actual LLM<\/strong> prompts. In the API, the prompts are usually passed using a dictionary. As they can be pretty long, and their structure is always similar, it makes sense to store them in\u00a0.json files<\/strong>. We will read the JSON files and use them as inputs for the API call.\u00a0<\/p>\n

        2.1 LLM\u00a0Prompts<\/h4>\n

        In this\u00a0.json file, you will have the model (<\/strong>you can call whatever model you like) and the content<\/strong> which is the instruction for the LLM. Of course, the content key has a static part, which is the \u201cinstruction\u201d and a \u201cdynamic\u201d part, which is the specific input of the API call. For example: this is the\u00a0.json file for the first API, I called it resume_parser_api.json<\/em><\/strong>:<\/p>\n