Accurate LLM CV parsing + realistic, memory-aware interview

CV parsing (resume_parser.py, app.py):
- Parse resumes with the Groq LLM (clean name/skills/education/experience JSON),
far more accurate than the old keyword/regex heuristics; keep the regex/NER
path as a lazy fallback so startup no longer loads the heavy NER model
- Auto-parse the uploaded CV on apply and populate the profile (manual form
fields still override), so an ATS-friendly CV "just works"

Interview realism (interview_engine.py, interview_api.py):
- Give follow-ups real memory: pass the persisted interview_log as
conversation_history (the frontend never sent it)
- Evaluate answers at the real job role + seniority instead of a generic default
- Enrich prompts with job skills/seniority/description; LUNA now acknowledges the
last answer and asks one focused, contextual follow-up
- Fix an empty-experience IndexError that silently dropped the first question

Also includes earlier deploy hardening: env-driven SECRET_KEY/FLASK_DEBUG and
removal of a duplicate generate_next_question definition.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app.py

@@ -56,7 +56,7 @@ app = Flask(
     instance_path=safe_instance_path
 )
 
-app.config['SECRET_KEY'] = 'saadi'
+app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'saadi')
 
 # Cookie configuration for Hugging Face Spaces
 app.config['SESSION_COOKIE_SAMESITE'] = 'None'
@@ -144,13 +144,32 @@ def apply(job_id):
             "education": parse_entries(education_input)
         }
 
+        # Auto-parse the uploaded CV so the candidate's profile reflects their
+        # real resume even when the form fields are left blank.  Anything the
+        # user typed manually takes precedence; otherwise we use the parsed CV.
+        parsed_features = {"skills": [], "experience": [], "education": []}
+        try:
+            if filepath:
+                parsed = _parse_resume_helper(filepath, file.filename)
+                for key in parsed_features:
+                    value = parsed.get(key, '')
+                    if value and value != "Not Found":
+                        parsed_features[key] = parse_entries(value)
+        except Exception as parse_err:
+            print(f"Auto CV parse failed: {parse_err}", file=sys.stderr)
+
+        merged_features = {
+            key: (manual_features[key] if manual_features[key] else parsed_features[key])
+            for key in manual_features
+        }
+
         application = Application(
             job_id=job_id,
             user_id=current_user.id,
             name=current_user.username,
             email=current_user.email,
             resume_path=filepath,
-            extracted_features=json.dumps(manual_features)
+            extracted_features=json.dumps(merged_features)
         )
 
         db.session.add(application)
@@ -399,4 +418,7 @@ if __name__ == '__main__':
     
     # Use port from environment or default to 7860
     port = int(os.environ.get('PORT', 7860))
-    app.run(debug=True, host='0.0.0.0', port=port)
+    # Debug mode is off by default (safe for the deployed Space); enable it
+    # locally by setting FLASK_DEBUG=1.
+    debug = os.environ.get('FLASK_DEBUG', '0') == '1'
+    app.run(debug=debug, host='0.0.0.0', port=port)

backend/routes/interview_api.py

@@ -212,45 +212,55 @@ def process_answer():
         # Get the current question for evaluation context
         current_question = data.get("current_question", "Tell me about yourself")
 
-        # Evaluate the answer
-        evaluation_result = evaluate_answer(current_question, answer)
-
-                # 🔥 Save Q&A in interview_log for report
+        # Load the job and the candidate's application up front so we can
+        # evaluate at the right level and give the next question real memory.
+        job = None
+        application = None
         try:
+            if job_id is not None:
+                job = Job.query.get(int(job_id))
             application = Application.query.filter_by(
                 user_id=current_user.id,
                 job_id=job_id
             ).first()
+        except Exception as load_err:
+            logging.error(f"Error loading job/application: {load_err}")
+
+        job_role = job.role if job else "Software Developer"
+        seniority = (job.seniority if job and job.seniority else "Mid-level")
 
+        # Evaluate the answer calibrated to the real role and seniority
+        evaluation_result = evaluate_answer(
+            current_question, answer, job_role=job_role, seniority=seniority
+        )
+
+        # Append this turn to the persisted interview log.  The log doubles as
+        # the report source, the final-score source, and the conversation
+        # memory passed into the next question.
+        conversation_log = []
+        try:
             if application:
-                log_data = []
                 if application.interview_log:
                     try:
-                        log_data = json.loads(application.interview_log)
+                        conversation_log = json.loads(application.interview_log)
                     except Exception:
-                        log_data = []
+                        conversation_log = []
 
-                log_data.append({
+                conversation_log.append({
                     "question": current_question,
                     "answer": answer,
                     "evaluation": evaluation_result
                 })
 
-                application.interview_log = json.dumps(log_data, ensure_ascii=False)
+                application.interview_log = json.dumps(conversation_log, ensure_ascii=False)
                 db.session.commit()
         except Exception as log_err:
             logging.error(f"Error saving interview log: {log_err}")
 
         # Determine the number of questions configured for this job
         total_questions = 4
-        if job_id is not None:
-            try:
-                job = Job.query.get(int(job_id))
-                if job and job.num_questions and job.num_questions > 0:
-                    total_questions = job.num_questions
-            except Exception:
-                # If lookup fails, keep default
-                pass
+        if job and job.num_questions and job.num_questions > 0:
+            total_questions = job.num_questions
 
         # Check completion.  ``question_idx`` is zero‑based; the last index
         # corresponds to ``total_questions - 1``.  When the current index
@@ -274,28 +284,22 @@ def process_answer():
                     "and do you prefer remote or on-site work?"
             )
             else:
-                # 🔥 Use Qdrant-powered next question
+                # Use the Qdrant-powered, memory-aware next question.  The job
+                # and application were already loaded above, and conversation_log
+                # holds every prior turn so LUNA can build on the real dialogue.
                 try:
-                # You need profile + job for Qdrant context
-                    job = Job.query.get(int(job_id)) if job_id else None
-                    application = Application.query.filter_by(
-                        user_id=current_user.id,
-                        job_id=job_id
-                    ).first()
-
                     profile = {}
                     if application and application.extracted_features:
                         profile = json.loads(application.extracted_features)
 
-                    conversation_history = data.get("conversation_history", [])
                     next_question_text = generate_next_question(
                         profile,
                         job,
-                        conversation_history,
+                        conversation_log,
                         answer
                     )
                 except Exception as e:
-                    logging.error(f"Error generating next question from Qdrant: {e}")
+                    logging.error(f"Error generating next question: {e}")
                     next_question_text = "Could you elaborate more on your last point?"
 
 

backend/services/interview_engine.py

@@ -115,6 +115,61 @@ def load_whisper_model():
 
 load_whisper_model()
 
+def _most_recent_experience(profile):
+    """Safely return the candidate's most recent experience entry, or ''.
+
+    ``profile['experience']`` may be a list (possibly empty) or a string, so we
+    guard against IndexError which would otherwise drop the first question to a
+    canned fallback.
+    """
+    exp = profile.get('experience')
+    if isinstance(exp, list):
+        return str(exp[0]).strip() if exp else ""
+    if isinstance(exp, str):
+        return exp.strip()
+    return ""
+
+
+def _job_context(job):
+    """Build a compact role-context block to inject into prompts."""
+    try:
+        skills = ", ".join(job.skills_list) if getattr(job, "skills_list", None) else ""
+    except Exception:
+        skills = ""
+    seniority = getattr(job, "seniority", "") or ""
+    description = (getattr(job, "description", "") or "").strip()
+    if len(description) > 600:
+        description = description[:600] + "…"
+    return (
+        f"- Role: {job.role} at {job.company}\n"
+        f"- Seniority: {seniority}\n"
+        f"- Required skills: {skills}\n"
+        f"- Role description: {description}"
+    )
+
+
+def _format_history(conversation_history):
+    """Render the running conversation into readable Q/A lines for the prompt.
+
+    Accepts either the list of interview_log dicts ({"question", "answer", ...})
+    or a plain string / list of strings, so callers can pass whatever they have.
+    """
+    if not conversation_history:
+        return "(this is the first follow-up; no prior turns yet)"
+    if isinstance(conversation_history, str):
+        return conversation_history
+    lines = []
+    for i, turn in enumerate(conversation_history, 1):
+        if isinstance(turn, dict):
+            q = str(turn.get("question", "")).strip()
+            a = str(turn.get("answer", "")).strip()
+            if q or a:
+                lines.append(f"Q{i}: {q}\nA{i}: {a}")
+        else:
+            lines.append(str(turn).strip())
+    return "\n\n".join(lines) if lines else "(no prior turns yet)"
+
+
 def generate_first_question(profile, job):
     """Generate the first interview question based on profile and job"""
     all_roles = extract_all_roles_from_qdrant()
@@ -128,28 +183,34 @@ def generate_first_question(profile, job):
     else:
         logging.warning("[QDRANT DEBUG] No questions retrieved, falling back to defaults")
 
-    context_data = random_context_chunks(retrieved_data, k=4) if retrieved_data else ""
+    recent_experience = _most_recent_experience(profile)
 
     try:
         prompt = f"""
-        You are LUNA, an AI recruiter conducting an interview for a {job.role} position at {job.company}.
-        Candidate profile:
+        You are LUNA, a warm, professional AI recruiter conducting a real interview.
+
+        Position context:
+        {_job_context(job)}
+
+        Candidate profile (from their CV):
         - Skills: {profile.get('skills', [])}
         - Experience: {profile.get('experience', [])}
         - Education: {profile.get('education', [])}
 
-        Interview style:
-        - Start the interview in a friendly but professional way.
-        - Always begin with: "Hi, how are you? I'm LUNA, your AI recruiter."
-        - If the candidate has previous experience, reference their most recent role or company:
-        Example: "I see you previously worked at {profile.get('experience', [''])[0]}. 
-        Can you tell me more about your time there, along with your education and overall background?"
-        - If no experience is available, simply ask them to tell you about their background, education, and experience.
+        Your task — write ONLY the opening line of the interview:
+        - Always begin with exactly: "Hi, how are you? I'm LUNA, your AI recruiter."
+        - Then warmly invite them to introduce themselves.
+        - If they have prior experience, reference their most recent role naturally
+          (most recent role: "{recent_experience}") and ask them to tell you about that
+          experience along with their background and education.
+        - If they have no prior experience, simply ask them to tell you about their
+          background, education, and what draws them to this {job.role} role.
+        - Keep it to 2-3 sentences, conversational and human.
 
         Respond ONLY with the question text, no formatting or extra notes.
         """
 
-        
+
         response = groq_llm.invoke(prompt)
         
         # Fix: Handle AIMessage object properly
@@ -171,66 +232,6 @@ def generate_first_question(profile, job):
         logging.error(f"Error generating first question: {e}")
         return "Tell me about yourself and why you're interested in this position."
 
-def generate_next_question(profile, job, conversation_history, last_answer):
-    """Generate the next interview question based on profile, job, and conversation so far"""
-    all_roles = extract_all_roles_from_qdrant()
-    logging.info(f"[QDRANT DEBUG] Available Roles: {all_roles}")
-
-    retrieved_data = retrieve_interview_data(job.role.lower(), all_roles)
-    logging.info(f"[QDRANT DEBUG] Role requested: {job.role.lower()}")
-    logging.info(f"[QDRANT DEBUG] Questions retrieved: {len(retrieved_data)}")
-    if retrieved_data:
-        logging.info(f"[QDRANT DEBUG] Sample Next Q: {retrieved_data[0]['question']}")
-    else:
-        logging.warning("[QDRANT DEBUG] No questions retrieved, falling back to defaults")
-
-    context_data = random_context_chunks(retrieved_data, k=4) if retrieved_data else ""
-
-    try:
-        prompt = f"""
-        You are LUNA, an AI recruiter continuing an interview for a {job.role} position at {job.company}.
-        Candidate profile:
-        - Skills: {profile.get('skills', [])}
-        - Experience: {profile.get('experience', [])}
-        - Education: {profile.get('education', [])}
-
-        Conversation so far:
-        {conversation_history}
-
-        Candidate's last answer:
-        {last_answer}
-
-        Interview style:
-        - Acknowledge the candidate's last answer naturally (e.g., "That's a great point", "I see what you mean").
-        - Then ask a related follow-up question that connects to what they just said.
-        - Keep the tone professional, concise, and relevant to the role.
-        - If technical, dig deeper into skills or tools they mentioned.
-        - If behavioral, expand on situations or experiences they described.
-
-        Respond ONLY with the next question text (no formatting, no commentary).
-        """
-
-        
-        response = groq_llm.invoke(prompt)
-        
-        if hasattr(response, 'content'):
-            question = response.content.strip()
-        elif isinstance(response, str):
-            question = response.strip()
-        else:
-            question = str(response).strip()
-
-        if not question or len(question) < 10:
-            question = "Could you elaborate more on your last point?"
-            
-        logging.info(f"Generated next question: {question}")
-        return question
-
-    except Exception as e:
-        logging.error(f"Error generating next question: {e}")
-        return "Could you elaborate more on your last point?"
-
-
 def edge_tts_to_file_sync(text, output_path, voice="en-US-AriaNeural"):
     """Synchronous wrapper for edge-tts with better error handling"""
     try:
@@ -349,28 +350,40 @@ def generate_next_question(profile, job, conversation_history, last_answer):
         logging.warning("[QDRANT DEBUG] No questions retrieved, falling back to defaults")
 
     context_data = random_context_chunks(retrieved_data, k=4) if retrieved_data else ""
+    history_text = _format_history(conversation_history)
 
     try:
         prompt = f"""
-        You are continuing an interview for a {job.role} position at {job.company}.
-        Candidate's profile:
+        You are LUNA, a warm but sharp AI recruiter conducting a live interview. You behave like
+        a real human interviewer: you listen, react naturally, and keep the conversation flowing.
+
+        Position context:
+        {_job_context(job)}
+
+        Candidate's profile (from their CV):
         - Skills: {profile.get('skills', [])}
         - Experience: {profile.get('experience', [])}
         - Education: {profile.get('education', [])}
 
-        Conversation so far:
-        {conversation_history}
+        Conversation so far (earlier questions and the candidate's answers):
+        {history_text}
 
-        Candidate's last answer:
-        {last_answer}
+        The candidate just said:
+        "{last_answer}"
 
-        Use the following context to generate the next question:
+        Example questions from this role's question bank (for inspiration on topic/difficulty — do NOT copy verbatim):
         {context_data}
 
-        Generate an appropriate follow-up interview question that is professional and relevant.
-        Keep it concise and clear. If the interview is for a technical role, focus on technical skills.
+        Write LUNA's next turn:
+        - Start with a brief, natural acknowledgement of their last answer (e.g. "That makes sense," "Great, thanks for sharing that.").
+        - Then ask exactly ONE focused follow-up question.
+        - Build on what they actually said and what's already been discussed — never repeat an earlier question.
+        - Stay anchored to the {job.role} role and its required skills; for technical roles, probe deeper into real skills/tools.
+        - Keep it concise, conversational, and human (1-2 sentences for the question).
+
+        Respond ONLY with LUNA's spoken text (acknowledgement + the one question), no labels or formatting.
         """
-        
+
         response = groq_llm.invoke(prompt)
         
         if hasattr(response, 'content'):
@@ -443,19 +456,21 @@ def evaluate_answer(question, answer, job_role="Software Developer", seniority="
             }
             
         prompt = f"""
-        You are evaluating a candidate's answer for a {seniority} {job_role} position.
-        
+        You are LUNA, an experienced recruiter evaluating a candidate's spoken answer for a
+        {seniority} {job_role} position. Judge it at the level expected for that seniority.
+
         Question: {question}
         Candidate Answer: {answer}
-        
-        Evaluate based on technical correctness, clarity, and relevance.
-        Provide a brief evaluation in 1-2 sentences.
-        
-        Rate the answer as one of: Poor, Medium, Good, Excellent
-        
-        Respond in this exact format:
+
+        Evaluate on: technical correctness, relevance to the question, depth/specificity, and clarity.
+        Calibrate to seniority — be more demanding for senior roles, more forgiving for junior ones.
+        Reward concrete, specific answers; penalise vague, off-topic, or empty ones.
+
+        Rate the answer as exactly one of: Poor, Medium, Good, Excellent.
+
+        Respond in this exact format and nothing else:
         Score: [Poor/Medium/Good/Excellent]
-        Feedback: [Your brief feedback here]
+        Feedback: [one or two specific sentences explaining the rating]
         """
         
         response = groq_llm.invoke(prompt)

backend/services/resume_parser.py

@@ -1,32 +1,48 @@
+import os
 import re
+import json
+import logging
 from pathlib import Path
 from typing import Dict, List, Tuple
-import spacy
+
 from pdfminer.high_level import extract_text as pdf_extract_text
 from docx import Document
-from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
-import nltk
-from nltk.corpus import stopwords
-from dateutil.parser import parse as date_parse
-
-# Download required NLTK data
-try:
-    nltk.download('stopwords', quiet=True)
-    nltk.download('punkt', quiet=True)
-except:
-    pass
-
-# Load spaCy model for better NER
-try:
-    nlp = spacy.load("en_core_web_sm")
-except:
-    print("Please install spacy model: python -m spacy download en_core_web_sm")
-    nlp = None
-
-MODEL_NAME = "manishiitg/resume-ner"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForTokenClassification.from_pretrained(MODEL_NAME)
-ner_pipeline = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_strategy="simple")
+
+# ---------------------------------------------------------------------------
+# Parsing strategy
+#
+# The primary parser is an LLM (Groq) which reads the raw resume text and
+# returns clean, structured fields.  This is far more accurate than regex and
+# handles any ATS-friendly CV.  The legacy spaCy/transformer/regex path is kept
+# only as a fallback for when no GROQ_API_KEY is configured or the LLM call
+# fails.  The heavy fallback dependencies (spaCy model, the manishiitg/resume-ner
+# transformer, nltk) are imported lazily inside ``_regex_parse`` so the normal
+# (LLM) path does not pay their startup cost.
+# ---------------------------------------------------------------------------
+
+# Cached lazily so we only build the Groq client once.
+_llm = None
+_llm_initialised = False
+
+
+def _get_llm():
+    """Return a cached ChatGroq client, or ``None`` when no key is configured."""
+    global _llm, _llm_initialised
+    if _llm_initialised:
+        return _llm
+    _llm_initialised = True
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        logging.warning("GROQ_API_KEY not set; resume parsing will use the regex fallback.")
+        _llm = None
+        return _llm
+    try:
+        from langchain_groq import ChatGroq
+        _llm = ChatGroq(temperature=0, model_name="llama-3.3-70b-versatile", api_key=api_key)
+    except Exception as exc:
+        logging.error(f"Failed to initialise Groq for resume parsing: {exc}")
+        _llm = None
+    return _llm
 
 # Expanded keyword lists
 SKILL_KEYWORDS = {
@@ -146,6 +162,7 @@ def extract_name(text: str, entities: List) -> str:
             return full_name
     
     # Method 2: Use spaCy if available
+    nlp = _get_nlp()
     if nlp:
         doc = nlp(text[:500])  # Check first 500 chars
         for ent in doc.ents:
@@ -260,36 +277,176 @@ def extract_experience(text: str, exp_section: str = "") -> List[str]:
     
     return list(dict.fromkeys(experience_info))
 
-def parse_resume(file_path: str, filename: str = None) -> Dict[str, str]:
-    """Main function to parse resume"""
-    # Extract and clean text
-    raw_text = extract_text(file_path)
-    text = clean_text(raw_text)
-    
-    # Extract sections
+# ---------------------------------------------------------------------------
+# Lazy loaders for the fallback (regex/NER) path
+# ---------------------------------------------------------------------------
+_nlp = None
+_nlp_loaded = False
+_ner_pipeline = None
+_ner_loaded = False
+
+
+def _get_nlp():
+    """Lazily load the spaCy model (used only by the regex fallback)."""
+    global _nlp, _nlp_loaded
+    if _nlp_loaded:
+        return _nlp
+    _nlp_loaded = True
+    try:
+        import spacy
+        _nlp = spacy.load("en_core_web_sm")
+    except Exception:
+        logging.warning("spaCy model en_core_web_sm unavailable; name detection degraded.")
+        _nlp = None
+    return _nlp
+
+
+def _get_ner_pipeline():
+    """Lazily load the resume-ner transformer (used only by the regex fallback)."""
+    global _ner_pipeline, _ner_loaded
+    if _ner_loaded:
+        return _ner_pipeline
+    _ner_loaded = True
+    try:
+        from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+        name = "manishiitg/resume-ner"
+        tok = AutoTokenizer.from_pretrained(name)
+        mdl = AutoModelForTokenClassification.from_pretrained(name)
+        _ner_pipeline = pipeline("ner", model=mdl, tokenizer=tok, aggregation_strategy="simple")
+    except Exception as exc:
+        logging.warning(f"resume-ner model unavailable ({exc}); using spaCy/regex for names.")
+        _ner_pipeline = None
+    return _ner_pipeline
+
+
+# ---------------------------------------------------------------------------
+# Primary parser: LLM (Groq)
+# ---------------------------------------------------------------------------
+def _coerce_list(value) -> List[str]:
+    """Normalise the LLM's value (list or string) into a clean list of strings."""
+    if isinstance(value, list):
+        items = [str(v).strip() for v in value]
+    elif isinstance(value, str):
+        items = [p.strip() for p in re.split(r'[\n;]+', value)]
+    else:
+        items = []
+    # Drop empties and obvious "not found" placeholders, dedupe (case-insensitive)
+    seen, out = set(), []
+    for it in items:
+        if not it or it.lower() in ("not found", "n/a", "none", "-"):
+            continue
+        key = it.lower()
+        if key not in seen:
+            seen.add(key)
+            out.append(it)
+    return out
+
+
+def _llm_extract(text: str) -> Dict[str, str]:
+    """Extract structured fields from resume text with the Groq LLM.
+
+    Returns the same string-field shape as ``parse_resume``. Raises on any
+    failure so the caller can fall back to the regex parser.
+    """
+    llm = _get_llm()
+    if llm is None:
+        raise RuntimeError("LLM unavailable")
+
+    # Keep the prompt bounded; resumes rarely need more than this many chars.
+    snippet = text[:6000]
+    prompt = f"""You are an expert resume parser. Read the resume text below and extract the candidate's details.
+
+Return ONLY a JSON object (no markdown, no commentary) with exactly these keys:
+- "name": the candidate's full name as a string (empty string if not found)
+- "skills": an array of individual technical and professional skills (e.g. ["Python", "React", "AWS", "Project Management"])
+- "education": an array of one-line entries, each "<Degree> in <Field> — <Institution>, <Year>" when available
+- "experience": an array of one-line entries, each "<Job Title> — <Company> (<dates or duration>)" when available
+
+Rules:
+- Use the actual content of the resume; never invent information.
+- Keep each array entry concise and on a single line.
+- If a section is missing, return an empty array for it.
+
+Resume text:
+\"\"\"
+{snippet}
+\"\"\"
+"""
+    response = llm.invoke(prompt)
+    raw = response.content if hasattr(response, "content") else str(response)
+
+    # Be robust to code fences or stray prose around the JSON.
+    cleaned = raw.strip()
+    if cleaned.startswith("```"):
+        cleaned = re.sub(r"^```[a-zA-Z]*\n?", "", cleaned).rstrip("`").strip()
+    start, end = cleaned.find("{"), cleaned.rfind("}")
+    if start == -1 or end == -1:
+        raise ValueError("LLM did not return JSON")
+    data = json.loads(cleaned[start:end + 1])
+
+    name = str(data.get("name", "")).strip()
+    skills = _coerce_list(data.get("skills"))
+    education = _coerce_list(data.get("education"))
+    experience = _coerce_list(data.get("experience"))
+
+    return {
+        "name": name if name else "Not Found",
+        "skills": ", ".join(skills[:20]) if skills else "Not Found",
+        "education": "\n".join(education[:6]) if education else "Not Found",
+        "experience": "\n".join(experience[:6]) if experience else "Not Found",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Fallback parser: legacy spaCy/transformer/regex heuristics
+# ---------------------------------------------------------------------------
+def _regex_parse(text: str) -> Dict[str, str]:
+    """Heuristic resume parsing used when the LLM is unavailable."""
     sections = extract_sections(text)
-    
-    # Get NER entities
-    entities = ner_pipeline(text[:1024])  # Limit for performance
-    
-    # Extract information
+
+    entities = []
+    ner = _get_ner_pipeline()
+    if ner is not None:
+        try:
+            entities = ner(text[:1024])  # Limit for performance
+        except Exception:
+            entities = []
+
     name = extract_name(text, entities)
     skills = extract_skills(text, sections.get('skills', ''))
     education = extract_education(text, sections.get('education', ''))
     experience = extract_experience(text, sections.get('experience', ''))
-    
+
     return {
         "name": name,
-        "skills": ", ".join(skills[:15]) if skills else "Not Found",  # Limit to 15 skills
+        "skills": ", ".join(skills[:15]) if skills else "Not Found",
         "education": ", ".join(education[:5]) if education else "Not Found",
-        "experience": ", ".join(experience[:5]) if experience else "Not Found"
+        "experience": ", ".join(experience[:5]) if experience else "Not Found",
     }
 
+
+def parse_resume(file_path: str, filename: str = None) -> Dict[str, str]:
+    """Parse a resume into structured fields.
+
+    Tries the Groq LLM first (accurate, handles any CV layout) and falls back
+    to the legacy regex/NER heuristics if the LLM is unavailable or errors.
+    The return shape (string fields) is unchanged so existing callers work.
+    """
+    raw_text = extract_text(file_path)
+    text = clean_text(raw_text)
+
+    try:
+        return _llm_extract(text)
+    except Exception as exc:
+        logging.warning(f"LLM resume parsing failed ({exc}); falling back to regex parser.")
+        return _regex_parse(text)
+
+
 # Optional: Add confidence scores
 def parse_resume_with_confidence(file_path: str) -> Dict[str, Tuple[str, float]]:
     """Parse resume with confidence scores for each field"""
     result = parse_resume(file_path)
-    
+
     # Simple confidence calculation based on whether data was found
     confidence_scores = {
         "name": 0.9 if result["name"] != "Not Found" else 0.1,
@@ -297,8 +454,8 @@ def parse_resume_with_confidence(file_path: str) -> Dict[str, Tuple[str, float]]
         "education": 0.8 if result["education"] != "Not Found" else 0.2,
         "experience": 0.8 if result["experience"] != "Not Found" else 0.2
     }
-    
+
     return {
-        key: (value, confidence_scores[key]) 
+        key: (value, confidence_scores[key])
         for key, value in result.items()
     }