Deploy ATS Intelligence Engine to Hugging Face Space

Co-authored-by: Cursor <cursoragent@cursor.com>

.dockerignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+.git
+.gitignore
+__pycache__
+**/__pycache__
+*.md
+images/
+terminals/
+.vscode/
+.idea/

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow 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
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* 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
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+*__pycache__
+*.pyc
+*.pyo
+.env

Dockerfile

@@ -0,0 +1,35 @@
+# Hugging Face Spaces Docker: https://huggingface.co/docs/hub/spaces-sdks-docker
+FROM python:3.11-slim
+
+# Required for Hugging Face Spaces Dev Mode
+RUN useradd -m -u 1000 user
+
+WORKDIR /app
+
+# System deps for PyMuPDF
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libglib2.0-0 \
+    libsm6 \
+    libxrender1 \
+    libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV HF_HOME=/home/user/.cache/huggingface \
+    PORT=7860
+
+RUN mkdir -p ${HF_HOME} && chown -R user:user /home/user
+
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pre-download embedding model at build time (faster Space cold start)
+RUN su - user -c "python -c \"from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')\""
+
+COPY --chown=user . /app
+
+USER user
+ENV PATH=/home/user/.local/bin:$PATH
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

Frontend/app.js

@@ -0,0 +1,283 @@
+// ── State ──────────────────────────────────────────────────────────────────
+const state = { resume: null, jd: null };
+//const API = 'http://localhost:8000'; // for localhost
+const API = ''; //for nginx
+let resumeMode = 'pdf'; // 'pdf' | 'text'
+let jdMode = 'pdf';     // 'pdf' | 'text'
+
+// Set pdf.js worker
+pdfjsLib.GlobalWorkerOptions.workerSrc =
+  'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';
+
+// ── PDF Extraction ─────────────────────────────────────────────────────────
+async function extractTextFromPDF(file) {
+  const arrayBuffer = await file.arrayBuffer();
+  const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+  let fullText = '';
+  for (let i = 1; i <= pdf.numPages; i++) {
+    const page = await pdf.getPage(i);
+    const content = await page.getTextContent();
+    const pageText = content.items.map(item => item.str).join(' ');
+    fullText += pageText + '\n';
+  }
+  return fullText.trim();
+}
+
+// ── File Handling ──────────────────────────────────────────────────────────
+async function handleFile(type, file) {
+  if (!file || file.type !== 'application/pdf') {
+    setStatus(type, 'Only PDF files are supported.', true);
+    return;
+  }
+  if (file.size > 10 * 1024 * 1024) {
+    setStatus(type, 'File exceeds 10MB limit.', true);
+    return;
+  }
+
+  const chipName = document.getElementById(type + 'ChipName');
+  const chip = document.getElementById(type + 'Chip');
+  chipName.textContent = file.name;
+  chip.style.display = 'flex';
+
+  document.getElementById(type + 'DropZone').classList.add('has-file');
+
+  setStatus(type, '⏳ Extracting text from PDF...');
+  try {
+    const text = await extractTextFromPDF(file);
+    if (!text || text.length < 30) {
+      setStatus(type, '⚠️ Could not extract enough text. Is this a scanned PDF?', true);
+      return;
+    }
+    state[type] = text;
+    setStatus(type, `✓ Extracted ${text.length.toLocaleString()} characters from ${file.name}`);
+
+    const previewBtn = document.getElementById(type + 'PreviewBtn');
+    const previewDiv = document.getElementById(type + 'Preview');
+    previewDiv.textContent = text.slice(0, 1200) + (text.length > 1200 ? '\n\n… (truncated)' : '');
+    previewBtn.style.display = 'inline-block';
+  } catch (err) {
+    setStatus(type, '✕ Failed to read PDF: ' + err.message, true);
+  }
+}
+
+function setStatus(type, msg, isError = false) {
+  const el = document.getElementById(type + 'Status');
+  el.textContent = msg;
+  el.className = 'extract-status' + (isError ? ' error' : '');
+}
+
+function clearFile(type) {
+  state[type] = null;
+  document.getElementById(type + 'File').value = '';
+  document.getElementById(type + 'Chip').style.display = 'none';
+  document.getElementById(type + 'DropZone').classList.remove('has-file');
+  document.getElementById(type + 'Status').textContent = '';
+  document.getElementById(type + 'PreviewBtn').style.display = 'none';
+  document.getElementById(type + 'Preview').style.display = 'none';
+}
+
+function togglePreview(type) {
+  const div = document.getElementById(type + 'Preview');
+  const btn = document.getElementById(type + 'PreviewBtn');
+  const visible = div.style.display !== 'none';
+  div.style.display = visible ? 'none' : 'block';
+  btn.textContent = visible
+    ? (type === 'resume' ? '👁 Preview resume text' : '👁 Preview JD text')
+    : '🙈 Hide preview';
+}
+
+// ── Drop Zone Setup ────────────────────────────────────────────────────────
+function setupDropZone(type) {
+  const zone = document.getElementById(type + 'DropZone');
+  const input = document.getElementById(type + 'File');
+
+  zone.addEventListener('click', e => {
+    if (e.target.closest('.file-chip') || e.target.classList.contains('drop-link')) return;
+    input.click();
+  });
+
+  input.addEventListener('change', () => {
+    if (input.files[0]) handleFile(type, input.files[0]);
+  });
+
+  zone.addEventListener('dragover', e => { e.preventDefault(); zone.classList.add('drag-over'); });
+  zone.addEventListener('dragleave', () => zone.classList.remove('drag-over'));
+  zone.addEventListener('drop', e => {
+    e.preventDefault();
+    zone.classList.remove('drag-over');
+    const file = e.dataTransfer.files[0];
+    if (file) handleFile(type, file);
+  });
+}
+
+setupDropZone('resume');
+setupDropZone('jd');
+
+// ── Mode Toggle (shared for both resume and jd) ────────────────────────────
+function switchMode(type, mode) {
+  if (type === 'resume') resumeMode = mode;
+  else jdMode = mode;
+
+  const cap = type.charAt(0).toUpperCase() + type.slice(1);
+
+  document.getElementById(type + 'PdfMode').style.display  = mode === 'pdf'  ? 'block' : 'none';
+  document.getElementById(type + 'TextMode').style.display = mode === 'text' ? 'block' : 'none';
+  document.getElementById(type + 'TogglePdf').classList.toggle('active',  mode === 'pdf');
+  document.getElementById(type + 'ToggleText').classList.toggle('active', mode === 'text');
+
+  if (mode === 'pdf') {
+    document.getElementById(type + 'Textarea').value = '';
+    updateCharCount(type);
+  } else {
+    clearFile(type);
+  }
+}
+
+// ── Get text from whichever mode is active ─────────────────────────────────
+function getText(type) {
+  const mode = type === 'resume' ? resumeMode : jdMode;
+  if (mode === 'text') {
+    return document.getElementById(type + 'Textarea').value.trim();
+  }
+  return state[type];
+}
+
+// ── Character Counters ─────────────────────────────────────────────────────
+function updateCharCount(type) {
+  const textarea = document.getElementById(type + 'Textarea');
+  const len = textarea ? textarea.value.length : 0;
+  const counter = document.getElementById(type + 'CharCount');
+  if (counter) counter.textContent = `${len.toLocaleString()} character${len !== 1 ? 's' : ''}`;
+}
+
+document.getElementById('resumeTextarea').addEventListener('input', () => updateCharCount('resume'));
+document.getElementById('jdTextarea').addEventListener('input', () => updateCharCount('jd'));
+
+// ── Analyze ────────────────────────────────────────────────────────────────
+async function analyze() {
+  const btn        = document.getElementById('analyzeBtn');
+  const spinner    = document.getElementById('spinner');
+  const btnLabel   = document.getElementById('btnLabel');
+  const statusText = document.getElementById('statusText');
+  const errorBox   = document.getElementById('errorBox');
+  const results    = document.getElementById('results');
+
+  errorBox.classList.remove('show');
+  results.classList.remove('show');
+
+  const resumeText = getText('resume');
+  if (!resumeText || resumeText.length < 30) {
+    showError(
+      resumeMode === 'pdf'
+        ? 'Please upload and process your resume PDF first.'
+        : 'Please paste at least a few lines of resume text.'
+    );
+    return;
+  }
+
+  const jdText = getText('jd');
+  if (!jdText || jdText.length < 30) {
+    showError(
+      jdMode === 'pdf'
+        ? 'Please upload and process the job description PDF first.'
+        : 'Please paste at least a few lines of job description text.'
+    );
+    return;
+  }
+
+  btn.disabled = true;
+  spinner.classList.add('active');
+  btnLabel.textContent = 'Analyzing...';
+  statusText.textContent = 'Sending to backend...';
+
+  try {
+    const resumeFile = document.getElementById('resumeFile').files[0];
+    const jdFile     = document.getElementById('jdFile').files[0];
+    const useUpload  = (resumeMode === 'pdf' && resumeFile) || (jdMode === 'pdf' && jdFile);
+
+    let res;
+    if (useUpload) {
+      // At least one PDF — send as multipart/form-data
+      const form = new FormData();
+      if (resumeMode === 'pdf' && resumeFile) form.append('resume_pdf', resumeFile);
+      else form.append('resume_text', resumeText);
+      if (jdMode === 'pdf' && jdFile) form.append('jd_pdf', jdFile);
+      else form.append('job_description', jdText);
+      res = await fetch(`${API}/predict/ats/upload`, { method: 'POST', body: form });
+    } else {
+      // Both plain text — send as JSON
+      res = await fetch(`${API}/predict/ats`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ resume_text: resumeText, job_description: jdText })
+      });
+    }
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.detail || `HTTP ${res.status}`);
+    }
+
+    const data = await res.json();
+    render(data);
+    statusText.textContent = 'Done ✓';
+  } catch (e) {
+    const msg = (e.message || '').toLowerCase().includes('fetch')
+      ? `Cannot reach backend at ${API}. Is your FastAPI server running?`
+      : e.message;
+    showError(msg);
+    statusText.textContent = '';
+  } finally {
+    btn.disabled = false;
+    spinner.classList.remove('active');
+    btnLabel.textContent = 'Run Analysis';
+  }
+}
+
+// ── Render Results ─────────────────────────────────────────────────────────
+function render(data) {
+  const s = +(data.semantic_score  || 0).toFixed(1);
+  const k = +(data.keyword_score   || 0).toFixed(1);
+  const f = +(data.final_ats_score || 0).toFixed(1);
+
+  document.getElementById('finalScore').innerHTML    = `${f}<span class="score-unit">/100</span>`;
+  document.getElementById('semanticScore').innerHTML = `${s}<span class="score-unit">/100</span>`;
+  document.getElementById('keywordScore').innerHTML  = `${k}<span class="score-unit">/100</span>`;
+  document.getElementById('feedbackBody').textContent = data.summary || 'No feedback returned.';
+
+  document.getElementById('results').classList.add('show');
+
+  setTimeout(() => {
+    setBar('finalBar',    'finalPct',    'finalMiniBar',    f);
+    setBar('semanticBar', 'semanticPct', 'semanticMiniBar', s);
+    setBar('keywordBar',  'keywordPct',  'keywordMiniBar',  k);
+  }, 60);
+}
+
+function setBar(barId, pctId, miniId, val) {
+  const pct = Math.min(val, 100);
+  document.getElementById(barId).style.width  = pct + '%';
+  document.getElementById(miniId).style.width = pct + '%';
+  document.getElementById(pctId).textContent  = val + '%';
+}
+
+// ── Utilities ──────────────────────────────────────────────────────────────
+function showError(msg) {
+  const box = document.getElementById('errorBox');
+  box.textContent = msg;
+  box.classList.add('show');
+}
+
+function clearAll() {
+  clearFile('resume');
+  clearFile('jd');
+  document.getElementById('resumeTextarea').value = '';
+  document.getElementById('jdTextarea').value = '';
+  updateCharCount('resume');
+  updateCharCount('jd');
+  switchMode('resume', 'pdf');
+  switchMode('jd', 'pdf');
+  document.getElementById('results').classList.remove('show');
+  document.getElementById('errorBox').classList.remove('show');
+  document.getElementById('statusText').textContent = '';
+}

Frontend/index.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>ATS Resume Scorer</title>
+  <link href="https://fonts.googleapis.com/css2?family=Syne:wght@400;500;600;700;800&family=DM+Mono:wght@300;400;500&display=swap" rel="stylesheet"/>
+  <link rel="stylesheet" href="style.css"/>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.min.js"></script>
+</head>
+<body>
+
+<div class="glow-orb a"></div>
+<div class="glow-orb b"></div>
+
+<div class="container">
+
+  <header>
+    <div class="logo-mark">
+      <div class="logo-icon"></div>
+      <span class="logo-text">ATS<span>Score</span></span>
+    </div>
+    <span class="badge">v2.0 · PDF-Powered</span>
+  </header>
+
+  <section class="hero">
+    <h1>Resume ATS <span class="line2">Intelligence Engine</span></h1>
+    <p>Upload your resume and job description as PDFs. We extract the text, analyze semantic similarity, and score your ATS compatibility.</p>
+  </section>
+
+  <div class="input-grid">
+    <!-- Resume field-wrap — replace the existing one -->
+<div class="field-wrap">
+  <label class="field-label">Resume PDF</label>
+
+  <div class="input-toggle">
+    <button class="toggle-btn active" id="resumeTogglePdf" onclick="switchMode('resume', 'pdf')">📄 PDF Upload</button>
+    <button class="toggle-btn" id="resumeToggleText" onclick="switchMode('resume', 'text')">✏️ Paste Text</button>
+  </div>
+
+  <!-- PDF mode -->
+  <div id="resumePdfMode">
+    <div class="drop-zone" id="resumeDropZone">
+      <input type="file" id="resumeFile" accept=".pdf" hidden />
+      <div class="drop-icon">
+        <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+          <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+          <polyline points="14 2 14 8 20 8"/>
+          <line x1="12" y1="18" x2="12" y2="12"/>
+          <line x1="9" y1="15" x2="15" y2="15"/>
+        </svg>
+      </div>
+      <p class="drop-title">Drop your resume here</p>
+      <p class="drop-sub">or <span class="drop-link" onclick="document.getElementById('resumeFile').click()">browse file</span></p>
+      <p class="drop-hint">PDF only · Max 10MB</p>
+      <div class="file-chip" id="resumeChip" style="display:none;">
+        <span class="chip-icon">📄</span>
+        <span class="chip-name" id="resumeChipName"></span>
+        <button class="chip-remove" onclick="clearFile('resume')">✕</button>
+      </div>
+      <div class="extract-status" id="resumeStatus"></div>
+    </div>
+  </div>
+
+  <!-- Text mode -->
+  <div id="resumeTextMode" style="display:none;">
+    <textarea id="resumeTextarea" placeholder="Paste your full resume content here — skills, experience, education, projects..."></textarea>
+    <div class="char-count" id="resumeCharCount">0 characters</div>
+  </div>
+</div>
+
+    <div class="field-wrap">
+  <label class="field-label jd-label">Job Description</label>
+
+  <!-- Toggle -->
+  <div class="input-toggle">
+    <button class="toggle-btn active" id="jdTogglePdf" onclick="switchMode('jd', 'pdf')">📄 PDF Upload</button>
+    <button class="toggle-btn" id="jdToggleText" onclick="switchMode('jd', 'text')">✏️ Paste Text</button>
+  </div>
+
+  <!-- PDF mode -->
+  <div id="jdPdfMode">
+    <div class="drop-zone jd-zone" id="jdDropZone">
+      <input type="file" id="jdFile" accept=".pdf" hidden />
+      <div class="drop-icon">
+        <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+          <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+          <polyline points="14 2 14 8 20 8"/>
+          <line x1="16" y1="13" x2="8" y2="13"/>
+          <line x1="16" y1="17" x2="8" y2="17"/>
+          <polyline points="10 9 9 9 8 9"/>
+        </svg>
+      </div>
+      <p class="drop-title">Drop job description here</p>
+      <p class="drop-sub">or <span class="drop-link" onclick="document.getElementById('jdFile').click()">browse file</span></p>
+      <p class="drop-hint">PDF only · Max 10MB</p>
+      <div class="file-chip" id="jdChip" style="display:none;">
+        <span class="chip-icon">📋</span>
+        <span class="chip-name" id="jdChipName"></span>
+        <button class="chip-remove" onclick="clearFile('jd')">✕</button>
+      </div>
+      <div class="extract-status" id="jdStatus"></div>
+    </div>
+  </div>
+
+  <!-- Text mode -->
+  <div id="jdTextMode" style="display:none;">
+    <textarea id="jdTextarea" placeholder="Paste the job description here — requirements, responsibilities, qualifications..."></textarea>
+    <div class="char-count" id="jdCharCount">0 characters</div>
+  </div>
+</div>
+
+  </div><!-- /.input-grid -->
+
+  <div class="preview-section">
+    <div class="preview-col">
+      <button class="btn-preview" id="resumePreviewBtn" onclick="togglePreview('resume')" style="display:none;">👁 Preview resume text</button>
+      <div class="text-preview" id="resumePreview" style="display:none;"></div>
+    </div>
+    <div class="preview-col">
+      <button class="btn-preview" id="jdPreviewBtn" onclick="togglePreview('jd')" style="display:none;">👁 Preview JD text</button>
+      <div class="text-preview" id="jdPreview" style="display:none;"></div>
+    </div>
+  </div>
+
+  <div class="action-row">
+    <button class="btn-analyze" id="analyzeBtn" onclick="analyze()">
+      <div class="spinner" id="spinner"></div>
+      <span id="btnLabel">Run Analysis</span>
+    </button>
+    <button class="btn-clear" onclick="clearAll()">Clear All</button>
+    <span class="status-text" id="statusText"></span>
+  </div>
+
+  <div class="error-box" id="errorBox"></div>
+
+  <div id="results">
+    <div class="results-header">
+      <h2>Analysis Results</h2>
+      <div class="divider"></div>
+    </div>
+    <div class="score-grid">
+      <div class="score-card main">
+        <div class="score-label">Final ATS Score</div>
+        <div class="score-value" id="finalScore">—<span class="score-unit">/100</span></div>
+        <div class="score-bar-mini"><div class="score-bar-mini-fill bar-purple" id="finalMiniBar"></div></div>
+      </div>
+      <div class="score-card">
+        <div class="score-label">Semantic Match</div>
+        <div class="score-value" id="semanticScore">—<span class="score-unit">/100</span></div>
+        <div class="score-bar-mini"><div class="score-bar-mini-fill bar-teal" id="semanticMiniBar"></div></div>
+      </div>
+      <div class="score-card">
+        <div class="score-label">Keyword Match</div>
+        <div class="score-value" id="keywordScore">—<span class="score-unit">/100</span></div>
+        <div class="score-bar-mini"><div class="score-bar-mini-fill bar-gray" id="keywordMiniBar"></div></div>
+      </div>
+    </div>
+    <div class="bars-card">
+      <div class="bars-title">Score Breakdown</div>
+      <div class="bar-item">
+        <div class="bar-meta"><span class="bar-name">Final ATS Score</span><span class="bar-pct" id="finalPct">0%</span></div>
+        <div class="bar-track"><div class="bar-fill bar-purple" id="finalBar"></div></div>
+      </div>
+      <div class="bar-item">
+        <div class="bar-meta"><span class="bar-name">Semantic Similarity</span><span class="bar-pct" id="semanticPct">0%</span></div>
+        <div class="bar-track"><div class="bar-fill bar-teal" id="semanticBar"></div></div>
+      </div>
+      <div class="bar-item">
+        <div class="bar-meta"><span class="bar-name">Keyword Match</span><span class="bar-pct" id="keywordPct">0%</span></div>
+        <div class="bar-track"><div class="bar-fill bar-gray" id="keywordBar"></div></div>
+      </div>
+    </div>
+    <div class="feedback-card">
+      <div class="feedback-header">
+        <span class="feedback-title">AI Feedback</span>
+        <span class="feedback-model">allenai/OLMo-3-7B</span>
+      </div>
+      <div class="feedback-body" id="feedbackBody">Generating feedback...</div>
+    </div>
+  </div>
+
+  <footer>
+    <p>Powered by FastAPI · SentenceTransformers · OLMo-3-7B · PDF.js</p>
+    <p>localhost:8000/predict/ats</p>
+  </footer>
+
+</div>
+<script src="app.js"></script>
+</body>
+</html>

Frontend/style.css

@@ -0,0 +1,367 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg: #0a0a0f;
+  --surface: #12121a;
+  --surface2: #1a1a26;
+  --border: rgba(255,255,255,0.07);
+  --border-bright: rgba(255,255,255,0.15);
+  --accent: #7c6fff;
+  --accent2: #3dffc0;
+  --accent3: #ff6b6b;
+  --text: #f0eefd;
+  --muted: #7a7890;
+  --font-display: 'Syne', sans-serif;
+  --font-mono: 'DM Mono', monospace;
+}
+
+html { scroll-behavior: smooth; }
+
+body {
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--font-display);
+  min-height: 100vh;
+  overflow-x: hidden;
+}
+
+body::before {
+  content: '';
+  position: fixed; inset: 0;
+  background-image:
+    linear-gradient(rgba(124,111,255,0.04) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(124,111,255,0.04) 1px, transparent 1px);
+  background-size: 40px 40px;
+  pointer-events: none;
+  z-index: 0;
+}
+
+.glow-orb { position: fixed; border-radius: 50%; filter: blur(120px); pointer-events: none; z-index: 0; }
+.glow-orb.a { width: 500px; height: 500px; background: rgba(124,111,255,0.12); top: -100px; left: -100px; }
+.glow-orb.b { width: 400px; height: 400px; background: rgba(61,255,192,0.07); bottom: -100px; right: -100px; }
+
+.container { position: relative; z-index: 1; max-width: 960px; margin: 0 auto; padding: 0 24px 80px; }
+
+/* HEADER */
+header {
+  padding: 48px 0 40px;
+  display: flex; align-items: flex-start; justify-content: space-between;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 48px;
+}
+.logo-mark { display: flex; align-items: center; gap: 12px; }
+.logo-icon {
+  width: 36px; height: 36px;
+  border: 1.5px solid var(--accent);
+  border-radius: 8px;
+  display: flex; align-items: center; justify-content: center;
+  position: relative; overflow: hidden;
+}
+.logo-icon::after {
+  content: '';
+  position: absolute;
+  width: 18px; height: 18px;
+  background: var(--accent);
+  clip-path: polygon(0 100%, 50% 0, 100% 100%);
+  opacity: 0.8;
+}
+.logo-text { font-size: 15px; font-weight: 700; letter-spacing: 0.12em; text-transform: uppercase; color: var(--text); }
+.logo-text span { color: var(--accent); }
+.badge {
+  background: rgba(124,111,255,0.12);
+  border: 1px solid rgba(124,111,255,0.25);
+  color: var(--accent);
+  font-family: var(--font-mono);
+  font-size: 11px; padding: 5px 12px;
+  border-radius: 999px; letter-spacing: 0.05em;
+}
+
+/* HERO */
+.hero { margin-bottom: 48px; }
+.hero h1 { font-size: clamp(36px, 5vw, 56px); font-weight: 800; line-height: 1.05; letter-spacing: -0.02em; margin-bottom: 16px; }
+.hero h1 .line2 { display: block; background: linear-gradient(90deg, var(--accent), var(--accent2)); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+.hero p { font-family: var(--font-mono); font-size: 14px; color: var(--muted); max-width: 520px; line-height: 1.7; }
+
+/* INPUT GRID */
+.input-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-bottom: 16px; }
+.field-wrap { display: flex; flex-direction: column; gap: 8px; }
+.field-label {
+  font-family: var(--font-mono); font-size: 11px; font-weight: 500;
+  color: var(--muted); text-transform: uppercase; letter-spacing: 0.1em;
+  display: flex; align-items: center; gap: 6px;
+}
+.field-label::before { content: ''; display: inline-block; width: 6px; height: 6px; border-radius: 50%; background: var(--accent); }
+.jd-label::before { background: var(--accent2); }
+
+/* DROP ZONE */
+.drop-zone {
+  background: var(--surface);
+  border: 1.5px dashed rgba(124,111,255,0.25);
+  border-radius: 14px;
+  min-height: 220px;
+  display: flex; flex-direction: column; align-items: center; justify-content: center;
+  padding: 28px 20px; gap: 6px;
+  cursor: pointer;
+  transition: border-color 0.2s, background 0.2s;
+  text-align: center;
+  position: relative;
+}
+.drop-zone:hover { border-color: var(--accent); background: rgba(124,111,255,0.04); }
+.drop-zone.drag-over { border-color: var(--accent); background: rgba(124,111,255,0.08); }
+.drop-zone.has-file { border-style: solid; border-color: rgba(124,111,255,0.4); }
+
+.jd-zone { border-color: rgba(61,255,192,0.2); }
+.jd-zone:hover { border-color: var(--accent2); background: rgba(61,255,192,0.04); }
+.jd-zone.drag-over { border-color: var(--accent2); background: rgba(61,255,192,0.06); }
+.jd-zone.has-file { border-color: rgba(61,255,192,0.4); }
+
+.drop-icon { color: var(--muted); margin-bottom: 4px; }
+.drop-title { font-size: 14px; font-weight: 600; color: var(--text); }
+.drop-sub { font-family: var(--font-mono); font-size: 12px; color: var(--muted); }
+.drop-link { color: var(--accent); cursor: pointer; text-decoration: underline; }
+.jd-zone .drop-link { color: var(--accent2); }
+.drop-hint { font-family: var(--font-mono); font-size: 11px; color: rgba(122,120,144,0.5); margin-top: 2px; }
+
+/* FILE CHIP */
+.file-chip {
+  display: flex; align-items: center; gap: 8px;
+  background: rgba(124,111,255,0.1);
+  border: 1px solid rgba(124,111,255,0.25);
+  border-radius: 8px;
+  padding: 8px 12px;
+  margin-top: 10px;
+  width: 100%;
+  max-width: 280px;
+}
+.chip-icon { font-size: 16px; }
+.chip-name { font-family: var(--font-mono); font-size: 12px; color: var(--text); flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.chip-remove { background: none; border: none; color: var(--muted); cursor: pointer; font-size: 13px; padding: 0 2px; }
+.chip-remove:hover { color: var(--accent3); }
+
+/* EXTRACT STATUS */
+.extract-status { font-family: var(--font-mono); font-size: 11px; color: var(--accent2); margin-top: 6px; min-height: 16px; }
+.extract-status.error { color: var(--accent3); }
+
+/* PREVIEW */
+.preview-row { display: flex; gap: 12px; margin-bottom: 12px; flex-wrap: wrap; }
+.btn-preview {
+  background: rgba(255,255,255,0.04);
+  border: 1px solid var(--border-bright);
+  border-radius: 8px;
+  padding: 7px 14px;
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: var(--muted);
+  cursor: pointer;
+  transition: color 0.2s, border-color 0.2s;
+}
+.btn-preview:hover { color: var(--text); border-color: rgba(255,255,255,0.25); }
+
+.text-preview {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 14px 16px;
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: rgba(240,238,253,0.6);
+  line-height: 1.7;
+  max-height: 160px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  margin-bottom: 12px;
+}
+
+/* ACTION ROW */
+.action-row { display: flex; align-items: center; gap: 12px; margin-bottom: 40px; margin-top: 8px; }
+.btn-analyze {
+  background: var(--accent); color: #fff; border: none; border-radius: 10px;
+  padding: 13px 28px; font-family: var(--font-display); font-size: 14px; font-weight: 700;
+  letter-spacing: 0.04em; cursor: pointer;
+  transition: transform 0.15s, box-shadow 0.15s, opacity 0.15s;
+  box-shadow: 0 4px 24px rgba(124,111,255,0.35);
+  display: flex; align-items: center; gap: 8px;
+}
+.btn-analyze:hover { transform: translateY(-1px); box-shadow: 0 6px 32px rgba(124,111,255,0.5); }
+.btn-analyze:active { transform: scale(0.98); }
+.btn-analyze:disabled { opacity: 0.45; cursor: not-allowed; transform: none; }
+.btn-clear {
+  background: transparent; border: 1px solid var(--border-bright); border-radius: 10px;
+  padding: 13px 20px; font-family: var(--font-display); font-size: 14px; font-weight: 500;
+  color: var(--muted); cursor: pointer; transition: border-color 0.2s, color 0.2s;
+}
+.btn-clear:hover { border-color: rgba(255,255,255,0.25); color: var(--text); }
+.status-text { font-family: var(--font-mono); font-size: 12px; color: var(--muted); }
+
+/* SPINNER */
+.spinner { width: 14px; height: 14px; border: 2px solid rgba(255,255,255,0.3); border-top-color: #fff; border-radius: 50%; animation: spin 0.7s linear infinite; display: none; }
+.spinner.active { display: block; }
+@keyframes spin { to { transform: rotate(360deg); } }
+
+/* ERROR */
+.error-box { display: none; background: rgba(255,107,107,0.08); border: 1px solid rgba(255,107,107,0.25); border-radius: 10px; padding: 14px 18px; font-family: var(--font-mono); font-size: 13px; color: var(--accent3); margin-bottom: 24px; }
+.error-box.show { display: block; }
+
+/* RESULTS */
+#results { display: none; }
+#results.show { display: block; animation: fadeUp 0.4s ease; }
+@keyframes fadeUp { from { opacity: 0; transform: translateY(16px); } to { opacity: 1; transform: translateY(0); } }
+
+.results-header { display: flex; align-items: center; gap: 12px; margin-bottom: 28px; }
+.results-header h2 { font-size: 18px; font-weight: 700; letter-spacing: -0.01em; }
+.results-header .divider { flex: 1; height: 1px; background: var(--border); }
+
+/* SCORE CARDS */
+.score-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; margin-bottom: 28px; }
+.score-card { background: var(--surface); border: 1px solid var(--border); border-radius: 14px; padding: 20px; position: relative; overflow: hidden; transition: border-color 0.2s; }
+.score-card:hover { border-color: var(--border-bright); }
+.score-card.main { border-color: rgba(124,111,255,0.3); background: linear-gradient(135deg, rgba(124,111,255,0.08), var(--surface)); }
+.score-card.main::before { content: ''; position: absolute; top: 0; right: 0; width: 60px; height: 60px; background: radial-gradient(circle at top right, rgba(124,111,255,0.2), transparent 70%); }
+.score-label { font-family: var(--font-mono); font-size: 10px; font-weight: 500; text-transform: uppercase; letter-spacing: 0.1em; color: var(--muted); margin-bottom: 10px; }
+.score-value { font-size: 42px; font-weight: 800; line-height: 1; letter-spacing: -0.02em; color: var(--text); }
+.score-card.main .score-value { color: var(--accent); }
+.score-unit { font-size: 18px; font-weight: 400; color: var(--muted); margin-left: 2px; }
+.score-bar-mini { margin-top: 14px; height: 3px; background: rgba(255,255,255,0.07); border-radius: 2px; overflow: hidden; }
+.score-bar-mini-fill { height: 100%; border-radius: 2px; width: 0%; transition: width 0.8s cubic-bezier(0.16, 1, 0.3, 1); }
+.bar-purple { background: var(--accent); }
+.bar-teal   { background: var(--accent2); }
+.bar-gray   { background: rgba(255,255,255,0.4); }
+
+/* BARS */
+.bars-card { background: var(--surface); border: 1px solid var(--border); border-radius: 14px; padding: 24px; margin-bottom: 20px; }
+.bars-title { font-family: var(--font-mono); font-size: 11px; font-weight: 500; text-transform: uppercase; letter-spacing: 0.1em; color: var(--muted); margin-bottom: 20px; }
+.bar-item { margin-bottom: 18px; }
+.bar-item:last-child { margin-bottom: 0; }
+.bar-meta { display: flex; justify-content: space-between; align-items: baseline; margin-bottom: 8px; }
+.bar-name { font-size: 13px; font-weight: 600; color: var(--text); }
+.bar-pct { font-family: var(--font-mono); font-size: 13px; color: var(--muted); }
+.bar-track { height: 8px; background: rgba(255,255,255,0.05); border-radius: 4px; overflow: hidden; }
+.bar-fill { height: 100%; border-radius: 4px; width: 0%; transition: width 0.9s cubic-bezier(0.16, 1, 0.3, 1); }
+
+/* FEEDBACK */
+.feedback-card { background: var(--surface); border: 1px solid var(--border); border-radius: 14px; padding: 24px; }
+.feedback-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 20px; padding-bottom: 16px; border-bottom: 1px solid var(--border); }
+.feedback-title { font-size: 14px; font-weight: 700; letter-spacing: 0.02em; display: flex; align-items: center; gap: 8px; }
+.feedback-title::before { content: ''; display: inline-block; width: 8px; height: 8px; background: var(--accent2); border-radius: 50%; animation: pulse 2s ease-in-out infinite; }
+@keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.3; } }
+.feedback-model { font-family: var(--font-mono); font-size: 10px; color: var(--muted); background: rgba(255,255,255,0.04); border: 1px solid var(--border); padding: 4px 10px; border-radius: 6px; }
+.feedback-body { font-family: var(--font-mono); font-size: 13px; line-height: 1.85; color: rgba(240,238,253,0.8); white-space: pre-wrap; }
+
+/* FOOTER */
+footer { margin-top: 64px; padding-top: 24px; border-top: 1px solid var(--border); display: flex; justify-content: space-between; align-items: center; }
+footer p { font-family: var(--font-mono); font-size: 11px; color: var(--muted); }
+
+/* RESPONSIVE */
+@media (max-width: 640px) {
+  .input-grid { grid-template-columns: 1fr; }
+  .score-grid { grid-template-columns: 1fr; }
+  header { flex-direction: column; gap: 16px; }
+}
+/* INPUT MODE TOGGLE */
+.input-toggle {
+  display: flex;
+  gap: 6px;
+  margin-bottom: 10px;
+}
+.toggle-btn {
+  background: transparent;
+  border: 1px solid var(--border-bright);
+  border-radius: 8px;
+  padding: 6px 14px;
+  font-family: var(--font-mono);
+  font-size: 12px;
+  color: var(--muted);
+  cursor: pointer;
+  transition: all 0.2s;
+}
+.toggle-btn:hover { color: var(--text); border-color: rgba(255,255,255,0.25); }
+.toggle-btn.active {
+  background: rgba(61,255,192,0.1);
+  border-color: rgba(61,255,192,0.35);
+  color: var(--accent2);
+}
+
+/* JD TEXTAREA (text mode) */
+#jdTextarea {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  color: var(--text);
+  font-family: var(--font-mono);
+  font-size: 13px;
+  line-height: 1.7;
+  padding: 16px;
+  resize: vertical;
+  height: 207px;
+  width: 100%;
+  transition: border-color 0.2s, box-shadow 0.2s;
+  outline: none;
+}
+#jdTextarea::placeholder { color: rgba(120,116,145,0.5); }
+#jdTextarea:focus {
+  border-color: var(--accent2);
+  box-shadow: 0 0 0 3px rgba(61,255,192,0.08);
+}
+
+.char-count {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--muted);
+  text-align: right;
+  margin-top: 6px;
+}
+/* RESUME TEXTAREA (text mode) — mirrors JD textarea with purple accent */
+#resumeTextarea {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  color: var(--text);
+  font-family: var(--font-mono);
+  font-size: 13px;
+  line-height: 1.7;
+  padding: 16px;
+  resize: vertical;
+  height: 207px;
+  width: 100%;
+  transition: border-color 0.2s, box-shadow 0.2s;
+  outline: none;
+}
+#resumeTextarea::placeholder { color: rgba(120,116,145,0.5); }
+#resumeTextarea:focus {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px rgba(124,111,255,0.08);
+}
+
+/* PREVIEW SECTION — side-by-side, aligned to input grid columns */
+.preview-section {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+  margin-top: 4px;
+  margin-bottom: 16px;
+}
+.preview-col {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+}
+.preview-col .btn-preview { align-self: flex-start; }
+.preview-col .text-preview { margin-bottom: 0; }
+
+@media (max-width: 640px) {
+  .preview-section { grid-template-columns: 1fr; }
+}
+
+/* FOOTER — centered text, tidy bottom padding */
+footer {
+  margin-top: 64px;
+  padding: 24px 0 32px;
+  border-top: 1px solid var(--border);
+  display: flex !important;
+  flex-direction: column !important;
+  align-items: center !important;
+  justify-content: center !important;
+  gap: 6px;
+  text-align: center;
+}

README.md

@@ -0,0 +1,171 @@
+---
+title: ATS Resume Intelligence Engine
+emoji: 📄
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+suggested_hardware: cpu-upgrade
+---
+
+# ATS Intelligence Engine
+
+<p align="center">
+  <b>An AI-powered Applicant Tracking System that scores resumes against job descriptions using semantic similarity.</b><br>
+  Built with FastAPI, LangChain, and Hugging Face — deployable as a Docker Space.
+</p>
+
+---
+
+## Features
+
+* Upload resume & job description (PDF or text)
+* Extract text using PyMuPDF
+* Semantic similarity via Sentence Transformers
+* Keyword matching for skill overlap
+* Final ATS score with LangChain + Hugging Face LLM feedback
+* REST API built with FastAPI
+* Docker Space ready (port **7860**)
+
+---
+
+## Tech Stack
+
+| Layer            | Technology                          |
+| ---------------- | ----------------------------------- |
+| Backend          | FastAPI, Uvicorn                    |
+| ML / Embeddings  | Sentence Transformers, Scikit-learn |
+| LLM / Feedback   | LangChain, Hugging Face Inference API |
+| PDF Parsing      | PyMuPDF                             |
+| Frontend         | HTML / JS (served by FastAPI)       |
+| Deployment       | Docker, Hugging Face Spaces         |
+
+---
+
+## Deploy on Hugging Face Spaces (Docker)
+
+### 1. Create a new Space
+
+1. Go to [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Choose **Docker** as the SDK
+3. Pick a name (e.g. `ats-resume-intelligence`)
+4. Hardware: **CPU upgrade** (recommended for Sentence Transformers)
+
+### 2. Push this repository
+
+```bash
+git remote add space https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+git push space main
+```
+
+Or clone the empty Space repo and copy these files into it, then commit and push.
+
+### 3. Add your Hugging Face token (required for AI feedback)
+
+In the Space → **Settings** → **Repository secrets**, add:
+
+| Secret name | Value |
+| ----------- | ----- |
+| `HF_TOKEN`  | Your Hugging Face access token ([create one](https://huggingface.co/settings/tokens)) with **Inference** permission |
+
+The Space will rebuild automatically after you push or add secrets.
+
+### 4. Open your live app
+
+Your Space URL will be:
+
+`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+
+The UI and API run on the same origin (port 7860), so no CORS or proxy setup is needed.
+
+---
+
+## Run locally with Docker
+
+### Prerequisites
+
+* Docker
+* Hugging Face API token
+
+### Setup
+
+Create a `.env` file:
+
+```env
+HF_TOKEN=your_huggingface_token_here
+```
+
+### Start
+
+```bash
+docker compose up --build
+```
+
+Open **http://localhost:7860**
+
+---
+
+## API Endpoints
+
+### `POST /predict/ats` — JSON
+
+```json
+{
+  "resume_text": "...",
+  "job_description": "..."
+}
+```
+
+### `POST /predict/ats/upload` — multipart
+
+| Field           | Type   | Description          |
+| --------------- | ------ | -------------------- |
+| resume_pdf      | File   | Resume PDF           |
+| resume_text     | string | Resume text          |
+| jd_pdf          | File   | Job description PDF  |
+| job_description | string | Job description text |
+
+### Response
+
+```json
+{
+  "semantic_score": 0.82,
+  "keyword_score": 0.74,
+  "final_ats_score": 0.79,
+  "summary": "..."
+}
+```
+
+### `GET /health` — health check
+
+---
+
+## Development (without Docker)
+
+```bash
+pip install -r requirements.txt
+set HF_TOKEN=your_token_here
+uvicorn main:app --reload --port 7860
+```
+
+For local dev without the Space URL, in `Frontend/app.js` set:
+
+```js
+const API = 'http://localhost:7860';
+```
+
+---
+
+## Environment variables
+
+| Variable | Description |
+| -------- | ----------- |
+| `HF_TOKEN` | Hugging Face API token (Space secret or `.env`) |
+
+---
+
+## License
+
+MIT License

docker-compose.yml

@@ -0,0 +1,10 @@
+# Local run — mirrors Hugging Face Spaces (single container, port 7860)
+services:
+  app:
+    build: .
+    container_name: ats_app
+    ports:
+      - "7860:7860"
+    environment:
+      - HF_TOKEN=${HF_TOKEN}
+    restart: unless-stopped

main.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from routes import router as predict_router
+
+FRONTEND_DIR = Path(__file__).resolve().parent / "Frontend"
+
+app = FastAPI(title="ATS Resume Intelligence Engine")
+app.include_router(predict_router)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+if FRONTEND_DIR.is_dir():
+    app.mount("/", StaticFiles(directory=FRONTEND_DIR, html=True), name="frontend")

nginx.conf

@@ -0,0 +1,23 @@
+server {
+    listen 80;
+    client_max_body_size 10M;
+
+    # Serve frontend files
+    location / {
+        root /usr/share/nginx/html;
+        index index.html;
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Proxy API calls to FastAPI backend
+    location /predict/ {
+        proxy_pass http://backend:8000;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 300s;
+        proxy_connect_timeout 60s;
+    }
+}

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn[standard]
+sentence-transformers
+scikit-learn
+PyMuPDF
+huggingface-hub
+pydantic
+python-multipart
+langchain
+langchain-core
+langchain-huggingface

routes.py

@@ -0,0 +1,56 @@
+# routes.py
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from typing import Optional
+from schemas import ScoreResponse, ScoreRequest
+from services.scorer import resume_score
+from utilities.pdf_parser import extract_text_from_pdf
+from utilities.keyword_match import clean_text
+
+router = APIRouter(prefix="/predict", tags=["Prediction"])
+
+
+# ── JSON route (both inputs are plain text) ────────────────────────────────
+@router.post("/ats", response_model=ScoreResponse)
+async def predict_ats_json(payload: ScoreRequest):
+    resume_clean = clean_text(payload.resume_text)
+    jd_clean     = clean_text(payload.job_description)
+    return resume_score(resume_clean, jd_clean)
+
+
+# ── Multipart route (one or both inputs are PDFs) ─────────────────────────
+@router.post("/ats/upload", response_model=ScoreResponse)
+async def predict_ats_upload(
+    resume_pdf:    Optional[UploadFile] = File(None,  description="Resume PDF (optional)"),
+    jd_pdf:        Optional[UploadFile] = File(None,  description="JD PDF (optional)"),
+    resume_text:   Optional[str]        = Form(None,  description="Resume plain text (optional)"),
+    job_description: Optional[str]      = Form(None,  description="JD plain text (optional)"),
+):
+    # ── Resolve resume text ──────────────────────────────────────────────
+    if resume_pdf and resume_pdf.filename:
+        if resume_pdf.content_type != "application/pdf":
+            raise HTTPException(status_code=400, detail="resume_pdf must be a PDF file.")
+        try:
+            resume_raw = extract_text_from_pdf(await resume_pdf.read())
+        except ValueError as e:
+            raise HTTPException(status_code=422, detail=str(e))
+    elif resume_text:
+        resume_raw = resume_text
+    else:
+        raise HTTPException(status_code=422, detail="Provide either resume_pdf or resume_text.")
+
+    # ── Resolve JD text ──────────────────────────────────────────────────
+    if jd_pdf and jd_pdf.filename:
+        if jd_pdf.content_type != "application/pdf":
+            raise HTTPException(status_code=400, detail="jd_pdf must be a PDF file.")
+        try:
+            jd_raw = extract_text_from_pdf(await jd_pdf.read())
+        except ValueError as e:
+            raise HTTPException(status_code=422, detail=str(e))
+    elif job_description:
+        jd_raw = job_description
+    else:
+        raise HTTPException(status_code=422, detail="Provide either jd_pdf or job_description.")
+
+    resume_clean = clean_text(resume_raw)
+    jd_clean     = clean_text(jd_raw)
+    return resume_score(resume_clean, jd_clean)

schemas.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+class ScoreRequest(BaseModel):
+    resume_text: str
+    job_description: str
+
+class ScoreResponse(BaseModel):
+    semantic_score: float
+    keyword_score: float
+    final_ats_score: float
+    summary: str
+

services/feedback.py

@@ -0,0 +1,48 @@
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from .llm import get_llm
+
+SYSTEM_PROMPT = """You are an ATS resume analyst.
+
+You MUST base your feedback ONLY on:
+- The provided ATS scores
+- The detected gaps
+
+DO NOT invent missing skills.
+DO NOT give generic advice.
+DO NOT mention motivation, confidence, or mindset.
+
+Write a concise analysis with exactly 3 sections:
+1. Score Explanation
+2. Weak Areas
+3. Actionable Improvements
+
+Keep it under 500 words."""
+
+
+def generate_resume_feedback(scores: dict, gaps: dict) -> str:
+    user_prompt = f"""ATS Scores:
+Semantic: {scores['semantic_score']}
+Keyword: {scores['keyword_score']}
+Final: {scores['final_ats_score']}
+
+Detected Gaps:
+Missing Keywords: {gaps['missing_keywords']}
+Skill Overlap: {gaps['skill_overlap_percentage']}%
+
+Provide the 3-section analysis now."""
+
+    try:
+        response = get_llm().invoke(
+            [
+                SystemMessage(content=SYSTEM_PROMPT),
+                HumanMessage(content=user_prompt),
+            ]
+        )
+        content = response.content
+        if isinstance(content, str) and content.strip():
+            return content.strip()
+    except Exception:
+        pass
+
+    return "Feedback generation failed."

services/llm.py

@@ -0,0 +1,47 @@
+import os
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_huggingface import ChatHuggingFace
+
+MODEL_ID = "allenai/Olmo-3-7B-Instruct"
+
+_chat_model: ChatHuggingFace | None = None
+
+
+def get_llm() -> ChatHuggingFace:
+    """Return a shared ChatHuggingFace client (Hugging Face Inference API via LangChain)."""
+    global _chat_model
+    if _chat_model is None:
+        token = (
+            os.environ.get("HF_TOKEN")
+            or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+            or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+        )
+        if not token:
+            raise ValueError(
+                "HF_TOKEN is not set. Add it as a Space secret or in your local .env file."
+            )
+        _chat_model = ChatHuggingFace(
+            model=MODEL_ID,
+            token=token,
+            temperature=0.2,
+            max_tokens=512,
+        )
+    return _chat_model
+
+
+if __name__ == "__main__":
+    llm = get_llm()
+    response = llm.invoke(
+        [
+            SystemMessage(content="You are an ATS resume analyst."),
+            HumanMessage(
+                content=(
+                    "ATS Scores: Semantic 0.45, Keyword 0.70, Final 0.68. "
+                    "Missing: api, tensorflow, docker. Skill overlap: 70%. "
+                    "Write 3 short sections: Score Explanation, Weak Areas, Actionable Improvements."
+                )
+            ),
+        ]
+    )
+    print(response.content)

services/scorer.py

@@ -0,0 +1,75 @@
+from utilities.keyword_match import final_ats_score, experience_level_penalty
+from utilities.skills import (
+    find_missing_skills,
+    calculate_skill_overlap,
+    extract_resume_skills,
+    extract_required_skills_from_jd,
+    clean_text,
+)
+from services.feedback import generate_resume_feedback
+
+
+# ---------------------------------------------------------------------------
+# Gap analysis
+# ---------------------------------------------------------------------------
+
+def extract_gaps(resume_text: str, jd_text: str) -> dict:
+    """
+    Builds a structured gap report used both for the LLM feedback prompt
+    and for any structured API response fields you add later.
+
+    Fields
+    ------
+    missing_keywords        Top-10 skills in JD that are absent from resume.
+    skill_overlap_pct       % of JD skills present in resume.
+    matched_skills          Skills the candidate already has that JD wants.
+    high_priority_missing   Missing skills that appear more than once in JD
+                            (JD emphasises them → higher impact gaps).
+    seniority_penalty       Penalty points from experience-level mismatch.
+    """
+    missing          = find_missing_skills(resume_text, jd_text)
+    overlap          = calculate_skill_overlap(resume_text, jd_text)
+    resume_skills    = extract_resume_skills(resume_text)
+    jd_skills_freq   = extract_required_skills_from_jd(jd_text)
+
+    matched = sorted(resume_skills & set(jd_skills_freq.keys()))
+
+    # Skills the JD mentions more than once — candidate should prioritise these
+    high_priority_missing = [
+        skill for skill in missing
+        if jd_skills_freq.get(skill, 0) > 1
+    ]
+
+    penalty = experience_level_penalty(resume_text, jd_text)
+
+    return {
+        "missing_keywords":       missing[:10],
+        "skill_overlap_percentage": overlap,
+        "matched_skills":         matched,
+        "high_priority_missing":  high_priority_missing[:5],
+        "seniority_penalty":      penalty,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Main scoring entry point
+# ---------------------------------------------------------------------------
+
+def resume_score(resume_text: str, jd_text: str) -> dict:
+    """
+    Orchestrates scoring → gap analysis → LLM feedback.
+
+    Returns a dict matching ScoreResponse schema plus a 'summary' field.
+    """
+    resume_clean = clean_text(resume_text)
+    jd_clean     = clean_text(jd_text)
+
+    scores = final_ats_score(resume_clean, jd_clean)
+    gaps   = extract_gaps(resume_clean, jd_clean)
+
+    feedback = generate_resume_feedback(scores, gaps)
+
+    return {
+        **scores,
+        "summary": feedback,
+    }

utilities/keyword_match.py

@@ -0,0 +1,205 @@
+import re
+from sklearn.metrics.pairwise import cosine_similarity
+from sentence_transformers import SentenceTransformer
+from utilities.skills import (
+    extract_resume_skills,
+    extract_required_skills_from_jd,
+    SKILLS_SORTED_BY_LENGTH,
+    clean_text,
+)
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+
+# ---------------------------------------------------------------------------
+# Stop-word list — common English words that pollute keyword matching
+# ---------------------------------------------------------------------------
+STOP_WORDS: set = {
+    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+    "of", "with", "by", "from", "as", "is", "was", "are", "were", "be",
+    "been", "being", "have", "has", "had", "do", "does", "did", "will",
+    "would", "could", "should", "may", "might", "shall", "can", "need",
+    "that", "this", "these", "those", "it", "its", "we", "our", "you",
+    "your", "they", "their", "he", "she", "his", "her", "i", "my",
+    "not", "no", "so", "if", "then", "than", "also", "just", "only",
+    "about", "up", "out", "over", "into", "through", "during", "including",
+    "used", "use", "using", "work", "working", "works", "strong", "good",
+    "experience", "experiences", "role", "team", "company", "environment",
+    "ability", "skills", "skill", "looking", "required", "requirement",
+    "plus", "bonus", "nice", "preferred", "knowledge", "understanding",
+    "familiarity", "proficiency", "proficient", "hands", "on",
+}
+
+
+# ---------------------------------------------------------------------------
+# Text utilities
+# ---------------------------------------------------------------------------
+
+def extract_skill_sentences(text: str) -> str:
+    """
+    Keep only sentences / bullet points that contain at least one
+    known tech skill. Falls back to the full text if nothing matches
+    (prevents a zero-length embedding).
+    """
+    segments = re.split(r'[.\n;]', text)
+    cleaned_text = clean_text(text)
+    relevant = []
+    for seg in segments:
+        seg_clean = clean_text(seg)
+        if any(skill in seg_clean for skill in SKILLS_SORTED_BY_LENGTH):
+            relevant.append(seg_clean)
+    return " ".join(relevant) if relevant else cleaned_text
+
+
+def remove_stop_words(text: str) -> set:
+    """Return meaningful tokens after removing stop words."""
+    tokens = set(text.split())
+    return tokens - STOP_WORDS
+
+
+# ---------------------------------------------------------------------------
+# Scoring functions
+# ---------------------------------------------------------------------------
+
+def keyword_match_score(resume_text: str, jd_text: str) -> float:
+    """
+    Skill-only keyword match.
+
+    Strategy:
+    - Extract recognised tech skills from both texts using the master taxonomy.
+    - Score = |resume_skills ∩ jd_skills| / |jd_skills|
+    - This eliminates stop-word noise and counts only meaningful tech terms.
+
+    Weighting bonus:
+    - JD skills that appear multiple times are treated as high-priority.
+      A missing high-frequency skill is penalised more heavily.
+    """
+    jd_skills_freq  = extract_required_skills_from_jd(jd_text)   # {skill: freq}
+    resume_skills   = extract_resume_skills(resume_text)
+
+    if not jd_skills_freq:
+        return 0.0
+
+    # Weighted scoring: skills mentioned more in JD carry more weight
+    total_weight   = sum(jd_skills_freq.values())
+    matched_weight = sum(
+        freq for skill, freq in jd_skills_freq.items()
+        if skill in resume_skills
+    )
+
+    return round(matched_weight / total_weight * 100, 2)
+
+
+def semantic_match_score(resume_text: str, jd_text: str) -> float:
+    """
+    Skill-focused semantic similarity.
+
+    Strategy:
+    - Filter both texts down to skill-relevant sentences before encoding.
+    - This focuses the embedding on technical content and reduces noise
+      from generic filler language ("we are a fast-paced team...").
+    """
+    resume_focused = extract_skill_sentences(resume_text)
+    jd_focused     = extract_skill_sentences(jd_text)
+
+    embeddings = model.encode([resume_focused, jd_focused])
+    score = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
+    return round(float(score) * 100, 2)
+
+
+def experience_level_penalty(resume_text: str, jd_text: str) -> float:
+    """
+    Detects seniority mismatch and returns a 0–10 penalty.
+
+    E.g. a senior-level JD matched against a junior resume
+    should score lower even if skills overlap.
+    """
+    SENIOR_SIGNALS = {"senior", "lead", "principal", "architect", "staff", "head of"}
+    JUNIOR_SIGNALS = {"junior", "entry level", "entry-level", "graduate", "intern", "fresher"}
+
+    jd_lower     = jd_text.lower()
+    resume_lower = resume_text.lower()
+
+    jd_is_senior = any(s in jd_lower for s in SENIOR_SIGNALS)
+    jd_is_junior = any(s in jd_lower for s in JUNIOR_SIGNALS)
+
+    resume_is_senior = any(s in resume_lower for s in SENIOR_SIGNALS)
+    resume_is_junior = any(s in resume_lower for s in JUNIOR_SIGNALS)
+
+    # JD wants senior but resume signals junior
+    if jd_is_senior and resume_is_junior:
+        return 10.0
+    # JD wants junior but resume is over-qualified (minor penalty)
+    if jd_is_junior and resume_is_senior:
+        return 3.0
+    return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Final composite score
+# ---------------------------------------------------------------------------
+
+def final_ats_score(resume_text: str, jd_text: str) -> dict:
+    """
+    Composite ATS score weighted as:
+      60%  semantic similarity  (contextual understanding)
+      40%  keyword match        (skill taxonomy match, frequency-weighted)
+
+    A seniority mismatch penalty (0–10 pts) is subtracted from the final score.
+
+    Returns a dict compatible with ScoreResponse schema.
+    """
+    semantic = semantic_match_score(resume_text, jd_text)
+    keyword  = keyword_match_score(resume_text, jd_text)
+    penalty  = experience_level_penalty(resume_text, jd_text)
+
+    raw_score  = round(0.6 * semantic + 0.4 * keyword, 2)
+    final      = round(max(0.0, raw_score - penalty), 2)
+
+    return {
+        "semantic_score":  round(semantic, 2),
+        "keyword_score":   round(keyword, 2),
+        "final_ats_score": final,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Smoke-test
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    examples = [
+        [
+            "Python developer with FastAPI, SQL, and machine learning experience",
+            "Looking for a Python developer with FastAPI, SQL, and ML skills",
+        ],
+        [
+            "Built backend services using Python frameworks and databases",
+            "Python developer with FastAPI and SQL",
+        ],
+        [
+            "Python Python Python SQL SQL FastAPI",
+            "Python developer with FastAPI and SQL",
+        ],
+        [
+            "Professional photographer specialising in portraits and wildlife",
+            "Hiring a machine learning engineer with Python and PyTorch",
+        ],
+        [
+            "Led ML teams, deployed large-scale models, optimised transformers",
+            "Junior Python developer with basic ML",
+        ],
+        [
+            "NLP engineer: PyTorch, HuggingFace transformers, LLM fine-tuning, RAG pipelines",
+            "Senior ML engineer: LLM, RAG, fine-tuning, Python, AWS SageMaker",
+        ],
+    ]
+
+    print(f"{'#':<3} {'Semantic':>10} {'Keyword':>10} {'Final ATS':>10}")
+    print("-" * 38)
+    for i, (resume, jd) in enumerate(examples):
+        result = final_ats_score(resume, jd)
+        print(
+            f"{i:<3} {result['semantic_score']:>10} "
+            f"{result['keyword_score']:>10} "
+            f"{result['final_ats_score']:>10}"
+        )

utilities/pdf_parser.py

@@ -0,0 +1,23 @@
+import fitz  # PyMuPDF
+
+def extract_text_from_pdf(file_bytes: bytes) -> str:
+    """
+    Extract plain text from a PDF given its raw bytes.
+    Joins all pages into a single string.
+    Raises ValueError if the PDF yields no text (e.g. scanned image-only PDF).
+    """
+    doc = fitz.open(stream=file_bytes, filetype="pdf")
+
+    pages_text = []
+    for page in doc:
+        pages_text.append(page.get_text("text"))   # "text" = plain text mode
+
+    full_text = "\n".join(pages_text).strip()
+
+    if not full_text:
+        raise ValueError(
+            "No text could be extracted from the PDF. "
+            "It may be a scanned image. Please upload a text-based PDF."
+        )
+
+    return full_text

utilities/skills.py

@@ -0,0 +1,217 @@
+import re
+
+# ---------------------------------------------------------------------------
+# Tech Skill Taxonomy
+# Multi-word phrases are matched BEFORE single tokens to avoid partial hits.
+# Each category is kept separate so it's easy to extend.
+# ---------------------------------------------------------------------------
+
+# --- Languages ---
+LANGUAGES = {
+    "python", "java", "javascript", "typescript", "golang", "go",
+    "rust", "ruby", "scala", "kotlin", "swift", "php", "r", "matlab",
+    "bash", "shell", "c", "cpp", "c++", "csharp", "c#",
+}
+
+# --- Web Frameworks ---
+WEB_FRAMEWORKS = {
+    "fastapi", "flask", "django", "spring boot", "spring",
+    "express", "nestjs", "nextjs", "nuxtjs", "rails",
+    "laravel", "fiber", "gin",
+}
+
+# --- Frontend ---
+FRONTEND = {
+    "react", "angular", "vue", "svelte", "html", "css",
+    "tailwind", "bootstrap", "redux", "webpack", "vite",
+}
+
+# --- APIs & Architecture ---
+API_ARCH = {
+    "rest api", "restful api", "graphql", "grpc", "websocket",
+    "microservices", "microservice", "event driven", "message queue",
+    "api gateway", "api",
+}
+
+# --- Databases ---
+DATABASES = {
+    "postgresql", "postgres", "mysql", "sqlite", "oracle",
+    "mongodb", "mongo", "redis", "cassandra", "dynamodb",
+    "elasticsearch", "neo4j", "firebase", "supabase",
+    "sql", "nosql", "vector database", "pinecone", "weaviate",
+}
+
+# --- ML / AI / Data Science ---
+ML_AI = {
+    "machine learning", "deep learning", "reinforcement learning",
+    "supervised learning", "unsupervised learning",
+    "natural language processing", "nlp", "computer vision",
+    "large language model", "llm", "generative ai", "gen ai",
+    "transformers", "bert", "gpt", "llama", "mistral",
+    "scikit-learn", "scikit learn", "sklearn",
+    "pytorch", "torch", "tensorflow", "keras", "jax",
+    "hugging face", "huggingface", "langchain", "llamaindex",
+    "xgboost", "lightgbm", "catboost",
+    "pandas", "numpy", "scipy", "matplotlib", "seaborn", "plotly",
+    "mlflow", "mlops", "model serving", "model deployment",
+    "feature engineering", "hyperparameter tuning",
+    "rag", "retrieval augmented generation", "fine tuning", "fine-tuning",
+    "diffusion models", "stable diffusion",
+    "data analysis", "data analytics", "data science",
+    "statistical analysis", "statistics", "probability",
+    "a/b testing", "hypothesis testing",
+}
+
+# --- Data Engineering ---
+DATA_ENGINEERING = {
+    "apache spark", "spark", "hadoop", "kafka", "airflow",
+    "dbt", "flink", "hive", "presto", "trino",
+    "etl", "elt", "data pipeline", "data warehouse",
+    "snowflake", "bigquery", "redshift", "databricks",
+}
+
+# --- Cloud & Infrastructure ---
+CLOUD = {
+    "aws", "amazon web services", "azure", "gcp", "google cloud",
+    "ec2", "s3", "lambda", "sagemaker", "bedrock",
+    "cloudformation", "terraform", "pulumi",
+    "serverless", "cloud functions",
+}
+
+# --- DevOps & CI/CD ---
+DEVOPS = {
+    "docker", "kubernetes", "k8s", "helm",
+    "ci/cd", "ci cd", "github actions", "gitlab ci", "jenkins",
+    "ansible", "chef", "puppet",
+    "linux", "unix", "nginx", "apache",
+    "monitoring", "observability", "prometheus", "grafana",
+    "opentelemetry", "datadog", "new relic",
+}
+
+# --- Version Control & Collaboration ---
+VCS = {
+    "git", "github", "gitlab", "bitbucket", "version control",
+}
+
+# --- System Design & Software Engineering ---
+ENGINEERING = {
+    "system design", "software design", "object oriented", "oop",
+    "design patterns", "solid principles", "clean code",
+    "distributed systems", "high availability", "scalability",
+    "load balancing", "caching", "message broker",
+    "unit testing", "integration testing", "tdd", "bdd",
+    "pytest", "junit", "jest", "mocha",
+    "code review", "agile", "scrum", "kanban",
+}
+
+# --- Security ---
+SECURITY = {
+    "cybersecurity", "penetration testing", "pen testing",
+    "oauth", "jwt", "ssl", "tls", "encryption",
+    "owasp", "security auditing",
+}
+
+# ---------------------------------------------------------------------------
+# Master set — sorted longest-first so multi-word phrases match before tokens
+# ---------------------------------------------------------------------------
+GENERAL_TECH_SKILLS: set = (
+    LANGUAGES | WEB_FRAMEWORKS | FRONTEND | API_ARCH |
+    DATABASES | ML_AI | DATA_ENGINEERING | CLOUD |
+    DEVOPS | VCS | ENGINEERING | SECURITY
+)
+
+# Pre-sorted for greedy multi-word matching (longest phrase wins)
+SKILLS_SORTED_BY_LENGTH: list = sorted(GENERAL_TECH_SKILLS, key=len, reverse=True)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def clean_text(text: str) -> str:
+    text = text.lower()
+    text = re.sub(r'[^a-z0-9\s/]', ' ', text)   # keep / for ci/cd etc.
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+def extract_skills(text: str) -> set:
+    """
+    Greedy left-to-right phrase match.
+    Multi-word skills (e.g. 'machine learning') are checked before
+    their constituent tokens to prevent double-counting.
+    """
+    cleaned = clean_text(text)
+    found: set = set()
+    consumed_positions: set = set()       # char positions already claimed
+
+    for skill in SKILLS_SORTED_BY_LENGTH:
+        start = 0
+        while True:
+            idx = cleaned.find(skill, start)
+            if idx == -1:
+                break
+            end = idx + len(skill)
+
+            # Boundary check — skill must be a whole word / phrase
+            before_ok = (idx == 0 or cleaned[idx - 1] == ' ')
+            after_ok  = (end == len(cleaned) or cleaned[end] == ' ')
+
+            if before_ok and after_ok:
+                span = set(range(idx, end))
+                if not span & consumed_positions:   # no overlap with claimed chars
+                    found.add(skill)
+                    consumed_positions |= span
+                    break           # found this skill, move to next
+
+            start = idx + 1
+
+    return found
+
+
+def extract_required_skills_from_jd(jd_text: str) -> dict:
+    """Return JD skills with mention-frequency as an importance signal."""
+    skills = extract_skills(jd_text)
+    cleaned = clean_text(jd_text)
+    return {skill: cleaned.count(skill) for skill in skills}
+
+
+def extract_resume_skills(resume_text: str) -> set:
+    return extract_skills(resume_text)
+
+
+def find_missing_skills(resume_text: str, jd_text: str) -> list:
+    jd_skills   = set(extract_required_skills_from_jd(jd_text).keys())
+    resume_skills = extract_resume_skills(resume_text)
+    return [s for s in jd_skills if s not in resume_skills]
+
+
+def calculate_skill_overlap(resume_text: str, jd_text: str) -> float:
+    jd_skills     = set(extract_required_skills_from_jd(jd_text).keys())
+    resume_skills = extract_resume_skills(resume_text)
+    if not jd_skills:
+        return 0.0
+    return round(len(jd_skills & resume_skills) / len(jd_skills) * 100, 2)
+
+
+# ---------------------------------------------------------------------------
+# Quick smoke-test
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    resume_text = (
+        "Python, NumPy, Pandas, Scikit-learn, PyTorch, TensorFlow, spaCy. "
+        "Machine Learning, NLP, Feature Engineering, Model Evaluation. "
+        "Flask, FastAPI, Git, GitHub, Linux, MLflow, Docker."
+    )
+    jd_text = (
+        "Machine Learning Engineer. Strong Python. Amazon SageMaker. "
+        "ML model deployment. APIs. GenAI / LLM solutions. "
+        "MLOps: model monitoring, drift detection, retraining. "
+        "Data pipelines. CI/CD. Kubernetes."
+    )
+    clean_r = clean_text(resume_text)
+    clean_j = clean_text(jd_text)
+    print("Missing skills :", find_missing_skills(clean_r, clean_j))
+    print("Skill overlap  :", calculate_skill_overlap(clean_r, clean_j), "%")
+    print("Resume skills  :", extract_resume_skills(clean_r))
+    print("JD skills      :", set(extract_required_skills_from_jd(clean_j).keys()))