DEV Community: Ahmed Abu Qahf

Streamlining the Hiring Process with OpenAI and LangChain Part 1

Ahmed Abu Qahf — Thu, 21 Mar 2024 21:07:35 +0000

The Spotlight Dilemma: Sorting Stars from Stardom
Navigating Recruitment Challenges: Unveiling Unseen Talent Gems
Unveiling the Bot: Your Backstage Buddy for Talent Hunting!
Process
- Step 1 - Audition Files
- Step 2 - Spotlight Highlights
- Step 3 - Storing Magic
- Step 4 - Chat Showtime

The Spotlight Dilemma: Sorting Stars from Stardom

Imagine you're the director of the most incredible talent show in town, searching for the brightest stars to light up the stage. Your job? To find the most dazzling performers who will leave the audience in awe. In the past, you'd have a stack of audition tapes to watch, which could be overwhelming. But now, with the rise of digital technology, you're flooded with videos from all around the world. It's like trying to find a needle in a haystack!

Navigating Recruitment Challenges: Unveiling Unseen Talent Gems

Here's the kicker: sometimes you might accidentally pick a performer just because they remind you of someone you know. That means you might miss out on some incredible acts that bring fresh and unique flavors to your show. And trust me, you don't want to miss out on the next superstar because they dance to a different beat.

Traditionally, you might have relied on word-of-mouth or the familiar faces you've seen before. But think about it, that might mean you're passing up on the chance to discover a hidden gem – a performer with a new style that the world has yet to see.

Ever had that moment when you're singing one song in your head, but your friend is humming a completely different tune? Well, imagine you've got a group of judges, each with their own musical taste. What one judge loves, another might not be crazy about. It's like trying to pick the best ice cream flavor, and everyone has their own favorite.

Now, picture this: the whole talent search process taking so long that amazing acts get snatched up by other shows. It's like watching a magician disappear in a puff of smoke before you even say "ta-da!" And if you're not crystal clear about how you're choosing your acts, they might feel like they're solving a puzzle without all the pieces.

But hey, what if you had a magical assistant who could watch all the auditions, spot the real gems, and help you tackle these challenges head-on? This incredible sidekick could make your job as a talent show director a breeze, and your stage would be graced with even more extraordinary performances!

That's where __LLMs__ – our modern-day magic helpers – come in for HR recruiters. They can help unearth the top talents, conquer these hurdles, and let recruiters focus on the most exciting parts of their gig. It's like having a team of assistants who always know the perfect act to steal the show.

Unveiling the Bot: Your Backstage Buddy for Talent Hunting!

Introducing the Talent Scouter Bot – your trusty assistant, powered by super-smart technology. It's like having a backstage helper who can chat about all those audition tapes, just like friends discussing their favorite acts.

You share the job description and what you're looking for in a superstar performer, and the Bot jumps into action. It chats with you like a friendly colleague, asking questions, and even provides a scorecard for each act's relevance to the role.

But here's where the magic happens. The Bot isn't just about numbers. It actually understands the resumes, just like you would read a story. It figures out who danced their way through college, who's a master at magic tricks, and who's a stand-up comedy sensation.

Now, let's dive into how this genius works:

This is the resume we're going to use throughout this guide: [Resume](https://upload.wikimedia.org/wikipedia/commons/c/cc/Resume.pdf)

Process

Step 1 - Audition Files

Imagine your Bot grabbing the audition tapes (resumes) and giving them a good watch (reading). It's like flipping through pages, but way faster. We're using special tools from __LangChain__, `PyMuPDFLoader`, to make this happen. `PyMuPDFLoader` will load the contents of every page in the resume and store them in a `Document` object. We can access the content of each page using the `page_content` attribute.

from langchain.document_loaders import PyMuPDFLoader

resume_path = "./resumes/john-doe.pdf"
loader = PyMuPDFLoader(file_path=resume_path)
resume_content = loader.load()
print(resume_content[0].page_content)

Step 2 - Spotlight Highlights

The Bot is a pro at finding the golden nuggets. It picks out the coolest parts of each act and creates a quick summary. Think of it like the highlights reel of a sports game – only for resumes. To make this happen, we’re going to use summarize chains and chat models modules from LangChain as well, specifically `load_summarize_chain` and `ChatOpenAI`. `load_summarize_chain` would take the resume's content and make a concise summary for it based on the prompt we pass to it, `SUMMARY_PROMPT`, here.

#!/usr/bin/python
# -*- coding: utf-8 -*-
from langchain.chains.summarize import load_summarize_chain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate

# Summarization Prompt

single_resume_tempate =
"""
You are an expert at extracting information from a resume.
Use the given resumes text to write a concise summary.
The summary must include the following sections:
1. Name
2. Contact Information
3. Professional Summary or Objective
4. Work Experience
5. Internships
6. Education
7. Skills
8. Achievements and Accomplishments
9. Relevant Projects
10. Certifications
11. Volunteer Work and Extracurricular Activities
12. Publications and Presentations
13. Personal Interests
14. Extra Useful Information such as years of experience,
working environment (On-site,remote or hybrid), will to
relocate for a job (yes or no), military status (exempted,
completed, required)...etc.
{text}
Your final answer must not exceed 1000 words. """
SUMMARY_PROMPT = PromptTemplate(template=single_resume_tempate,
                                input_variables=['text'])

# Chat Model
llm = ChatOpenAI(model_name='gpt-4', temperature=0)

# Summarize Chain
single_summary_chain = load_summarize_chain(
  llm=llm,
  chain_type='stuff',
  prompt=SUMMARY_PROMPT
)

# Print Summary
print single_summary_chain.run(resume_content)

Step 3 - Storing Magic

Just like you have a drawer for your favorite things, the Bot has a digital space to keep those resume summaries. This makes it easy to find and chat about each act later on. It's like organizing your superhero cards. In order to do this, we’re going to utilize embeddings and vector stores from LangChain, especially `OpenAIEmbeddings` and `Chroma`. `Chroma` is our vector store. It would use the `OpenAIEmbeddings` to embed the resume's content and store them for retrieval. Think of `Chroma` as a database that stores data about our resume.

from langchain.embeddings import OpenAIEmbeddings
from langchain.docstore.document import Document
from langchain.vectorstores import Chroma

resume_summary = single_summary_chain.run(data)
summary_documents = [Document(page_content=str(resume_summary),
                     metadata={'source': resume_path})]
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents=summary_documents,
                                    embedding=embeddings)

Step 4 - Chat Showtime

This is where the magic comes alive. The Bot turns into a lively conversation, ready to discuss the acts. You throw questions like confetti, and the Bot pulls out the perfect answers from its magic hat. In order to make this happen, we are going to use the chains module from LangChain, specifically `ConversationalRetrievalChain`. `ConversationalRetrievalChain` allows us to have a conversation with LLM about our resumes. The `ConversationBufferMemory` powers our `ConversationalRetrievalChain` with memory, like human memory, so we can ask questions using pronouns like he, she, they...etc. instead of using the names every single time.

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain

memory = ConversationBufferMemory(
  memory_key='chat_history',
  return_messages=True
)
chain = ConversationalRetrievalChain.from_llm(
  llm=llm,
  memory=memory,
  verbose=False, chain_type='stuff',
  retriever=vectorstore.as_retriever()
)

question = 'Who is the resume about?'
result = chain({'question': question})

print result['answer']

# The resume is about John Doe

With a wave of LangChain's wizardry, we've created a Bot that can chat about talents, just like you'd talk about your favorite show. 🎤🎭 And guess what? You don't need to be a tech wizard to use it – it's all designed to make your talent-hunting adventure easy and fun.

So, next time you're searching for the brightest star in your talent galaxy, let the Talent Scouter Bot be your guide. It's like having a chatty sidekick who's always ready to help you find the next big sensation! 🎉🎵🤖

See part 2 to know more about Langchain, LLMs and more.

How Does The Internet Work? Part 3: Traceroute

Ahmed Abu Qahf — Mon, 09 Sep 2019 17:40:01 +0000

Ever noticed how fast a single web page loads? How is it possible for a web page whose web-servers might be miles and miles away from your machine loads almost instantaneously? It makes you think: are our machines directly connected to our favorite website's servers? The answer is no, they are not.

When you are on the internet, requests sent from your machine don't reach the destination computer in a single jump or a hop. However, it follows a unique route through strategically and physically interconnected computer networks around the world called The Internet Backbone in order to help you receive and transmit requests and information.

If you navigate to Submarine Cable Map, you'll be able to view the locations of these networks, and how they are interconnected.

Another way to look at it is the Opte Project's visual representation of the internet. One of its visualizations is the following image which portrays a portion of the internet in 2005 in which each line is connected between nodes that represent two different IP addresses. How awesome is that 😮.

Sometimes you may wanna know what that route is, and that's where traceroute steps in.

Traceroute is a procedure that enables you to precisely figure out how data transmission travels from one machine to another. Basically, it compiles a list of the computers on the network that are involved with an internet activity and identifies each computer or a server on that list and the time data took to get from one machine to another. If any interruption happens in the transfer of data, the traceroute shows you where the problem occurred along the chain.

In order to perform a traceroute, open up your terminal and write down the following command:

* traceroute HOSTNAME           if you're a Mac or Linux user.
* tracert HOSTNAME              if you're a Windows user.

For example, Let's try and traceroute Google.com

We got that google's IP address is 172.217.17.174, so were we to enter that IP address in the browser's address bar and hit go, we should redirected to Google.com web page.

Traceroute is always a practical way if you're finding difficulty accessing a particular website. It helps in finding out where the problem is occurring in the network.

The icon used in the cover image is licensed under icons8 Free License.

How Does The Internet Work? Part 2: Breaking a Website

Ahmed Abu Qahf — Fri, 06 Sep 2019 18:56:30 +0000

This part's title might be a little bit deceiving; as you might think of it as hacking the website, and shutting it down. Sorry to disappoint you, but this is not what the title amplifies. The first part of this series finished at the website's web server replies back to your browser with the necessary HTML, CSS & JS files so that the browser can render the website. What the title indicates is to break down the website to its components (HMTL, CSS & JS), and have some fun playing with them. In order to do so, we need to open a browser (firefox...E.g.), navigate to google.com or any other website and turn on the developer's tools.

First things first. I'll start by giving a simple explanation to each component.

HTML

* stands for hyper text markup language.
* responsible for the structure of a web page.
* consists of elements represented in it by tags.

CSS

* stands for cascading style sheet.
* from the name, it describes the style of a HTML page and 
  how HTML elements should be displayed.

JavaScript

* the programming language of HTML and the web.
* used in writing the elements' handlers to interact with the backend.

Let's get to the fun part.

In order to turn on the developer's tools, you need to click on the settings menu icon which usually looks like three vertical lines or dots, then choose Web Developer (Firefox), and check the toggle tools tab, you should be getting a result like this.

From the image, you can see that Google's home page HTML is located on the left of the image and right next to it is the CSS. Now we're going to play with the HTML code, and try to do the following:

Change Google Search Button To Your Name Search
Delete I am Feeling Lucky Button
Delete the whole html code

Let's start with the first one:

In order to do so, we need to activate pick an element from the page button, located next to the inspector tab to the left, by either clicking on it or by clicking Ctrl+Shift+C from the keyboard. Then, we pick the element we want to edit so we're going to pick Google Search for this one. The tools immediately highlights the html code for this button to you. What we're going to do is to change the value attribute to Your Name instead of Google, press ENTER, and voila you have your own search button 😃 .

The second one:

we'll follow the same steps as in one, but instead of changing the attribute value, we're going to delete the following line:

<input class="RNmpXc" value="I'm Feeling Lucky" 
aria-label="I'm Feeling Lucky" name="btnI" type="submit" jsaction="sf.lck" 
data-ved="0ahUKEwi1opyl4bzkAhUI0uAKHd4BBqAQ19QECAo">

As the image shows, we successfully deleted the button. Can we do the same to the whole page, though?

The third one:

we'll do the same steps in two, but this time, we're going to delete the whole body tag code and see what happens.

As we can see from the image, the page is totally white; no google logo image, no buttons, no tabs, nothing at all. This is mainly because the code inside the body tag is the structure of the page. So, does this means you deleted google forever, and you might go to jail for this?! 😟. Absolutely not! What you just did is only deleting the copy of HTML code your browser got from Google's web servers for the request you sent earlier. If you enter google.com again in the browser's address bar and hit go, the process we talked about in part 1 happens again, and you get another copy of the HTML code from Google's web servers so that your browser renders it and the full page shows up again like nothing happened.

Here's what I did after I played a bit, I changed it to totally Somaa's Search Engine 😂

Cover Image Icon License: icons8 Free License.

How Does The Internet Work? Part 1: Browsing a Website

Ahmed Abu Qahf — Fri, 09 Aug 2019 23:49:08 +0000

Who doesn't use the internet at least once during the day? Almost everyone, right? You start by opening up your browser (Firefox, chrome, safari...etc.), write down your favourite website's URL (DEV, Google...etc.) in the browser's address bar, you hit go and BOOM the website shows up, but have you ever considered how does this happen? what happens behind the scenes so once you gave the browser the website address, it shows up?

Understanding how the Internet works is very important. Lots of people usually skims through the surface of the concepts behind the working mechanism of the internet without fully understanding how everything works together. Without these foundations, it becomes very difficult to think about performance, optimizing sites and so on. Therefore, I decided to share with you what I know about that, and I decided to post it as a series so that the post won't take you too much time reading it.

Part 1: Browsing a Website

(A) Finding out The Domain's IP Address

When you enter a website URL (Google.com ...E.g.) in your browser URL bar and hit the go button, the browser first needs to know the IP address of this domain you want to visit in order to navigate to it. Therefore, the browser checks its cache which keeps DNS records for (2-30 minutes). If it is not there, the browser sends a request to your internet router asking it "Who is this Google.com fellow?" Your router does the same by checking its own cache for DNS records. If it is not there either, it sends the same request to your ISP asking the same question "Do you know this google.com?" Your ISP sends the same request one more time to its DNS cache. The DNS replies back to the ISP: "I don't know who google.com is but I have its address, here it is 127.217.7.23". The ISP returns the IP Address back to the router which in turn sends it back to your browser.

(B) Navigating to the Website

Once the browser receives the IP Address, it sends a HTTP request to that address asking for establishing a connection between the browser and the website's web servers. The Web servers handle the request, and reply back to the browser by sending the website's HTML, CSS and JavaScript which the browser renders so that you can view the website's page as it should be.