pushing api

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -0,0 +1,10 @@
+langchain-groq
+fastapi
+uvicorn
+python-dotenv
+pandas
+tqdm
+requests
+bs4
+lxml
+chardet

routers/query/query.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from langchain_groq import ChatGroq
+from utils.LLMResponse import GenerateLLMResponse
+from utils.ScrapeClass import ScrapeJobDetails
+from dotenv import load_dotenv
+import os
+
+router = APIRouter(prefix='/query')
+load_dotenv()
+
+class RequestType(BaseModel):
+    resume: str
+    cover_letter: str
+    task: str
+    urls: list
+
+global llm, instructions
+
+@router.on_event('startup')
+def _initialize():
+    api = os.getenv('groq_api_key')
+
+    global llm
+    
+    llm = ChatGroq(groq_api_key=api,
+                   model="llama-3.3-70b-versatile", temperature=0.3)
+
+    global instructions
+
+    instructions = '''
+                        0. **Adopt a conversational yet professional tone**: Write naturally as if you're explaining your interest and value to a hiring manager, avoiding overly formal or robotic language.
+
+                        1. **Start with a specific reference to the company**: Mention a project, product, or initiative that directly aligns with your skills or experience. Research the company's AI-related work and integrate it naturally into the response. Avoid generic statements like "I'm excited about your innovation."
+
+                        2. **Showcase your unique abilities and proven expertise**: Highlight your strongest abilities, previous experience, and measurable achievements that make you uniquely qualified for this role. Draw examples directly from your past work, such as specific tools (e.g., LLMs, RAG architectures) or accomplishments (e.g., "improved response accuracy by 25%").
+
+                        3. **Demonstrate clear value to the company**: Link your achievements and skills to the company’s goals or challenges. Instead of saying "I can make an impact," explain exactly how your expertise will solve their problems, improve processes, or drive innovation.
+
+                        4. **Provide measurable results with context**: Use one strong example with metrics to back up your claims (e.g., "I implemented a this at that that improved performance by this percent "). Avoid inventing metrics or offering vague claims.
+
+                        5. **Make every sentence count**: Remove repetition or filler. Each sentence should serve a clear purpose—whether it's showing value, demonstrating expertise, or connecting to the company's mission.
+
+                        6. **End with a confident, specific conclusion**: Reinforce how your unique skills will help the company succeed. Replace weak statements like "I’m excited to help" with clear, tailored contributions (e.g., "I’m eager to optimize your AI pipeline and drive measurable performance gains for your team").
+
+                        7. **Keep it concise and focused**: Limit the response to **100-150 words** while retaining clarity, specificity, and impact. Be enthusiastic but to the point.
+
+                        8. Replace metrics & results that are not mentioned in my resume & cover letter. Don't invent results. Only use values that are in resume & cover letter
+    '''
+
+@router.post("/")
+def _query(data: RequestType):
+
+    list_ = data.urls
+
+    object_ = ScrapeJobDetails(list_)
+    response_dict = object_._run()
+    
+    lr = GenerateLLMResponse(llm)
+
+    resultList = {}
+
+    for url in list_:
+
+        context = lr._extract_relevant_details(
+            resume=data.resume, job_desc=response_dict[url]
+        )
+
+        custom_prompt = lr._buildPrompt(
+            context = context, cover_letter=data.cover_letter, jobData=response_dict[url], task=data.task)
+
+        final_response = lr._runInferenceLoop(
+            instruction=instructions, prompt=custom_prompt)
+
+        resultList[url] = final_response
+
+    return resultList

server.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI, routing, Response
+from fastapi.middleware.cors import CORSMiddleware 
+from routers.query.query import router as query_router
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["*"],
+)
+
+
+app.include_router(query_router)
+
+@app.get('/')
+def _default_router():
+    return Response('Server is running!')
+

utils/LLMResponse.py

@@ -0,0 +1,150 @@
+from tqdm import tqdm
+
+class GenerateLLMResponse:
+    def __init__(self,  llm):
+
+       self.llm = llm
+
+    def _extract_relevant_details(self, resume: str, job_desc: str)->str:
+
+        prompt = f'''
+            You are an experienced & harsh employer thats extracts specific important aspects from the resume that is relevant to the job Details
+            You will be given text that contains multiple sentences. Only output the sentences that can be relevant to the job Details.
+
+            Use the following rules to judge if a particular sentence is important/ relevant to the job Details or not.
+
+            1. Extract the sentence contains specific skills mentioned in the job Details.
+            2. Extract sentences that reference specific tools, technologies, frameworks, or platforms that are mentioned in the job Details.
+            3. Extract sentences that highlight measurable results and are highly relevant.
+            4. Extract sentences that demonstrate experience with tasks or responsibilities similar to those listed in the job Details.
+            5. Extract sentences that demonstrate problem-solving ability or direct impact on previous projects or companies.
+            6. Extract sentences that demonstrate previous roles or positions that are similar to the job you are hiring for should be marked as relevant.
+            
+            -Input Format-
+
+            Job Description: ""
+            Resume: ""
+
+            -Output Format-
+
+            "Relevant Sentence"
+            "Relevant Sentence"
+
+            -Instructions-
+
+            1. Maintain the original meaning of the text, using proper grammar and vocabulary suitable for a general audience.
+            2. Avoid changing the tone or intent of the original sentence.
+            3. Preserve all escape sequences such as \\n (newlines) and \\t (tabs) in their exact positions in the text.
+            4. Don't generate any sentence on your own. Only filter the relevant sentences from the resume
+            5. Don't give results like "This skill is demonstrated in this..."
+            6. Also do mention skills from the resume section
+
+            Dont give me any code and dont mention 'json' at the top of the response. There should not be any extra output (even a single word) besides the output required.
+
+            ######################
+            -Examples-
+            ######################
+
+            Job Details: 
+            
+            We are looking for a Senior AI Engineer with expertise in fine-tuning large language models (LLMs) and working with retrieval-augmented generation (RAG) architectures. 
+            In this role, you will help enhance our existing AI systems by fine-tuning LLMs for specific use cases, integrating RAG architectures to improve model performance, and developing high-impact AI solutions.
+            Key Responsibilities:
+            Fine-tune large language models (LLMs) to improve performance on domain-specific tasks.
+            Design and implement RAG architectures to enhance retrieval-based AI systems.
+            Collaborate with cross-functional teams to identify AI-driven solutions for business challenges.
+            Optimize LLMs for both accuracy and efficiency, ensuring high-quality model output.
+            Conduct thorough testing and validation of fine-tuned models to ensure robustness and scalability.
+            Provide leadership and mentorship in AI model development and deployment processes.
+            Required Skills:
+            Proven experience in fine-tuning large language models (GPT, BERT, T5, etc.) for domain-specific tasks.
+            Deep understanding of retrieval-augmented generation (RAG) architectures and integration with LLMs.
+            Strong programming skills in Python, TensorFlow, PyTorch, and relevant AI libraries.
+            Experience in designing and deploying AI solutions at scale.
+            Knowledge of natural language processing (NLP) techniques and best practices.
+            Strong communication and collaboration skills.
+
+            Resume: 
+
+        
+            ################
+            Output:
+
+            "Led a project to fine-tune a large GPT-3 model for customer support, improving response accuracy by 20% compared to the previous version."
+            "Designed and implemented a retrieval-augmented generation (RAG) architecture to integrate external knowledge sources, enhancing the relevance and diversity of generated text."
+            "Optimized BERT for document classification tasks, increasing accuracy by 15% while reducing inference time by 25%."
+            "Collaborated with cross-functional teams to build and deploy an LLM-powered chatbot, improving customer satisfaction by 30% through personalized interactions."
+            "Implemented end-to-end pipelines for training and fine-tuning LLMs, including data preprocessing, model selection, and hyperparameter tuning."
+            "Integrated RAG techniques into a content generation system, reducing reliance on pre-trained models and improving the context relevance of generated responses."
+            "Developed scalable LLM fine-tuning strategies using TensorFlow and PyTorch, ensuring model performance on a range of NLP tasks."
+            "Evaluated model performance through rigorous testing and validation, ensuring robustness and alignment with business needs in a production environment."
+
+            #############################
+
+            -Real Data-
+            ######################
+            Job Details: {job_desc}
+            Resume: {resume}
+            ######################
+            Output:
+
+        '''
+
+        result = self._invoke(prompt)
+
+        return result
+
+    def _invoke(self, prompt: str)->str:
+
+        response = self.llm.invoke(prompt)
+
+        return response.content
+        
+    def _buildPrompt(self, context: str, cover_letter: str, jobData: str, task: str)->str:
+
+        template = f'''
+
+        Instruction: 
+
+        Think from the perspective of an employer. Your response must sound extremely natural and should not contain buzzwords.
+        Be direct & sound enthusiastic about the role. Don't give very general response. 
+        Give answers that display my expertise for that particular topic
+
+        Only return the answer to the question and nothing else. In no circumstance will yoo return anything like "I made the following changes:..."
+
+
+        Details relevant to the job details:
+
+        {context}
+
+
+        My cover letter which contains my tech background:
+
+        {cover_letter}
+
+        Job data which includes about the job & requirements: 
+
+        {jobData}
+
+        {task}
+
+        Only give me the final answer & don't give tell what changes did you make.
+
+        '''
+
+        return template
+
+    def _runInferenceLoop(self, instruction: str, prompt: str):
+
+        
+        prompt = f'''
+        
+                Prompt: {prompt}
+
+                Instruction: {instruction}
+        '''
+            
+        result = self._invoke(prompt)
+
+        return result
+

utils/ScrapeClass.py

@@ -0,0 +1,42 @@
+from bs4 import BeautifulSoup
+import requests
+
+class ScrapeJobDetails:
+    def __init__(self, urls: list):
+
+        self.url_list = urls
+
+    def _fetchUrlData(self, url: str):
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
+            'Accept-Language': 'en-US,en;q=0.9',
+        }
+
+        return requests.get(url, headers=headers).text
+
+    def _parseHtml(self, html_content):
+
+        soup = BeautifulSoup(html_content, 'lxml')
+
+        tags_to_extract = ['p', 'li', 'ul']
+
+        extracted_text = []
+        for tag in tags_to_extract:
+            for element in soup.find_all(tag):
+                extracted_text.append(element.get_text(strip=True))  
+
+        return "\n".join(extracted_text)
+
+
+    def _run(self):
+
+        result_dict = {}
+
+        for url in self.url_list:
+
+            html_data = self._fetchUrlData(url)
+
+            result_dict[url] = self._parseHtml(html_data)
+
+        return result_dict