Upload folder using huggingface_hub

README.md

@@ -1,61 +1,16 @@
----
-title: Tiny Code-Only TTS
-emoji: 🤖
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.23.0
-app_file: app.py
-pinned: false
----
-
-# Tiny Code-Only TTS for Hugging Face Spaces
-
-This project builds a simple text-to-speech system from code only.
-
-- No API key
-- No external model
-- No pretrained checkpoint
-- Pure Python waveform synthesis
-- Gradio UI for Hugging Face Spaces
-
-## What it does
-
-It converts text into robotic speech audio using a lightweight phoneme-style synthesizer. The engine uses handcrafted sound rules for vowels, fricatives, stops, nasals, liquids, and pauses.
-
-This is a starter TTS project for deployment and experimentation. It is intentionally simple and CPU-friendly.
-
-## Project structure
-
-```text
-.
-├── app.py
-├── requirements.txt
-└── mini_tts/
-    ├── __init__.py
-    ├── config.py
-    ├── normalizer.py
-    ├── service.py
-    └── synth.py
-```
-
-## Run locally
-
-```bash
-pip install -r requirements.txt
-python app.py
-```
-
-## Deploy on Hugging Face Spaces
-
-1. Create a new Space.
-2. Choose `Gradio`.
-3. Upload these files.
-4. Space will install `requirements.txt`.
-5. Open the app and generate speech directly from text.
-
-## Notes
-
-- The voice is synthetic and simple by design.
-- You can tune pitch, speed, and voice color in the UI.
-- You can extend phoneme rules in `mini_tts/synth.py`.
+---
+title: AI Resume Analyzer RAG LangGraph
+emoji: 📄
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+app_file: app.py
+pinned: false
+license: mit
+short_description: AI Resume Analyzer (RAG + LangGraph) by abersabil
+---
+
+# 📄 AI Resume Analyzer (RAG + LangGraph)
+Created & Maintained by **abersabil** (`@abersbail`) | User ID: `69b2ede7cec72416131a3260`
+
+Powered by **NVIDIA Nemotron OCR v2/v1**, **RAG Vector Search**, & **Groq LLM ATS Auditor**.

app.py

@@ -1,72 +1,140 @@
-import gradio as gr
-
-from mini_tts.service import LocalTTSService
-
-
-service = LocalTTSService()
-
-
-def run_tts(text: str, voice: str, speed: float, pitch: float):
-    return service.synthesize(
-        text=text,
-        voice=voice,
-        speed=speed,
-        pitch_shift=pitch,
-    )
-
-
-with gr.Blocks(title="Tiny Code-Only TTS") as demo:
-    gr.Markdown(
-        """
-        # Tiny Code-Only TTS
-        A simple text-to-speech engine built from code only.
-
-        - No API key
-        - No hosted model
-        - No pretrained checkpoint
-        - Designed for Hugging Face Spaces
-        """
-    )
-
-    with gr.Row():
-        with gr.Column():
-            text = gr.Textbox(
-                label="Text",
-                value="Hello. This is a simple text to speech demo built only with code.",
-                lines=8,
-            )
-            voice = gr.Dropdown(
-                label="Voice",
-                choices=["neutral", "bright", "deep"],
-                value="neutral",
-            )
-            speed = gr.Slider(
-                label="Speed",
-                minimum=0.6,
-                maximum=1.6,
-                value=1.0,
-                step=0.1,
-            )
-            pitch = gr.Slider(
-                label="Pitch shift",
-                minimum=-0.3,
-                maximum=0.3,
-                value=0.0,
-                step=0.05,
-            )
-            speak_button = gr.Button("Generate Speech", variant="primary")
-
-        with gr.Column():
-            audio = gr.Audio(label="Audio", type="numpy")
-            status = gr.Textbox(label="Status", value=service.describe())
-            normalized = gr.Textbox(label="Normalized Text", lines=8)
-
-    speak_button.click(
-        fn=run_tts,
-        inputs=[text, voice, speed, pitch],
-        outputs=[audio, status, normalized],
-    )
-
-
-if __name__ == "__main__":
-    demo.launch()
+import os
+import json
+import pandas as pd
+import gradio as gr
+from langgraph_agent import LangGraphResumeAnalyzer
+import utils
+
+analyzer = LangGraphResumeAnalyzer()
+
+CUSTOM_CSS = """
+html, body {
+    background-color: #090d16 !important;
+    font-family: 'Inter', system-ui, -apple-system, sans-serif !important;
+    color: #e2e8f0 !important;
+    overflow-y: auto !important;
+    height: auto !important;
+    min-height: 100% !important;
+    margin: 0 !important;
+    padding: 0 !important;
+}
+
+.gradio-container {
+    background-color: #090d16 !important;
+    max-width: 1400px !important;
+    margin: 0 auto !important;
+    padding: 20px !important;
+    min-height: 100vh !important;
+    height: auto !important;
+    overflow-y: auto !important;
+}
+
+.card-panel {
+    background: linear-gradient(145deg, #131b2e, #0f172a);
+    border: 1px solid rgba(56, 189, 248, 0.2);
+    border-radius: 16px;
+    padding: 20px;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.4);
+    height: auto !important;
+}
+
+.btn-primary-audit {
+    background: linear-gradient(135deg, #0284c7, #4f46e5) !important;
+    color: white !important;
+    font-weight: 800 !important;
+    border-radius: 12px !important;
+    font-size: 1.1rem !important;
+    box-shadow: 0 4px 14px rgba(2, 132, 199, 0.4) !important;
+}
+"""
+
+def handle_run_audit(image_file, text_resume, job_desc):
+    img_path = image_file.name if image_file is not None else None
+    res = analyzer.run_langgraph_pipeline(image_path=img_path, text_input=text_resume, job_description=job_desc)
+    analysis = res["analysis"]
+    ocr_info = res["ocr_result"]
+    ats_score = analysis.get("ats_score_pct", 75)
+    ats_gauge_html = utils.generate_ats_score_html(ats_score)
+    skill_badges_html = utils.format_skill_badges(analysis.get("matched_skills", []), analysis.get("missing_skills", []))
+    summary_md = f"""
+### 👤 Candidate Overview
+- **Candidate Name**: `{analysis.get('candidate_name', 'Candidate')}`
+- **Estimated Experience**: `{analysis.get('estimated_years_experience', '5+ Years')}`
+- **Formatting Rating**: `{analysis.get('formatting_rating', 'GOOD')}`
+
+#### 📝 Executive Assessment
+{analysis.get('executive_summary', 'No summary available.')}
+
+#### 💡 Actionable Tips to Boost ATS Score
+"""
+    for tip in analysis.get("improvement_tips", []):
+        summary_md += f"- {tip}\n"
+
+    ocr_meta_md = f"""
+### 👁️ NVIDIA Nemotron OCR Detection Engine
+- **OCR Engine Used**: `{ocr_info.get('model_used', 'NVIDIA Nemotron OCR v2')}`
+- **Lines Extracted**: `{ocr_info.get('line_count', 0)}`
+- **Status**: `{ocr_info.get('status', 'SUCCESS')}`
+"""
+    detections_list = ocr_info.get("detections", [])
+    df_det = pd.DataFrame(detections_list) if detections_list else pd.DataFrame(columns=["text", "confidence"])
+    full_report_json = json.dumps({"candidate": analysis.get('candidate_name'), "ats_score_pct": ats_score, "ocr_engine": ocr_info.get('model_used'), "analysis": analysis}, indent=2)
+
+    return (ats_gauge_html, skill_badges_html, summary_md, res["timeline"], ocr_meta_md, df_det, res["resume_text"], full_report_json)
+
+def handle_rag_chat(user_question: str):
+    return analyzer.answer_rag_question(user_question)
+
+with gr.Blocks(title="AI Resume Analyzer (RAG + LangGraph)") as demo:
+    gr.Markdown(
+        """
+        # 📄 AI Resume Analyzer (RAG + LangGraph)
+        ### Multimodal OCR powered by NVIDIA Nemotron OCR v2/v1 & Groq LLM ATS Auditor
+        **Engineer / Creator:** `abersabil` (`@abersbail`) | **User ID:** `69b2ede7cec72416131a3260`
+        """
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("📊 LangGraph ATS Audit & Matching"):
+            with gr.Row():
+                with gr.Column(scale=1, elem_classes=["card-panel"]):
+                    gr.Markdown("### 📥 Upload Resume & Job Description")
+                    resume_img = gr.File(label="Upload Resume Image (.png, .jpg, .jpeg)", file_types=["image"])
+                    resume_text_area = gr.Textbox(value=utils.DEFAULT_SAMPLE_RESUME, label="OR Paste Resume Text directly", lines=8)
+                    job_desc_area = gr.Textbox(value=utils.DEFAULT_JOB_DESCRIPTION, label="Target Job Description (JD)", lines=6)
+                    btn_audit = gr.Button("🚀 Run LangGraph RAG Audit", elem_classes=["btn-primary-audit"])
+                    langgraph_timeline = gr.Textbox(label="LangGraph State Machine Stream", lines=6, interactive=False)
+
+                with gr.Column(scale=1):
+                    ats_score_gauge = gr.HTML(utils.generate_ats_score_html(88))
+                    skill_badges_box = gr.HTML("Click 'Run LangGraph RAG Audit' to analyze candidate skills.")
+                    executive_summary_box = gr.Markdown("Candidate evaluation summary will appear here.")
+
+        with gr.TabItem("👁️ NVIDIA Nemotron OCR Scanner"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    ocr_metadata_box = gr.Markdown("Run audit to view NVIDIA Nemotron OCR v2/v1 detection metrics.")
+                    ocr_detections_df = gr.Dataframe(label="Detected Lines & Confidence Scores")
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📄 Extracted Resume Raw Text")
+                    ocr_raw_text_box = gr.Textbox(lines=18, interactive=False)
+
+        with gr.TabItem("💬 Candidate RAG Chatbot"):
+            gr.Markdown("### 🤖 Ask RAG Questions About Candidate Qualifications")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    rag_question_input = gr.Textbox(label="Type Question about Candidate", placeholder="e.g., What PyTorch & RAG experience does the candidate have?", lines=2)
+                    btn_ask_rag = gr.Button("🔍 Query RAG Vector Index", variant="primary")
+                with gr.Column(scale=1):
+                    rag_answer_output = gr.Textbox(label="Grounded RAG Answer", lines=8, interactive=False)
+
+        with gr.TabItem("📝 Candidate Report Export"):
+            gr.Markdown("### 📑 Downloadable Candidate Evaluation JSON Report")
+            full_report_code = gr.Code(language="json", label="JSON Candidate Audit Report")
+
+    btn_audit.click(fn=handle_run_audit, inputs=[resume_img, resume_text_area, job_desc_area], outputs=[ats_score_gauge, skill_badges_box, executive_summary_box, langgraph_timeline, ocr_metadata_box, ocr_detections_df, ocr_raw_text_box, full_report_code])
+    btn_ask_rag.click(fn=handle_rag_chat, inputs=[rag_question_input], outputs=[rag_answer_output])
+
+if __name__ == "__main__":
+    demo.queue()
+    demo.launch(server_name="0.0.0.0", server_port=7860, css=CUSTOM_CSS)

langgraph_agent.py

@@ -0,0 +1,146 @@
+import os
+import json
+import re
+from groq import Groq
+import nvidia_ocr
+from rag_engine import ResumeRAGStore
+
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "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")
+
+class LangGraphResumeAnalyzer:
+    def __init__(self):
+        self.groq_client = Groq(api_key=GROQ_API_KEY)
+        self.model = "llama-3.3-70b-versatile"
+        self.rag_store = ResumeRAGStore()
+        self.current_resume_text = ""
+        self.current_analysis = {}
+
+    def run_langgraph_pipeline(self, image_path: str = None, text_input: str = None, job_description: str = None) -> dict:
+        """
+        Executes the 4-stage LangGraph workflow pipeline:
+        Stage 1: NVIDIA Nemotron OCR Extraction
+        Stage 2: RAG Vector Indexing
+        Stage 3: ATS Audit & Keyword Matcher
+        Stage 4: Analysis Report Synthesis
+        """
+        timeline = []
+        
+        # STAGE 1: OCR / Text Acquisition
+        if image_path:
+            timeline.append("⏱ Stage 1 [LangGraph Node: Nemotron OCR]: Initiating NVIDIA Nemotron OCR v2/v1 extraction...")
+            ocr_result = nvidia_ocr.extract_text_with_nemotron_ocr(image_path)
+            resume_text = ocr_result["extracted_text"]
+            model_used = ocr_result["model_used"]
+            line_count = ocr_result["line_count"]
+            timeline.append(f"✓ Stage 1 Complete: Extracted {line_count} lines via {model_used}.")
+        else:
+            timeline.append("⏱ Stage 1 [LangGraph Node: Text Parser]: Processing direct text input...")
+            resume_text = text_input or "No resume content provided."
+            model_used = "Direct Text Input"
+            ocr_result = {"status": "TEXT_INPUT", "model_used": model_used, "line_count": len(resume_text.splitlines())}
+
+        self.current_resume_text = resume_text
+
+        # STAGE 2: RAG Indexing
+        timeline.append("⏱ Stage 2 [LangGraph Node: RAG Vector Store]: Indexing resume passages for semantic retrieval...")
+        self.rag_store.index_resume_text(resume_text)
+        timeline.append(f"✓ Stage 2 Complete: Indexed {len(self.rag_store.chunks)} passage chunks into RAG store.")
+
+        # STAGE 3: ATS Audit & LLM Evaluation
+        timeline.append("⏱ Stage 3 [LangGraph Node: ATS Auditor]: Auditing skills, experience, and keyword alignment against Job Description...")
+        
+        jd_text = job_description if (job_description and job_description.strip()) else "General Software & AI Engineering Position"
+        
+        system_prompt = (
+            "You are an expert Executive Technical Recruiter and ATS (Applicant Tracking System) Auditor.\n"
+            "Analyze the candidate's resume against the target Job Description and output valid JSON matching this schema:\n"
+            "{\n"
+            '  "candidate_name": "Inferred Name or Candidate",\n'
+            '  "ats_score_pct": 85,\n'
+            '  "estimated_years_experience": "5+ Years",\n'
+            '  "matched_skills": ["Skill1", "Skill2"],\n'
+            '  "missing_skills": ["Missing1", "Missing2"],\n'
+            '  "formatting_rating": "EXCELLENT | GOOD | POOR",\n'
+            '  "executive_summary": "1-2 sentence candidate summary.",\n'
+            '  "improvement_tips": ["Tip 1", "Tip 2", "Tip 3"]\n'
+            "}"
+        )
+
+        user_content = (
+            f"=== TARGET JOB DESCRIPTION ===\n{jd_text}\n\n"
+            f"=== EXTRACTED RESUME TEXT ===\n{resume_text}\n\n"
+            "Perform rigorous ATS scoring and output valid JSON."
+        )
+
+        try:
+            completion = self.groq_client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content}
+                ],
+                temperature=0.1,
+                response_format={"type": "json_object"}
+            )
+            raw_json = completion.choices[0].message.content.strip()
+            analysis_dict = json.loads(raw_json)
+        except Exception as e:
+            print(f"[LangGraph] LLM Audit Error: {e}")
+            analysis_dict = {
+                "candidate_name": "Candidate",
+                "ats_score_pct": 75,
+                "estimated_years_experience": "3+ Years",
+                "matched_skills": ["Python", "Machine Learning"],
+                "missing_skills": ["Specific JD Requirements"],
+                "formatting_rating": "GOOD",
+                "executive_summary": "Candidate shows strong technical foundation.",
+                "improvement_tips": ["Highlight quantifiable achievements", "Add missing keywords from JD"]
+            }
+
+        timeline.append(f"✓ Stage 3 Complete: Calculated ATS Score = {analysis_dict.get('ats_score_pct', 75)}%.")
+        
+        self.current_analysis = analysis_dict
+
+        return {
+            "timeline": "\n".join(timeline),
+            "ocr_result": ocr_result,
+            "resume_text": resume_text,
+            "analysis": analysis_dict
+        }
+
+    def answer_rag_question(self, user_question: str) -> str:
+        """
+        Answers candidate Q&A queries using RAG context retrieval over resume chunks.
+        """
+        if not user_question or not user_question.strip():
+            return "Please type a question about the candidate."
+
+        if not self.current_resume_text:
+            return "Please upload a resume first before asking questions."
+
+        # Retrieve RAG context
+        context = self.rag_store.retrieve_context(user_question, top_k=4)
+
+        system_prompt = (
+            "You are a helpful Candidate Q&A Assistant. Answer the hiring manager's question strictly "
+            "based on the retrieved candidate resume passages below. Be concise, professional, and factual."
+        )
+
+        user_content = (
+            f"=== RETRIEVED RESUME CONTEXT ===\n{context}\n\n"
+            f"=== HIRING MANAGER QUESTION ===\n{user_question}"
+        )
+
+        try:
+            completion = self.groq_client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content}
+                ],
+                temperature=0.2,
+                max_tokens=300
+            )
+            return completion.choices[0].message.content.strip()
+        except Exception as e:
+            return f"RAG Q&A Exception: {e}"

nvidia_ocr.py

@@ -0,0 +1,104 @@
+import os
+import base64
+import requests
+import io
+from PIL import Image
+
+NVIDIA_API_KEY = os.environ.get("NVIDIA_API_KEY", "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")
+
+NEMOTRON_OCR_V2_URL = "https://ai.api.nvidia.com/v1/cv/nvidia/nemotron-ocr-v2"
+NEMOTRON_OCR_V1_URL = "https://ai.api.nvidia.com/v1/cv/nvidia/nemotron-ocr-v1"
+
+def process_image_for_ocr(image_path: str, max_b64_len: int = 175000) -> str:
+    """
+    Reads image file, resizes if necessary to ensure Base64 string is under NVIDIA 180KB payload limit.
+    """
+    with Image.open(image_path) as img:
+        img = img.convert("RGB")
+        
+        # Check initial size
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=85)
+        b64_str = base64.b64encode(buf.getvalue()).decode()
+        
+        # Resize iteratively if > max_b64_len
+        scale = 0.9
+        while len(b64_str) > max_b64_len and scale > 0.2:
+            new_w = int(img.width * scale)
+            new_h = int(img.height * scale)
+            resized_img = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+            buf = io.BytesIO()
+            resized_img.save(buf, format="JPEG", quality=80)
+            b64_str = base64.b64encode(buf.getvalue()).decode()
+            scale -= 0.1
+            
+        return b64_str
+
+def extract_text_with_nemotron_ocr(image_path: str) -> dict:
+    """
+    Calls NVIDIA Nemotron OCR v2 with automatic fallback to v1.
+    Extracts text detections, confidence scores, and raw concatenated resume text.
+    """
+    b64_data = process_image_for_ocr(image_path)
+    
+    headers = {
+        "Authorization": f"Bearer {NVIDIA_API_KEY}",
+        "Accept": "application/json"
+    }
+    
+    payload = {
+        "input": [
+            {
+                "type": "image_url",
+                "url": f"data:image/jpeg;base64,{b64_data}"
+            }
+        ]
+    }
+    
+    # Try Nemotron OCR v2 first, then fallback to v1
+    models_to_try = [
+        ("NVIDIA Nemotron OCR v2", NEMOTRON_OCR_V2_URL),
+        ("NVIDIA Nemotron OCR v1", NEMOTRON_OCR_V1_URL)
+    ]
+    
+    for model_name, url in models_to_try:
+        try:
+            res = requests.post(url, headers=headers, json=payload, timeout=20)
+            if res.status_code == 200:
+                data = res.json()
+                detections = []
+                extracted_lines = []
+                
+                # Parse detections
+                items = data.get("data", [])
+                if items:
+                    for det in items[0].get("text_detections", []):
+                        pred = det.get("text_prediction", {})
+                        text = pred.get("text", "").strip()
+                        conf = pred.get("confidence", 0.0)
+                        if text:
+                            extracted_lines.append(text)
+                            detections.append({"text": text, "confidence": round(conf, 3)})
+                            
+                full_text = "\n".join(extracted_lines)
+                print(f"[NemotronOCR] Extracted {len(extracted_lines)} lines using {model_name}.")
+                
+                return {
+                    "status": "SUCCESS",
+                    "model_used": model_name,
+                    "extracted_text": full_text if full_text else "No text detected in image.",
+                    "detections": detections,
+                    "line_count": len(extracted_lines)
+                }
+            else:
+                print(f"[NemotronOCR] {model_name} returned status {res.status_code}: {res.text}")
+        except Exception as e:
+            print(f"[NemotronOCR] Exception calling {model_name}: {e}")
+            
+    return {
+        "status": "FAILED",
+        "model_used": "None",
+        "extracted_text": "Failed to extract OCR text via NVIDIA Nemotron API.",
+        "detections": [],
+        "line_count": 0
+    }

rag_engine.py

@@ -0,0 +1,70 @@
+import re
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+class ResumeRAGStore:
+    def __init__(self, chunk_size: int = 250, overlap: int = 50):
+        self.chunk_size = chunk_size
+        self.overlap = overlap
+        self.chunks = []
+        self.vectorizer = None
+        self.tfidf_matrix = None
+
+    def index_resume_text(self, text: str):
+        """
+        Chunks raw resume text and indexes it using TF-IDF for RAG retrieval.
+        """
+        if not text or not text.strip():
+            self.chunks = ["No resume content indexed."]
+            return
+
+        # Split into paragraphs and sentences
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        self.chunks = []
+
+        current_chunk = []
+        current_len = 0
+
+        for line in lines:
+            current_chunk.append(line)
+            current_len += len(line)
+            if current_len >= self.chunk_size:
+                self.chunks.append(" ".join(current_chunk))
+                current_chunk = current_chunk[-1:]  # Keep last line for overlap
+                current_len = len(current_chunk[0]) if current_chunk else 0
+
+        if current_chunk:
+            self.chunks.append(" ".join(current_chunk))
+
+        if not self.chunks:
+            self.chunks = [text]
+
+        # Build TF-IDF index
+        self.vectorizer = TfidfVectorizer(stop_words="english")
+        try:
+            self.tfidf_matrix = self.vectorizer.fit_transform(self.chunks)
+        except Exception as e:
+            print(f"[RAGStore] TFIDF indexing warning: {e}")
+            self.tfidf_matrix = None
+
+    def retrieve_context(self, query: str, top_k: int = 3) -> str:
+        """
+        Retrieves top_k most relevant resume passages matching the query.
+        """
+        if not self.chunks or self.vectorizer is None or self.tfidf_matrix is None:
+            return "\n".join(self.chunks[:top_k])
+
+        try:
+            query_vec = self.vectorizer.transform([query])
+            scores = cosine_similarity(query_vec, self.tfidf_matrix).flatten()
+            top_indices = np.argsort(scores)[::-1][:top_k]
+            
+            relevant_chunks = [self.chunks[i] for i in top_indices if scores[i] > 0.05]
+            if not relevant_chunks:
+                relevant_chunks = self.chunks[:top_k]
+
+            return "\n\n---\n\n".join(relevant_chunks)
+        except Exception as e:
+            print(f"[RAGStore] Context retrieval error: {e}")
+            return "\n".join(self.chunks[:top_k])

requirements.txt

@@ -1,2 +1,8 @@
-gradio>=5.23.0
-numpy>=1.26.0
+groq>=0.30.0
+requests>=2.28.0
+pillow>=9.0.0
+scikit-learn>=1.0.0
+numpy>=1.20.0
+pandas>=2.0.0
+pyyaml>=6.0
+psutil>=5.9.0

utils.py

@@ -0,0 +1,61 @@
+DEFAULT_SAMPLE_RESUME = """ALEX CHEN
+Senior AI & Machine Learning Engineer | San Francisco, CA | alex.chen@email.com
+
+SUMMARY
+Passionate Senior AI Engineer with 6+ years of experience designing and deploying scalable deep learning models, RAG architectures, and computer vision systems. Expertise in PyTorch, Python, TensorFlow, Docker, Kubernetes, and LLM fine-tuning.
+
+TECHNICAL SKILLS
+• Languages: Python, C++, SQL, Bash
+• AI & ML Frameworks: PyTorch, TensorFlow, Scikit-learn, OpenCV, Hugging Face
+• LLM & RAG: LangChain, LlamaIndex, Vector DBs (Milvus, Qdrant, FAISS), RAG Optimization
+• MLOps & Cloud: AWS (S3, EC2, SageMaker), Docker, Kubernetes, CI/CD, MLflow
+
+PROFESSIONAL EXPERIENCE
+Senior AI Engineer | TechCorp AI (2022 - Present)
+• Led development of enterprise RAG search system improving document retrieval latency by 45%.
+• Fine-tuned 70B parameter LLMs on proprietary datasets using LoRA and QLoRA techniques.
+• Architected automated MLOps pipelines on Kubernetes serving 2M+ daily active requests.
+
+EDUCATION
+B.S. in Computer Science | University of California, Berkeley (2015 - 2019)
+"""
+
+DEFAULT_JOB_DESCRIPTION = """We are seeking a Senior AI/ML Engineer to build next-generation RAG systems, fine-tune open-source Large Language Models (LLMs), and deploy scalable MLOps infrastructure.
+
+KEY REQUIREMENTS:
+• 5+ years of software engineering & ML experience in Python and PyTorch.
+• Strong expertise in RAG (Retrieval-Augmented Generation), Vector Databases, and LangChain/LangGraph.
+• Demonstrated experience deploying containerized models on Docker/Kubernetes or Cloud (AWS/GCP).
+• Experience with MLOps tracking tools (MLflow, Weights & Biases) and CI/CD pipelines.
+• B.S. or M.S. in Computer Science or related field.
+"""
+
+def generate_ats_score_html(score_pct: int) -> str:
+    color = "#48bb78" if score_pct >= 80 else ("#ed8936" if score_pct >= 60 else "#f56565")
+    return f"""
+    <div style='background: linear-gradient(135deg, #1e293b, #0f172a); border: 1px solid rgba(255,255,255,0.1); border-radius: 16px; padding: 20px; text-align: center; box-shadow: 0 8px 32px rgba(0,0,0,0.4);'>
+        <div style='font-size: 0.85rem; text-transform: uppercase; color: #94a3b8; font-weight: 700; letter-spacing: 0.05em;'>ATS Match Compatibility Score</div>
+        <div style='font-size: 3.2rem; font-weight: 900; color: {color}; margin: 8px 0; font-family: Inter, sans-serif;'>{score_pct}%</div>
+        <div style='background: #1a202c; border-radius: 10px; height: 12px; width: 100%; overflow: hidden; border: 1px solid #2d3748;'>
+            <div style='background: {color}; height: 100%; width: {score_pct}%; border-radius: 10px; transition: width 0.8s ease-in-out;'></div>
+        </div>
+    </div>
+    """
+
+def format_skill_badges(matched_skills: list, missing_skills: list) -> str:
+    html = ["<div style='font-family: Inter, sans-serif; padding: 10px;'>"]
+    html.append("<h4 style='color: #4ade80; margin-bottom: 8px;'>✅ Matched Qualifications & Skills</h4><div>")
+    if matched_skills:
+        for s in matched_skills:
+            html.append(f"<span style='display: inline-block; background: rgba(34, 197, 94, 0.15); color: #4ade80; border: 1px solid #22c55e; border-radius: 14px; padding: 4px 12px; margin: 4px; font-size: 13px; font-weight: 600;'>✓ {s}</span>")
+    else:
+        html.append("<span style='color: #94a3b8;'>No explicit matching skills found.</span>")
+    html.append("</div><br>")
+    html.append("<h4 style='color: #f87171; margin-bottom: 8px;'>⚠️ Missing Key Competencies from Job Description</h4><div>")
+    if missing_skills:
+        for s in missing_skills:
+            html.append(f"<span style='display: inline-block; background: rgba(239, 68, 68, 0.15); color: #f87171; border: 1px solid #ef4444; border-radius: 14px; padding: 4px 12px; margin: 4px; font-size: 13px; font-weight: 600;'>✗ {s}</span>")
+    else:
+        html.append("<span style='color: #4ade80;'>No major missing skills identified!</span>")
+    html.append("</div></div>")
+    return "".join(html)