Askmyresume version 1.0.0

.env.example

@@ -0,0 +1,8 @@
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+SENDGRID_API_KEY=
+PUSHOVER_USER_KEY=
+PUSHOVER_API_TOKEN=
+SENDGRID_FROM_EMAIL=
+SENDGRID_TO_EMAIL=
+HF_TOKEN=

.gitattributes

@@ -1,5 +1,6 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text
@@ -8,6 +9,8 @@
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +36,27 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+faiss.index filter=lfs diff=lfs merge=lfs -text
+resume.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,141 @@
+# ===============================
+# Python
+# ===============================
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Virtual environments
+.env
+.venv
+venv/
+env/
+myenv/
+ENV/
+
+# ===============================
+# Environment & Secrets
+# ===============================
+.env.local
+.env.*.local
+.env.production
+.env.development
+.env.test
+*.key
+*.pem
+
+# API keys / credentials
+secrets/
+credentials/
+config/secrets.yaml
+config/secrets.json
+
+# ===============================
+# Jupyter / Data Science
+# ===============================
+.ipynb_checkpoints/
+*.ipynb
+
+# ===============================
+# ML / AI Artifacts
+# ===============================
+models/
+checkpoints/
+weights/
+*.pt
+*.pth
+*.onnx
+*.joblib
+*.pkl
+
+# Vector stores / RAG indexes
+faiss_index/
+chroma/
+vectorstore/
+embeddings/
+
+# ===============================
+# Logs & Runtime Files
+# ===============================
+logs/
+*.log
+*.out
+*.err
+
+# ===============================
+# Gradio / FastAPI
+# ===============================
+gradio_cached_examples/
+.gradio/
+tmp/
+uploads/
+
+# ===============================
+# Cache / Temp
+# ===============================
+.cache/
+.mypy_cache/
+.pytest_cache/
+ruff_cache/
+coverage/
+htmlcov/
+
+# ===============================
+# OS / Editor
+# ===============================
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# ===============================
+# Docker
+# ===============================
+docker-data/
+*.tar
+
+# ===============================
+# Deployment
+# ===============================
+*.local
+*.tfstate
+*.tfstate.backup
+.envrc
+
+# ===============================
+# Reports / Generated Content
+# ===============================
+reports/
+outputs/
+generated_images/
+charts/
+visualizations/
+
+# ===============================
+# Misc
+# ===============================
+*.bak
+*.tmp
+
+#==================================
+# FAISS / embeddings
+data/*.index
+data/*.bin
+data/chunks_metadata.json
+
+# Resume files
+data/*.pdf
+documents/*.pdf
+
+# Assets
+data/*.png
+data/*.jpg
+data/*.jpeg

README.md

@@ -10,4 +10,64 @@ pinned: false
 short_description: Interactive Resume Chatbot
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AskMyResume 🤖📄  
+**Resume-Aware LLM Chatbot with RAG + Human Escalation + Recruiter Contact Bridge**
+
+AskMyResume is a recruiter-friendly chatbot powered by **OpenAI Agents SDK** and a **FAISS RAG pipeline**.  
+It answers questions about my resume, portfolio, GitHub projects, and LinkedIn summary.
+
+If the chatbot is unsure or detects a high-intent recruiter question (salary, relocation, interview request, etc.), it escalates by sending you a **push notification (Pushover)** and an **email (SendGrid)**.
+
+---
+
+## 🚀 Features
+
+### ✅ Resume Q&A (RAG-powered)
+- Loads resume PDF + portfolio + GitHub READMEs + LinkedIn summary
+- Splits text using **RecursiveCharacterTextSplitter**
+- Stores embeddings in **FAISS (cosine similarity)**
+- Retrieves top-k relevant chunks and generates grounded answers
+
+### ✅ Recruiter-Friendly Responses
+- Concise, professional tone
+- Provides sources from retrieved chunks
+- Avoids hallucinations
+
+### ✅ Human Escalation (High Intent Detection)
+Triggers escalation when:
+- confidence score is low
+- question contains keywords (salary, visa, relocation, interview, etc.)
+- recruiter requests contact information
+
+Escalation actions:
+- 📲 Push notification via **Pushover**
+- 📧 Email notification via **SendGrid**
+
+### ✅ Recruiter Contact Bridge
+Recruiters can:
+- leave their name, email, company, LinkedIn
+- send a message directly to you
+
+### ✅ Gradio UI (v6.5)
+- Streaming chatbot UI
+- Contact form
+- Resume download button
+- Session IDs
+- Escalation log panel
+- Custom bot avatar (your picture)
+
+---
+
+## 🧱 Tech Stack
+
+- **Python 3.10+**
+- **OpenAI Agents SDK**
+- **FAISS** (cosine similarity retrieval)
+- **PyPDF / pypdf**
+- **Gradio 6.5**
+- **SendGrid API**
+- **Pushover API**
+
+---
+
+

app.py

@@ -0,0 +1,12 @@
+from utils.central_logging import setup_logging
+from download import download_assets
+from ui.gradio_app import launch_ui
+
+
+
+
+setup_logging()
+download_assets()
+
+if __name__ == "__main__":
+    launch_ui()

download.py

@@ -0,0 +1,42 @@
+
+from ntpath import isdir
+from utils.central_logging import get_logger
+from huggingface_hub import snapshot_download
+from huggingface_hub import login
+from dotenv import load_dotenv
+import os
+
+logger = get_logger("download")
+
+load_dotenv(override=True)
+
+hf_token = os.getenv("HF_TOKEN")
+path = "data"
+
+
+if hf_token:
+    logger.info("Hugging face token has been set")
+else:
+    logger.info("Error no hugging face token found")
+
+try:
+    login(hf_token)
+    logger.info("Logging to Hugging face has been successful")
+except Exception as e:
+    logger.exception(f"An error occurred when loging to Hugging face: {e}")
+
+
+def download_assets():
+    if not os.path.isdir(path):
+        os.makedirs(path, exist_ok=True)
+        repo_id = "Cedric07/data"
+        local_download_path = snapshot_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            local_dir = path,
+            local_dir_use_symlinks=False,
+        )
+        logger.info(f"Downloaded to: {local_download_path}")
+
+
+download_assets()

ingestion/ingest_all.py

@@ -0,0 +1,33 @@
+import json
+from ingestion.pdf_loader import extract_text_from_pdf
+from ingestion.text_loader import load_text,load_markdown_folder
+from utils.central_logging import setup_logging,get_logger
+
+
+setup_logging()
+logger = get_logger("loader")
+
+def ingest_data(resume_pdf_path:str,linked_path:str,github_folder_path:str) -> list[dict]:
+
+    dataset = []
+
+    pdf_pages =  extract_text_from_pdf(resume_pdf_path,"resume.pdf")
+    dataset.append(pdf_pages)
+    linked_resume = extract_text_from_pdf(linked_path,"linked_page.pdf")
+    dataset.append(linked_resume)
+
+    github_docs = load_markdown_folder(github_folder_path,"github_readmes")
+    dataset.append(github_docs)
+
+    return dataset
+
+
+if __name__ == "__main__":
+    
+     dataset = ingest_data("./data/resume.pdf","./data/profile.pdf","./data")
+
+     with open("./data/dataset.json","w",encoding="utf-8") as file:
+        json.dump(dataset,file,indent=2,ensure_ascii=False)
+
+     logger.info(f"Ingestion completed. Total document loaded: {len(dataset)}")
+     logger.info("Saved to: data/dataset.json")    

ingestion/pdf_loader.py

@@ -0,0 +1,28 @@
+from  pypdf import PdfReader
+
+
+def extract_text_from_pdf(pdf_path:str,source:str) -> list[dict]:
+
+    reader = PdfReader(pdf_path)
+    pages_data = []
+
+    for i,page in enumerate(reader.pages):
+        text = page.extract_text() or ""
+        pages_data.append(
+            {
+                "page": i+1,
+                "text": text.strip(),
+                "source": source
+            }
+        )
+
+    return pages_data
+
+
+
+
+def pdf_to_text(pdf_path:str,source:str) -> str:
+
+    pages = extract_text_from_pdf(pdf_path,source)
+    full_text = "\n\n".join([f"---Page {p["page"]}--- {p["source"]} \n --- \n {p["text"]}" for p in pages])
+    return full_text

ingestion/text_loader.py

@@ -0,0 +1,28 @@
+import os
+import glob
+from unittest import result
+
+def load_text(file_path:str) -> str:
+    text = ""
+    if not os.path.exists(file_path):
+        return ""
+    
+    with open(file_path,"r",encoding="utf-8") as file:
+        text = file.read().strip()
+    
+    return text
+
+
+def load_markdown_folder(folder_path:str,source:str) -> list[dict]:
+    results = []
+    md_files = glob.glob(os.path.join(folder_path,"*.md"))
+    
+    for md_file in md_files:
+        text = load_text(md_file)
+        results.append({
+            "source":source,
+            "file":os.path.basename(md_file),
+            "text":text
+        })
+    
+    return results

local_agents/escalation_agent.py

@@ -0,0 +1,48 @@
+from notifications.pushover_client import PushoverClient
+from notifications.sendgrid_client import SendGridClient
+
+ESCALATION_KEYWORDS = [
+    "salary", "compensation", "pay", "rate",
+    "visa", "sponsorship", "relocation", "relocate",
+    "interview", "availability", "schedule",
+    "start date", "notice period",
+    "contract", "freelance",
+    "phone", "email", "contact", "meeting", "call"
+]
+
+class EscalationAgent:
+    def __init__(self, confidence_threshold: float = 0.65):
+        self.confidence_threshold = confidence_threshold
+        self.pushover = PushoverClient()
+        self.sendgrid = SendGridClient()
+
+    def should_escalate(self, question: str, confidence: float) -> bool:
+        q = question.lower()
+
+        if confidence < self.confidence_threshold:
+            return True
+
+        for kw in ESCALATION_KEYWORDS:
+            if kw in q:
+                return True
+
+        return False
+
+    def notify(self, question: str, answer: str, confidence: float):
+        title = "Resume Bot Escalation"
+
+        push_message = (
+            f"Recruiter Question:\n{question}\n\n"
+            f"Confidence: {confidence:.2f}\n\n"
+            f"Draft Answer:\n{answer[:800]}"
+        )
+
+        email_subject = "Resume Bot Escalation Alert"
+        email_content = (
+            f"Recruiter Question:\n{question}\n\n"
+            f"Confidence: {confidence:.2f}\n\n"
+            f"Draft Answer:\n{answer}\n"
+        )
+
+        self.pushover.send(title=title, message=push_message, priority=1)
+        self.sendgrid.send_email(subject=email_subject, content=email_content)

local_agents/prompt.py

@@ -0,0 +1,47 @@
+def get_system_prompt():
+    return """
+You are a recruiter-facing Resume Chatbot for Cheun Da.
+
+You MUST follow these rules:
+
+1. Always call retrieve_resume_context(query) before answering.
+2. Answer ONLY from the retrieved chunks.
+3. If the answer is not clearly supported by the context:
+   - do NOT guess
+   - do NOT hallucinate
+   - instead say:
+     "I don’t have that information on the resume. I can notify Cheun Da directly."
+   - then draft a short helpful response and call notify_candidate()
+
+4. If the question involves any sensitive topic, ALWAYS escalate:
+   - salary / compensation
+   - relocation / visa / sponsorship
+   - interview scheduling / availability
+   - start date / notice period
+   - direct contact request
+   - contract rates / freelance terms
+
+5. When escalating:
+   - generate a recruiter-friendly draft response
+   - call notify_candidate(question, draft_answer, confidence)
+
+6. Tone:
+   - concise
+   - professional
+   - recruiter-friendly
+   - bullet points preferred
+   - no long essays
+
+7. When possible, include:
+   - relevant project names
+   - relevant technologies
+   - links if they exist in the context
+
+8. If recruiter wants to stay in touch:
+   - ask for their name, email, Message, company, and optional LinkedIn
+   - then call save_recruiter_contact()
+
+OUTPUT FORMAT:
+- Provide a clear answer
+- Optionally include: "Relevant Sources:" with 1–3 short citations (resume, GitHub, LinkedIn)
+"""

local_agents/resume_agent.py

@@ -0,0 +1,99 @@
+from typing import List, Dict, Any, Optional
+from agents import Agent, Runner, trace, function_tool
+from rag.retriever import ResumeRetriever
+from local_agents.escalation_agent import EscalationAgent
+from local_agents.prompt import get_system_prompt
+import os
+
+retriever = ResumeRetriever()
+escalation_agent = EscalationAgent(confidence_threshold=0.65)
+
+
+@function_tool
+def retrieve_resume_context(query:str,top_k:int) ->  Dict[str, Any]:
+
+    chunks = retriever.retrieve(query=query,top_k=top_k)
+
+    if not chunks:
+        return {
+            "confidence":0.0,
+            "chunks": []
+        }
+    
+    top_score = chunks[0]["score"]
+
+    return {
+        "confident": float(top_score),
+        "chunks": chunks
+    }
+
+
+@function_tool
+def notify_candidate(question: str, draft_answer: str, confidence: float) -> str:
+    escalation_agent.notify(question,draft_answer,confidence)
+    return "Candidate have been notify via push + email"
+
+@function_tool
+def save_recruiter_contact(name:str,email:str,message:str,linkedin:Optional[str]=None,company:Optional[str]=None) -> str:
+    
+    summary = (
+        f"📩 New recruiter contact request\n\n"
+        f"Name: {name}\n"
+        f"Email: {email}\n"
+        f"Company: {company or 'N/A'}\n"
+        f"LinkedIn: {linkedin or 'N/A'}\n\n"
+        f"Message:\n{message}\n"
+    )
+
+    title = "Recruiter contact request"
+    escalation_agent.pushover.send(title=title,message=summary,priority=1)
+    escalation_agent.sendgrid.send_email(subject=title,content=summary)
+
+    return "Recruiter contact info received. Cheun Da has been notified."
+
+
+def _save_recruiter_contact(name:str,email:str,message:str,linkedin:Optional[str]=None,company:Optional[str]=None) -> str:
+    
+    summary = (
+        f"📩 New recruiter contact request\n\n"
+        f"Name: {name}\n"
+        f"Email: {email}\n"
+        f"Company: {company or 'N/A'}\n"
+        f"LinkedIn: {linkedin or 'N/A'}\n\n"
+        f"Message:\n{message}\n"
+    )
+
+    title = "Recruiter contact request"
+    escalation_agent.pushover.send(title=title,message=summary,priority=1)
+    escalation_agent.sendgrid.send_email(subject=title,content=summary)
+
+    return "Recruiter contact info received. Cheun Da has been notified."
+
+resume_agent = Agent(
+    name="Resume Aware LLM Chatbot",
+     model="gpt-4o-mini",
+     instructions = get_system_prompt(),
+     tools=[retrieve_resume_context,notify_candidate,save_recruiter_contact]
+)
+
+async def answer_resume_question(question:str):
+    with trace("resume-agent-stream"):
+        result = Runner.run_streamed(resume_agent,input=question)
+    
+        async for event in result.stream_events():
+
+            if event.type != "raw_response_event":
+                continue
+
+            data = event.data
+            event_type = getattr(data, "type", None)
+
+            if event_type == "response.output_text.delta":
+                yield data.delta
+            
+            #print(f"type: {event.type}")
+            #print(f"event: {event}")
+            #if event.type == "final_output_delta":
+            #    yield event.delta
+    
+    

notifications/pushover_client.py

@@ -0,0 +1,56 @@
+from dotenv import load_dotenv
+from utils.central_logging import get_logger
+import os
+import requests
+
+
+logger =  get_logger("pushover")
+load_dotenv(override=True)
+
+
+pushover_api_token = os.getenv("PUSHOVER_API_TOKEN")
+pushover_user_key = os.getenv("PUSHOVER_USER_KEY")
+
+if pushover_api_token:
+    logger.info("Pushover api token has been set")
+else:
+    message = "Error pushover api token has been set"
+    logger.error(message)
+    raise ValueError(message)
+
+if pushover_user_key:
+    logger.info("Pushover user key has been set")
+else:
+    message = "Error pushover user key has been set"
+    logger.error(message)
+    raise ValueError(message)
+
+
+class PushoverClient:
+
+    def __init__(self):
+
+        self.api_token = pushover_api_token
+        self.user_key = pushover_user_key
+    
+
+    def send(self,title:str,message:str,priority:int=1) -> dict:
+        url = "https://api.pushover.net/1/messages.json"
+
+        payload = {
+            "token": self.api_token,
+            "user": self.user_key,
+            "title": title,
+            "message": message,
+            "priority": priority
+        }
+
+        response = requests.post(url,data=payload)
+
+        if response.status_code != 200:
+            message = f"Pushover error: {response.status_code} - {response.text}"
+            logger.exception(message)
+            raise Exception(message)
+        
+        return response.json()
+        

notifications/sendgrid_client.py

@@ -0,0 +1,61 @@
+from utils.central_logging  import get_logger
+from dotenv import load_dotenv
+from sendgrid import SendGridAPIClient
+from sendgrid.helpers.mail import Mail
+import os 
+
+logger = get_logger("sendgrid")
+
+load_dotenv(override=True)
+
+sendgrid_api_key = os.getenv("SENDGRID_API_KEY")
+sendgrid_from_email = os.getenv("SENDGRID_FROM_EMAIL")
+sendgrid_to_email = os.getenv("SENDGRID_TO_EMAIL")
+
+if sendgrid_api_key:
+    logger.info("Sendgrid api key has been set")
+else:
+    message = "Missing sendgrid api key"
+    logger.error(message)
+    raise ValueError(message)
+
+if sendgrid_from_email:
+    logger.info("Sendgrid from email has been set")
+else:
+    message = "Missing sendgrid from email"
+    logger.error(message)
+    raise ValueError(message)
+
+if sendgrid_to_email:
+    logger.info("Sendgrid to email has been set")
+else:
+    message = "Missing sendgrid to email"
+    logger.error(message)
+    raise ValueError(message)
+
+class SendGridClient:
+
+    def __init__(self) :
+        self.sendgrid_api_key = sendgrid_api_key
+        self.from_email = sendgrid_from_email
+        self.to_email = sendgrid_to_email
+        self.client = SendGridAPIClient(self.sendgrid_api_key)
+    
+    def send_email(self,subject:str,content:str) -> int:
+        message = Mail(
+            from_email=self.from_email,
+            to_emails=self.to_email,
+            subject=subject,
+            plain_text_content=content
+        )
+
+        response = self.client.send(message)
+
+        print(f"status code: {response.status_code}")
+        
+        if response.status_code not in (200,202):
+            message = f"SendGrid failed: {response.status_code} {response.body}"
+            logger.exception(message)
+            raise Exception(message)
+        
+        return response.status_code

rag/build_index.py

@@ -0,0 +1,52 @@
+import os
+import json
+from rag.embedder import OpenaiEmbedder
+from rag.vector_store import FaissVectorStore
+from rag.chunker import chunk_document
+from utils.central_logging import setup_logging,get_logger
+
+
+
+setup_logging()
+logger  = get_logger("index_building")
+
+DATASET_PATH = "./data/dataset.json"
+FAISS_INDEX_PATH = "./data/faiss.index"
+CHUNKS_METADATA_PATH = "./data/chunks_metadata.json"
+
+
+def build_index(chunk_size:int=800,chunk_overlap=150):
+
+    if not os.path.exists(DATASET_PATH):
+        message = f"Missing dataset file: {DATASET_PATH}"
+        logger.error(message)
+        raise FileNotFoundError(message)
+    
+    with open(DATASET_PATH,"r",encoding="utf-8") as file:
+        dataset = json.load(file)
+    
+    chunks = chunk_document(dataset,chunk_size=chunk_size,chunk_overlap=chunk_overlap)
+
+    if not chunks:
+        message = "No chunks were created. Check dataset content."
+        logger.error(message)
+        raise ValueError(message)
+    
+    texts = [chunk["text"] for chunk in chunks]
+
+    embedder = OpenaiEmbedder(model="text-embedding-3-small")
+    embedding = embedder.embed_multiple_texts(texts)
+
+
+    dim = len(embedding[0])
+
+    store = FaissVectorStore(dim)
+    store.add_embedding(embedding,chunks)
+
+    store.save_data(FAISS_INDEX_PATH,CHUNKS_METADATA_PATH)
+
+    logger.info("Saving FAISS index + chunk metadata...")
+
+
+if __name__ == "__main__":
+    build_index(chunk_size=800,chunk_overlap=150)

rag/chunker.py

@@ -0,0 +1,55 @@
+import hashlib
+from typing import List, Dict
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+
+
+def generate_chink_id(text: str, prefix: str = "chunk") -> str:
+
+    h = hashlib.md5(text.encode("utf-8")).hexdigest()[:12]
+    return f"{prefix}_{h}"
+
+
+def chunk_document( dataset: List[Dict],chunk_size: int = 800,chunk_overlap: int = 150) -> List[Dict]:
+
+    all_chunks = []
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        separators=["\n\n", "\n", ". ", " ", ""]
+    )
+
+    for docs in dataset:
+        for doc in docs:
+            raw_text = doc.get("text","")
+
+            if not raw_text or  not raw_text.strip():
+                continue
+
+            chunks = splitter.split_text(raw_text)
+
+            for i,chunk in enumerate(chunks):
+                chunk = chunk.strip()
+                if not chunk:
+                    continue
+
+                prefix = f"{doc.get('source','unknown')}"
+
+                if doc.get("page") is not None:
+                    prefix += f"_page{doc['page']}"
+                
+                if doc.get("file") is not None:
+                    prefix += f"_{doc['file']}"
+                
+                chunk_id = generate_chink_id(raw_text,prefix)
+                
+                all_chunks.append({
+                    "chunk_id":chunk_id,
+                    "text":raw_text,
+                    "source":doc.get("source"),
+                    "page":doc.get("page"),
+                    "file":doc.get("file")
+                })
+
+    return all_chunks
+

rag/embedder.py

@@ -0,0 +1,52 @@
+from utils.central_logging import get_logger
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+logger = get_logger("embedding")
+
+load_dotenv(override=True)
+
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+if openai_api_key:
+    logger.info("Openai api key has been set")
+else:
+    logger.error("Openai api key has not been found")
+
+
+
+class OpenaiEmbedder:
+
+    def __init__(self, model: str = "text-embedding-3-small") :
+        self.client =  OpenAI(api_key=openai_api_key)
+        self.model = model
+
+    def embed_text(self,text:str) -> list[float]:
+
+        if not text:
+            message = "Can not be an empty text"
+            logger.error(message)
+            raise ValueError(message)
+
+        response = self.client.embeddings.create(
+            model=self.model,
+            input=text        
+            )
+        
+        return response.data[0].embedding
+    
+
+    def embed_multiple_texts(self,texts:list[str]) -> list[list[float]]:
+
+        if not texts:
+            message = "Can not be an empty list of texts"
+            logger.error(message)
+            raise ValueError(message)
+        
+        response = self.client.embeddings.create(
+            model= self.model,
+            input= texts
+        )
+
+        return [item.embedding for item in response.data]

rag/main.py

@@ -0,0 +1,40 @@
+from rag.embedder import OpenaiEmbedder
+from rag.vector_store import FaissVectorStore
+from rag.retriever import ResumeRetriever
+
+
+FAISS_INDEX_PATH = "data/faiss.index"
+CHUNKS_METADATA_PATH = "data/chunks_metadata.json"
+
+
+def main():
+  
+    dim = 1536
+
+    store = FaissVectorStore(dim=dim)
+    store.load(FAISS_INDEX_PATH, CHUNKS_METADATA_PATH)
+
+    print(f"Index loaded. Total vectors: {store.index.ntotal}")
+
+    embedder = OpenaiEmbedder(model="text-embedding-3-small")
+    retriever = ResumeRetriever(embedder, store)
+
+    query = input("\nAsk a resume question: ")
+
+    results = retriever.retrieve(query, top_k=5)
+
+    print("\n🔎 Top Results:\n")
+    for i, r in enumerate(results, start=1):
+        print(f"#{i}")
+        print(f"Score: {r['score']:.4f}")
+        print(f"Source: {r['source']}")
+        print(f"Page: {r.get('page')}")
+        print(f"File: {r.get('file')}")
+        print(f"Chunk ID: {r.get('chunk_id')}")
+        print("Text Preview:")
+        print(r["text"][:400])
+        print("-" * 60)
+
+
+if __name__ == "__main__":
+    main()

rag/retriever.py

@@ -0,0 +1,59 @@
+from rag.embedder import OpenaiEmbedder
+from rag.vector_store import FaissVectorStore
+from typing import List, Dict, Any, Optional
+
+class ResumeRetriever:
+
+    DIM = 1536
+    FAISS_INDEX_PATH = "./data/faiss.index"
+    CHUNKS_METADATA_PATH = "./data/chunks_metadata.json"
+    EMBEDDING_MODEL = "text-embedding-3-small"
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ResumeRetriever, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self,embedder:Optional[OpenaiEmbedder] = None,vector_store:Optional[FaissVectorStore]=None):
+
+        if self._initialized:
+            return
+
+        if embedder is None:
+            embedder = OpenaiEmbedder(model=self.EMBEDDING_MODEL)
+        
+        if vector_store is None:
+            vector_store = FaissVectorStore(dim=self.DIM)
+            vector_store.load(self.FAISS_INDEX_PATH,self.CHUNKS_METADATA_PATH)
+        
+        self.embedder = embedder
+        self.vector_store = vector_store
+        self._initialized = True
+    
+    def retrieve(self, query: str, top_k: int = 5) -> list[dict]:
+
+        formatted = []
+
+        if not query or not query.strip():
+            return []
+        
+        query_embedding = self.embedder.embed_text(query)
+        results = self.vector_store.search(query_embedding, top_k=top_k)
+
+        for r in results:
+            meta = r["metadata"]
+            formatted.append({
+                "score": r["score"],
+                "source": meta.get("source", "unknown"),
+                "text": meta.get("text", ""),
+                "page":meta.get("page",""),
+                "file":meta.get("file",""),
+                "chunk_id":meta.get("chunk_id",""),
+                "metadata": meta
+            })
+        
+        return formatted
+    

rag/test.py

@@ -0,0 +1,45 @@
+import json
+from rag.embedder import OpenaiEmbedder
+from rag.vector_store import FaissVectorStore
+from rag.retriever import ResumeRetriever
+
+
+with open("./data/dataset.json","r",encoding="utf-8") as file:
+    dataset = json.load(file)
+
+metadatas = []
+texts = []
+
+for docs in dataset:
+    for doc in docs:
+        texts.append(doc["text"])
+        metadatas.append(doc)
+    
+
+embedder = OpenaiEmbedder()
+embeddings = embedder.embed_multiple_texts(texts)
+
+
+dim = len(embeddings[0])
+store = FaissVectorStore(dim=dim)
+
+store.add_embedding(embeddings, metadatas)
+
+
+store.save_data("./data/faiss.index", "./data/metadata.json")
+
+store2 = FaissVectorStore(dim=dim)
+store2.load("data/faiss.index", "data/metadata.json")
+
+retriever = ResumeRetriever(embedder, store2)
+
+query = "What is knowbot?"
+results = retriever.retrieve(query, top_k=5)
+
+
+print("\nTop Results:\n")
+for r in results:
+    print("Score:", r["score"])
+    print("Source:", r["source"])
+    print("Preview:", r["text"][:200])
+    print("-" * 50)

rag/vector_store.py

@@ -0,0 +1,89 @@
+from utils.central_logging import get_logger
+import json
+import os
+import faiss
+import numpy as np
+
+
+logger = get_logger("vectore_store")
+
+def normalize_vectors(vectors: np.ndarray) -> np.ndarray:
+    faiss.normalize_L2(vectors)
+    return vectors
+
+class FaissVectorStore:
+
+    def __init__(self,dim:int):
+        self.dim = dim
+        self.index = faiss.IndexFlatIP(dim)
+        self.metadata = []
+    
+
+    def add_embedding(self, embeddings: list[list[float]], metadatas: list[dict]):
+
+        if len(embeddings) == 0:
+            message = "Embedding list is empty"
+            logger.error(message)
+            raise ValueError(message)
+
+        if len(embeddings) != len(metadatas):
+            message = "Embeddings and metadata must have same length."
+            logger.error(message)
+            raise ValueError(message)
+        
+        
+        vectors = np.array(embeddings,dtype="float32")
+        vectors = normalize_vectors(vectors)
+        self.index.add(vectors)
+        self.metadata.extend(metadatas)
+    
+
+    def search(self, query_embedding: list[float], top_k: int = 5):
+
+        results = []
+
+        if self.index.ntotal == 0:
+            return []
+        
+        query_vec = np.array([query_embedding],dtype="float32")
+        distances, indices = self.index.search(query_vec, top_k)
+
+        
+        for dist, idx in zip(distances[0], indices[0]):
+            if idx == -1:
+                continue
+
+            results.append({
+                "score": float(dist),
+                "metadata": self.metadata[idx]
+            })
+
+        return results
+    
+
+    def save_data(self, index_path: str, metadata_path: str):
+
+        faiss.write_index(self.index,index_path)
+
+        with open(metadata_path,"w",encoding="utf-8") as file:
+            json.dump(self.metadata,file,indent=2,ensure_ascii=False)
+        
+    
+    def load(self, index_path: str, metadata_path: str):
+
+        if not os.path.exists(index_path):
+            message = f"FAISS index file not found: {index_path}"
+            logger.error(message)
+            raise FileNotFoundError(message)
+
+        if not os.path.exists(metadata_path):
+            message = f"Metadata file not found: {metadata_path}"
+            logger.error(message)
+            raise FileNotFoundError(message)
+
+        self.index = faiss.read_index(index_path)
+
+        with open(metadata_path,'r',encoding="utf-8") as file:
+            self.metadata = json.load(file)
+
+            

ui/chat_handler.py

@@ -0,0 +1,47 @@
+from local_agents.resume_agent import answer_resume_question
+from utils.central_logging import get_logger
+from ui.generate_session import generate_session_id
+
+logger = get_logger("chat_handler")
+
+
+
+
+async def chat_handler(message,history,session_id):
+
+    if not session_id:
+        session_id = generate_session_id()
+    
+    if history is None:
+        history = []
+    
+    history.append({"role":"user","content":message})
+
+    partial_answer = ""
+
+    try:
+        async for token in answer_resume_question(message):
+            #print(f"token: {token}")
+            partial_answer += token
+
+            if len(history) > 0 and history[-1]["role"] == "assistant":
+                history[-1]["content"] = partial_answer
+            else:
+                history.append({"role":"assistant","content":partial_answer})
+
+            yield history,session_id,""
+
+        if "notified" in partial_answer.lower() and "anthony" in partial_answer.lower():
+            logger.info({
+                "type": "escalation",
+                "session_id": session_id,
+                "question": message,
+                "answer_preview": partial_answer[:500]
+            })
+            
+
+    except Exception as e:
+        note = f"An error occured: {str(e)}"
+        logger.exception(note)
+        history[-1]["content"] = note
+        yield history,session_id

ui/contact_handler.py

@@ -0,0 +1,34 @@
+from local_agents.resume_agent import _save_recruiter_contact
+from ui.generate_session import generate_session_id
+from utils.central_logging import get_logger
+
+logger =  get_logger("contact_handler")
+
+def contact_handler(name, email, message, linkedin, company, session_id):
+
+    if not session_id:
+        session_id = generate_session_id()
+
+    if not name or not email or not message:
+        return "⚠️ Name, Email, and Message are required."
+    
+    print(f"name: {name}")
+    print(f"email: {email}")
+    print(f"message: {message}")
+    print(f"linkedin: {linkedin}, company: {company}")
+    try:
+        result = _save_recruiter_contact(name,email,message,linkedin=linkedin if linkedin else None,company=company if company else None)
+        logger.info({
+            "type": "contact_request",
+            "session_id": session_id,
+            "recruiter_name": name,
+            "recruiter_email": email,
+            "company": company,
+            "linkedin": linkedin,
+            "message_preview": message[:500]
+        })
+        return f"✅ Thanks! Your message has been sent.\n\n{result}","", "", "", "", ""
+    except Exception as e:
+        note = f"⚠️ Failed to send contact info: {str(e)}"
+        logger.info(note)
+        return note,"", "", "", "", ""

ui/generate_session.py

@@ -0,0 +1,4 @@
+import uuid
+
+def generate_session_id():
+    return str(uuid.uuid4())[:8]

ui/gradio_app.py

@@ -0,0 +1,115 @@
+from ui.generate_session import generate_session_id
+from utils.central_logging import get_logger
+from ui.chat_handler import chat_handler
+from ui.contact_handler import contact_handler
+import gradio as gr
+import os
+
+
+RESUME_FILE_PATH = "./data/resume.pdf"
+USER_AVATAR = None
+BOT_AVATAR = "./data/thony.png"
+
+logger = get_logger("gradio")
+
+def get_resume_file():
+    if os.path.exists(RESUME_FILE_PATH):
+        return RESUME_FILE_PATH
+    return None
+
+def reset_session():
+    return generate_session_id()
+
+css = """
+.avatar-container {
+    width:80px !important;
+    height: 80px !important;
+}
+ """
+
+def  launch_ui():
+    with gr.Blocks(title="ResumeBot - Cheun Da", theme=gr.themes.Soft(),css=css) as demo:
+
+        gr.Markdown(
+            """
+                #AskMyResume (Cheun Da)
+
+                Answer questions about my resume**.
+
+                **Features**
+                - 💬 Chat Resume Q&A  
+                - 📩 Stay in touch form  
+                - 📄 Resume download  """ )
+        
+        session_state = gr.State(generate_session_id())
+
+        with gr.Row():
+            session_display = gr.Textbox(
+                label="Session Initialisation",
+                interactive=False
+            )
+            reset_session_btn = gr.Button("🔄 New Session")
+
+        
+        demo.load(
+            fn=lambda sid: sid,
+            inputs=session_state,
+            outputs=session_display
+        )
+
+        reset_session_btn.click(
+            fn=reset_session,
+            outputs=session_state
+        ).then(
+            fn=lambda sid: sid,
+            inputs=session_state,
+            outputs=session_display
+        )
+
+        with gr.Tabs():
+            with gr.Tab("💬 Chat"):
+                chatbot = gr.Chatbot(label="Resume Chat", height=450,avatar_images=(USER_AVATAR, BOT_AVATAR))
+                msg = gr.Textbox(label="Ask a question", placeholder="e.g. What projects have you worked on?")
+                #send_btn = gr.Button("Send")
+
+                #send_btn.click(
+                #    fn=chat_handler,
+                #    inputs=[msg, chatbot, session_state],
+                #    outputs=[chatbot, session_state,msg])
+
+                msg.submit(
+                    fn=chat_handler,
+                    inputs=[msg, chatbot, session_state],
+                    outputs=[chatbot, session_state,msg]
+                )
+
+                clear_btn = gr.Button("🧹 Clear Chat")
+                clear_btn.click(lambda: [], outputs=chatbot)
+            
+            with gr.Tab("📩 Stay In Touch"):
+                gr.Markdown("### Recruiter Contact Form (Message Cheun Da Directly)")
+
+                name = gr.Textbox(label="Your Name *")
+                email = gr.Textbox(label="Your Email *")
+                company = gr.Textbox(label="Company (optional)")
+                linkedin = gr.Textbox(label="LinkedIn Profile (optional)")
+                message = gr.Textbox(label="Message *", lines=5)
+
+                contact_btn = gr.Button("Send Message")
+                contact_status = gr.Textbox(label="Status", interactive=False)
+
+                contact_btn.click(
+                    fn=contact_handler,
+                    inputs=[name, email, message, linkedin, company, session_state],
+                    outputs=[contact_status,name, email, message, linkedin, company]
+                )
+            
+            with gr.Tab("📄 Download Resume"):
+                gr.Markdown("### Download Resume PDF")
+                resume_file = gr.File(label="Resume File", value=get_resume_file)
+            
+
+    demo.queue(default_concurrency_limit=64)
+    demo.launch(debug=True, share=False)
+
+

utils/central_logging.py

@@ -0,0 +1,51 @@
+import logging
+import logging.handlers
+from pathlib import Path
+
+LOG_DIR = Path("logs")
+LOG_DIR.mkdir(exist_ok=True)
+
+LOG_FILE = LOG_DIR / "advisor.log"
+
+LOG_FORMAT = (
+    "%(asctime)s | %(levelname)s | %(name)s | "
+    "%(funcName)s:%(lineno)d | %(message)s"
+)
+
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+def setup_logging(log_level=logging.INFO):
+    """Global logging configuration"""
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+
+    # Prevent duplicate logs in notebooks / reloads
+    if root_logger.handlers:
+        return
+
+    formatter = logging.Formatter(LOG_FORMAT, DATE_FORMAT)
+
+    # ---- File Handler (advisor.log) ----
+    file_handler = logging.handlers.RotatingFileHandler(
+        LOG_FILE,
+        maxBytes=10 * 1024 * 1024,  # 10 MB
+        backupCount=5,
+        encoding="utf-8",
+    )
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(log_level)
+
+    # ---- Console Handler ----
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(log_level)
+
+    root_logger.addHandler(file_handler)
+    root_logger.addHandler(console_handler)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a named logger"""
+    return logging.getLogger(name)