Add files

.gitignore

@@ -0,0 +1,45 @@
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

DB.py

@@ -0,0 +1,49 @@
+import os
+from dotenv import load_dotenv
+import psycopg2
+import mysql.connector as sql
+
+load_dotenv()
+
+class DB:
+    def __init__(self):
+        self.string = os.getenv("Connection_String")
+        self.collection = os.getenv("Collection_Name")
+        self.host = os.getenv("Host")
+        self.port = os.getenv("Port")
+        self.user = os.getenv("User")
+        self.password = os.getenv("Password")
+        self.db = os.getenv("DB_Name")
+    
+    def connect_PS(self):
+        self.connection_PS = psycopg2.connect(self.string)
+        self.cursor_PS = self.connection_PS.cursor()
+    
+    def connect_MS(self):
+        self.connection_MS = sql.connect(
+            host = self.host,
+            port = self.port,
+            user = self.user,
+            password = self.password,
+            database = self.db
+        )
+        self.cursor_MS = self.connection_MS.cursor()
+
+    def insert(self, data):
+        insert_query = f"INSERT INTO users(name,email,date,time,password,score) VALUES %s"
+        self.cursor_MS.execute(insert_query, (data,))
+
+
+    def clear(self):
+        self.cursor_PS.execute(f"DELETE FROM {self.collection}")
+        self.connection_PS.commit()
+    
+    def close_PS(self):
+        self.cursor_PS.close()
+        self.connection_PS.close()
+    
+    def close_MS(self):
+        self.cursor_MS.close()
+        self.connection_MS.close()
+
+

DockerFile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+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 ["gunicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

Embedder.py

@@ -0,0 +1,31 @@
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from dotenv import load_dotenv
+from langchain_postgres import PGVector
+from langchain_core.documents import Document
+import os
+import json
+
+load_dotenv()
+class Embed:
+    def __init__(self):
+        API = os.getenv("API_KEY")
+        self.embeddings = GoogleGenerativeAIEmbeddings(google_api_key = API,
+            model="models/text-embedding-004")
+        
+    def create_db(self,String,Name):
+        self.db = PGVector(self.embeddings,connection = String,collection_name = Name,use_jsonb = True)
+
+    def create_document(self,n,resume):
+        json_res = json.loads(resume)
+        return Document(
+            page_content = f"{resume}",
+            metadata = {"id": n, "name": json_res["name"] , "email": json_res["email"]}
+        )
+    def add_docs(self,documents):
+        self.db.add_documents(documents=documents)
+    
+    def match(self,skills,select):
+        result = self.db.similarity_search(skills,k = select)
+        return result
+
+

Evaluator.py

@@ -0,0 +1,40 @@
+from Models import Model
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+class InterviewEvaluator(Model):
+    def __init__(self,model,tech=None,non_tech=None):
+        PROMPT = os.getenv("Eval_prompt")
+        super().__init__(PROMPT,model)
+        self.tech_questions = [
+            "What is a stack data structure?",
+            "What is a queue data structure?",
+            "What is object-oriented programming?",
+            "What is an API?",
+            "What is a database index?"
+        ]
+        self.non_tech_questions = [
+            "Can you introduce yourself?",
+            "What are your strengths?",
+            "How do you handle stress or pressure?",
+            "Why do you want to work with our organization?",
+            "Describe a challenge you faced and how you overcame it."
+        ]
+
+    def ask(self,id):
+        if id:
+            return self.tech_questions
+        else:
+            return self.non_tech_questions
+        
+    def edit(self,questions,id):
+        if id:
+            self.tech_questions = questions
+        else:
+            self.non_tech_questions = questions
+
+    
+    def score_candid(self,candidate_output):
+        return self.send(candidate_output)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Karthik Reddy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Models.py

@@ -0,0 +1,38 @@
+import os
+from dotenv import load_dotenv
+from google import genai
+import json
+
+load_dotenv()
+class Model:
+    def __init__(self,PROMPT,model_inp):
+        API_KEY = os.getenv("GOOGLE_API_KEY")
+        self.client = genai.Client(api_key=API_KEY)
+        self.chat = self.client.chats.create(model = model_inp)
+        response = self.chat.send_message(PROMPT)
+
+    def json(self,text):
+        if not text.strip():
+            return ""
+        
+        s_idx = text.find("{")
+        e_idx = text.rfind("}") + 1
+        
+        if s_idx == -1 or e_idx == -1 :
+            return ""
+        
+        try:
+            output = json.loads(text[s_idx:e_idx])
+        except Exception as e:
+            raise  ValueError(f"Error Parsing {e}")
+
+        return output if output else ""
+
+
+    def send(self,content):
+        response = self.chat.send_message(content)
+        result = self.json(response.text)
+        return result
+    
+
+

Parser.py

@@ -0,0 +1,18 @@
+from langchain_community.document_loaders import PyPDFLoader
+
+class Parser():
+    def __init__(self):
+        pass
+    def parse(self,file_path):
+        loader = PyPDFLoader(file_path)
+        pages = loader.load_and_split()
+        no_of_pages = pages[0].metadata["total_pages"]
+        content = []
+        for i in range(no_of_pages):
+            content.append(pages[i].page_content)
+
+        return {
+            "content": content,
+            "no_of_pages": no_of_pages
+        }
+

README copy.md

@@ -0,0 +1,2 @@
+# AxionAI
+AI platform that automates resume screening, interview scheduling, and candidate analysis - boosting efficiency while keeping humans in control of key decisions.

Scheduler.py

@@ -0,0 +1,85 @@
+import pandas as pd
+import smtplib
+import ssl
+import os
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from dotenv import load_dotenv
+from datetime import datetime, timedelta
+
+load_dotenv()
+
+
+class Schedule:
+    def __init__(self):
+        self.server = "smtp.gmail.com"
+        self.port = 587
+        self.sender = "axionai101@gmail.com"
+        self.password = os.getenv("app_password")
+
+    def defaults(self,start_date,start_time,slot_length):
+        self.date = start_date
+        self.time = start_time
+        self.slot_length = slot_length
+    
+    def schedule_slots(self, file_path):
+        self.df = pd.read_csv(file_path)
+
+        # Combine date and time into datetime object
+        start_datetime = datetime.strptime(
+            f"{self.date} {self.time}", "%Y-%m-%d %H:%M"
+        )
+
+        slots = []
+
+        for i in range(len(self.df)):
+            slot_start = start_datetime + timedelta(minutes=i * self.slot_length)
+            slot_end = slot_start + timedelta(minutes=self.slot_length)
+
+            slot_str = f"{slot_start.strftime('%Y-%m-%d %H:%M')} - {slot_end.strftime('%H:%M')}"
+            slots.append(slot_str)
+
+        self.df["Slot"] = slots
+
+
+    def send_emails(self):
+        names = self.df["Name"]
+        emails = self.df["Email"]
+        slots = self.df["Slot"]
+        for name,email,slot in zip(names,emails,slots):
+            message = MIMEMultipart("alternative")
+            message["Subject"] = "Interview Invitation – First Round Cleared"
+            message["From"] = self.sender
+            message["To"] = email
+            html = f"""
+    <html>
+        <body>
+            <p>
+                    Dear {name},<br><br>
+                    We are pleased to inform you that you have successfully cleared the first round of the interview process.<br><br>
+
+                    You are hereby invited to attend the next round of interviews, scheduled as per the details below:<br><br>
+
+                    <strong>Date:</strong> {self.date}<br>
+                    <strong>Time:</strong> {slot}<br>
+
+                    Please ensure that you are available and join the interview on time. Further instructions, if any, will be shared with you prior to the interview.<br><br>
+
+                    We wish you the very best and look forward to speaking with you.<br><br>
+
+                    Best regards,<br>
+                    <strong>Hiring Team</strong>
+                </p>
+
+              </body>
+            </html>
+            """
+            part = MIMEText(html, "html")
+            message.attach(part)
+            context = ssl.create_default_context()
+            with smtplib.SMTP(self.server, self.port) as server:
+                server.starttls(context=context)
+                server.login(self.sender, self.password)
+                server.sendmail(self.sender, email, message.as_string())
+
+

app.py

@@ -0,0 +1,193 @@
+from flask import Flask , request , jsonify
+from flask_cors import CORS
+import logging
+from Models import Model
+from Parser import Parser
+from DB import DB
+from Embedder import Embed
+from Scheduler import Schedule
+from Evaluator import InterviewEvaluator
+from dotenv import load_dotenv
+import json
+import os
+
+
+load_dotenv()
+app = Flask(__name__)
+CORS(app)
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+model_4b = os.getenv("4b")
+model_27b = os.getenv("27b")
+db = DB()
+
+embedder = Embed()
+embedder.create_db(db.string,db.collection)
+logging.info("Embedder Loaded Successfully")
+
+evaluator = InterviewEvaluator(model_4b)
+logging.info("Evaluator Loaded Successfully")
+
+PROMPT = os.getenv("Prompt")
+JD_Prompt = os.getenv("JD_Prompt")
+Summary = os.getenv("Summary_Prompt")
+parser = Parser()
+
+
+@app.route("/",methods = ["GET","POST"])
+def default_route():
+    return jsonify({
+        "output" : "Backend Running Successfully"
+    })
+
+@app.route("/parse",methods = ["POST"])
+def parse():
+    db.connect_PS()
+    logging.info("Database Connected Successfully")
+
+    
+    structure_model = Model(PROMPT,model_27b)
+    logging.info("Model Loaded Successfully")
+    
+    logging.info("Parsing Resumes")
+    
+
+    files = os.listdir("./resume")
+    contents = []
+    documents = []
+    for file_path in files:
+        if file_path.endswith(".pdf"):
+            path = r"./resume/" + file_path 
+            print(path)
+            result = parser.parse(path)
+            content = result["content"][0]
+            contents.append(content)
+    
+    if contents:
+        logging.info("Resumes Parsed Successfully")
+        for i in range(len(contents)):
+            structured = structure_model.send(contents[i])
+            doc = embedder.create_document(i, json.dumps(structured))
+            documents.append(doc)
+        
+        embedder.add_docs(documents)
+        logging.info("Resumes Embeddings Added Successfully")
+    else:
+        logging.error('No Resumes Found/Parsed')
+    
+    db.close_PS()
+    return jsonify({
+        "output" : "Resumes Parsed and Embedded Successfully"
+    })
+
+@app.route("/match", methods = ["POST"])
+def match():
+    db.connect_PS()
+    data = request.get_json()
+    JD = data.get("job_description")
+    k = data.get("candidates")
+    out = Model(JD_Prompt, model_4b).send(JD)
+    summarizer = Model(Summary,model_4b)
+
+    result = embedder.match(json.dumps(out),k)
+    output = []
+    for i in result:
+        content = {}
+        content["Name"] = i.metadata["name"]
+        content["Email"] = i.metadata["email"]
+        content["content"] = summarizer.send(json.dumps(i.page_content))
+        output.append(content)
+    db.close_PS()
+    return jsonify(output)
+
+@app.route("/interview", methods = ["GET"])
+def interview():
+    # 0 for non_tech and 1 for tech questions
+    data = request.get_json()
+    q_id = data.get("id")
+    questions = evaluator.ask(q_id)
+    return jsonify(questions)
+
+@app.route("/interview",methods=["POST"])
+def edit():
+    data = request.get_json()
+    # 0 for non_tech and 1 for tech questions
+    q_id = data.get("id")
+    questions = data.get("questions")
+    evaluator.edit(questions,q_id)
+    return jsonify({"output" : "Questions Edited Successfully"})
+
+@app.route("/evaluate",methods = ["POST"])
+def score():
+    db.connect_MS()
+    data = request.get_json()
+    candid = data.get("user_output")
+    email = data.get("email")
+    password = data.get("password")
+    result = evaluator.score_candid(candid)
+    score = result["score"]
+    query = f"Update score = {score} from users where Email = {email} and password = {password}"
+    db.cursor_MS.execute(query)
+    db.connection_MS.commit()
+    db.close_MS()
+    return jsonify(result)
+
+
+def create_user():
+    db.connect_MS()
+    df = scheduler.df
+    for name,email,date,time in zip(df["Name"],df["Email"],scheduler.date,df["Slot"]):
+        password = name[:5] + email[:5]
+        db.insert([name,email,date,time,password,0.0])
+    
+    db.connection_MS.commit()
+    db.close_MS()
+
+
+@app.route("/schedule", methods = ["POST"])
+def email():
+    data = request.get_json()
+    date = data.get("date")
+    time = data.get("time")
+    slot_length = data.get("length")
+
+    scheduler = Schedule()
+    scheduler.defaults(date,time,slot_length)
+    scheduler.schedule_slots("./test.csv")
+    create_user()
+    scheduler.send_emails()
+    return jsonify({"output" : "Emails Sent Successfully"})
+
+@app.route("/login-user",methods=["GET"])
+def login_u():
+    db.connect_MS()
+    data = request.get_json()
+    email = data.get("email")
+    password = data.get("pass")
+    query = f"SELECT * FROM users WHERE email = {email} AND password = {password}"
+
+    result = db.cursor_MS.execute(query).fetchone()
+    db.close_MS()
+    if result:
+        return jsonify({"user": "True"})
+    else:
+        return jsonify({"user": "False"})
+
+@app.route("/login-org",methods=["GET"])
+def login_o():
+    db.connect_MS()
+    data = request.get_json()
+    email = data.get("email")
+    password = data.get("pass")
+    query = f"SELECT * FROM org WHERE email = {email} AND password = {password}"
+
+    result = db.cursor_MS.execute(query).fetchone()
+    db.close_MS()
+    if result:
+        return jsonify({"user": "True"})
+    else:
+        return jsonify({"user": "False"})
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

requirements.txt

@@ -0,0 +1,18 @@
+flask
+flask-cors
+python-dotenv
+numpy
+langchain
+langchain-google-genai
+langchain-community
+langchain
+pypdf
+langchain-postgres
+psycopg2
+langchain-core 
+langchain-cohere 
+sqlalchemy
+google
+pandas
+mysql-connector-python
+gunicorn