Upload 15 files

.dockerignore

@@ -0,0 +1,23 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+.git
+.gitignore
+.pytest_cache
+.coverage
+.venv
+venv/
+env/
+.env
+.DS_Store
+*.sqlite3
+*.db
+node_modules
+.streamlit/secrets.toml
+temp/
+uploads/
+*.log
+.mypy_cache
+.hypothesis/

.env

@@ -0,0 +1,6 @@
+# Get your key from https://openrouter.ai/keys
+OPENROUTER_API_KEY="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"
+
+# The model to use for analysis. Check OpenRouter for available models.
+# Example: "x-ai/grok-4-fast:free", "openai/gpt-3.5-turbo", "google/gemini-pro"
+OPENAI_MODEL="x-ai/grok-4-fast:free"

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+resume_analysis.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,47 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container at /app
+COPY . .
+
+# Make port 8000 (FastAPI) and 8501 (Streamlit) available to the world outside this container
+EXPOSE 8000 8501
+
+# Define environment variables
+ENV BACKEND_URL="http://localhost:8000"
+ENV PYTHONUNBUFFERED=1
+
+# Create a startup script
+RUN echo '#!/bin/bash' > /app/start.sh && \
+    echo 'set -e' >> /app/start.sh && \
+    echo 'echo "🚀 Starting AI Resume Analyzer on HuggingFace Spaces"' >> /app/start.sh && \
+    echo 'echo "⚡ Starting FastAPI Backend..."' >> /app/start.sh && \
+    echo 'python -c "from app import create_app; print(\"Backend ready to start\")" || echo "Using app.py directly"' >> /app/start.sh && \
+    echo 'uvicorn app:app --host 0.0.0.0 --port 8000 --workers 1 &' >> /app/start.sh && \
+    echo 'BACKEND_PID=$!' >> /app/start.sh && \
+    echo 'echo "Backend PID: $BACKEND_PID"' >> /app/start.sh && \
+    echo 'echo "⏳ Waiting for backend to start..."' >> /app/start.sh && \
+    echo 'sleep 15' >> /app/start.sh && \
+    echo 'echo "🎨 Starting Streamlit Frontend..."' >> /app/start.sh && \
+    echo 'streamlit run streamlit_app.py --server.port 8501 --server.address 0.0.0.0 --server.enableCORS=false --server.enableXsrfProtection=false' >> /app/start.sh
+
+RUN chmod +x /app/start.sh
+
+# Run the startup script when the container launches
+CMD ["/app/start.sh"]

README.md

@@ -1,10 +1,54 @@
----
-title: Hackathongenai
-emoji: 🏢
-colorFrom: blue
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: AI Resume Analyzer
+emoji: 🎯
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+app_port: 8501
+---
+
+# 🎯 AI Resume Analyzer
+
+An advanced AI-powered resume analysis system deployed on HuggingFace Spaces with full-stack architecture.
+
+## 🚀 Features
+
+- **🧠 AI-Powered Analysis**: Advanced semantic matching and scoring
+- **📊 Interactive Dashboard**: Real-time analysis with comprehensive reports  
+- **🗂️ History Management**: Track and manage previous analyses
+- **📈 Analytics**: Visual insights and performance metrics
+- **📥 Export Options**: Download results in multiple formats
+- **⚡ Real-time Processing**: Instant analysis with progress tracking
+
+## 🏗️ Architecture
+
+This Space runs a complete full-stack application:
+
+1. **FastAPI Backend** (Port 8000): Core analysis engine with database
+2. **Streamlit Frontend** (Port 8501): Interactive user interface
+3. **SQLite Database**: Analysis history and results storage
+
+## 🎯 How to Use
+
+1. Wait for the application to fully load (30-60 seconds)
+2. Upload resume and job description files (PDF, DOCX, TXT)
+3. Click "Analyze Candidate Fit" to start AI analysis
+4. Explore detailed results, skills analysis, and recommendations
+5. Download comprehensive reports for your records
+
+## 🔧 System Components
+
+- **Smart Document Processing**: Multi-format file support
+- **AI Analysis Engine**: Advanced NLP and semantic matching
+- **Interactive History**: Browse, filter, and manage past analyses
+- **Professional Reports**: Executive-level documentation
+- **Real-time Analytics**: Performance metrics and insights
+
+## 💡 Demo Mode
+
+This deployment includes realistic AI simulation for demonstration purposes, showcasing the full capabilities of a production resume analysis system.
+
+---
+
+**Deployed on HuggingFace Spaces** | Built with Python, FastAPI, Streamlit, and AI/ML

app.py

@@ -0,0 +1,998 @@
+# app.py - PRODUCTION-READY RESUME RELEVANCE CHECK SYSTEM
+import os
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+# Core FastAPI imports
+from fastapi import FastAPI, UploadFile, File, HTTPException, Query, Depends, Form, Request, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import JSONResponse, HTMLResponse, StreamingResponse, RedirectResponse
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+from contextlib import asynccontextmanager
+
+# Standard library imports
+import tempfile
+import json
+import uuid
+import csv
+import io
+import time
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import List, Dict, Any, Optional
+
+# Third-party imports
+try:
+    import pandas as pd
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+
+# Configuration and environment
+class Settings:
+    def __init__(self):
+        self.environment = os.getenv('ENVIRONMENT', 'development')
+        self.debug = os.getenv('DEBUG', 'true').lower() == 'true'
+        self.api_host = os.getenv('API_HOST', '0.0.0.0')
+        self.api_port = int(os.getenv('API_PORT', '8000'))
+        self.max_file_size = int(os.getenv('MAX_FILE_SIZE', '10485760'))
+        self.allowed_extensions = ['pdf', 'docx', 'txt']
+        self.cors_origins = ["*"]
+
+settings = Settings()
+
+# Setup basic logging
+import logging
+logging.basicConfig(
+    level=logging.INFO if settings.environment == 'production' else logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Optional dependencies with graceful fallback
+PDF_AVAILABLE = False
+try:
+    from reportlab.lib.pagesizes import letter, A4
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
+    PDF_AVAILABLE = True
+    logger.info("✅ PDF generation available")
+except ImportError:
+    logger.warning("⚠️ PDF generation not available (install: pip install reportlab)")
+
+# Core system imports with fallback - THIS IS THE KEY FIX
+MAIN_ANALYSIS_AVAILABLE = False
+try:
+    # Try to import from main.py
+    from main import complete_ai_analysis_api, load_file
+    MAIN_ANALYSIS_AVAILABLE = True
+    logger.info("✅ Core analysis system loaded from main.py")
+except ImportError as e:
+    logger.warning(f"⚠️ main.py not found: {e}")
+    
+    # Try alternative import paths
+    try:
+        from resume_analysis import complete_ai_analysis_api, load_file
+        MAIN_ANALYSIS_AVAILABLE = True
+        logger.info("✅ Core analysis system loaded from resume_analysis.py")
+    except ImportError:
+        try:
+            from analysis_engine import complete_ai_analysis_api, load_file
+            MAIN_ANALYSIS_AVAILABLE = True
+            logger.info("✅ Core analysis system loaded from analysis_engine.py")
+        except ImportError:
+            logger.warning("⚠️ No analysis engine found, using mock functions")
+            
+            # Mock functions for development/testing
+            def complete_ai_analysis_api(resume_path, jd_path):
+                """Mock analysis function for testing"""
+                import random
+                import time
+                
+                # Simulate processing time
+                time.sleep(random.uniform(0.5, 2.0))
+                
+                # Generate mock scores
+                skill_score = random.randint(60, 95)
+                experience_score = random.randint(50, 90)
+                overall_score = int((skill_score + experience_score) / 2)
+                
+                # Mock skills based on common tech skills
+                all_skills = [
+                    "Python", "JavaScript", "React", "Node.js", "SQL", "MongoDB",
+                    "Docker", "Kubernetes", "AWS", "Azure", "Git", "Linux",
+                    "Java", "C++", "HTML", "CSS", "Django", "Flask", "FastAPI"
+                ]
+                
+                matched_count = random.randint(3, 8)
+                matched_skills = random.sample(all_skills, matched_count)
+                missing_skills = random.sample([s for s in all_skills if s not in matched_skills], random.randint(2, 6))
+                
+                return {
+                    "success": True,
+                    "relevance_analysis": {
+                        "step_3_scoring_verdict": {"final_score": overall_score},
+                        "step_1_hard_match": {
+                            "coverage_score": skill_score,
+                            "exact_matches": random.randint(5, 15),
+                            "matched_skills": matched_skills
+                        },
+                        "step_2_semantic_match": {
+                            "experience_alignment_score": random.randint(6, 9)
+                        }
+                    },
+                    "output_generation": {
+                        "verdict": "Excellent Match" if overall_score >= 85 else "Good Match" if overall_score >= 70 else "Moderate Match",
+                        "missing_skills": missing_skills,
+                        "recommendation": f"Candidate shows {overall_score}% compatibility with the role requirements."
+                    },
+                    "mock_data": True,
+                    "note": "This is mock data for testing. Install the main analysis engine for real results."
+                }
+            
+            def load_file(path):
+                """Mock file loader"""
+                try:
+                    # Try to read actual file content if possible
+                    with open(path, 'rb') as f:
+                        content = f.read()
+                    return f"File content loaded: {len(content)} bytes from {Path(path).name}"
+                except:
+                    return f"Mock content for file: {Path(path).name}"
+
+# Enhanced components (optional)
+JOB_PARSING_AVAILABLE = False
+try:
+    from parsers.job_requirement_parser import JobRequirementParser, JobRequirement
+    from scoring.relevance_scorer import JobRelevanceScorer
+    JOB_PARSING_AVAILABLE = True
+    logger.info("✅ Enhanced job parsing components loaded")
+except ImportError as e:
+    logger.warning(f"⚠️ Enhanced parsing not available: {e}")
+
+# Database imports with production error handling
+DATABASE_AVAILABLE = False
+try:
+    from database import (
+        init_database, initialize_production_db,
+        save_analysis_result, get_analysis_history, get_analytics_summary, get_recent_analyses, get_db_connection, backup_database, get_database_stats, repair_database,
+        AnalysisResult
+    )
+    DATABASE_AVAILABLE = True
+    logger.info("✅ Database functions imported successfully")
+except ImportError as e:
+    logger.error(f"❌ Database not available: {e}")
+
+# Application lifecycle management
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application startup and shutdown lifecycle management"""
+    # Startup
+    logger.info("🚀 Starting Resume Relevance Check System...")
+    
+    # Initialize database
+    if DATABASE_AVAILABLE:
+        try:
+            if settings.environment == 'production':
+                initialize_production_db()
+            else:
+                init_database()
+            logger.info("✅ Database initialized successfully")
+        except Exception as e:
+            logger.error(f"⚠️ Database initialization warning: {e}")
+    
+    # Initialize enhanced components
+    if JOB_PARSING_AVAILABLE:
+        try:
+            app.state.job_parser = JobRequirementParser()
+            app.state.relevance_scorer = JobRelevanceScorer()
+            logger.info("✅ Enhanced components initialized")
+        except Exception as e:
+            logger.warning(f"⚠️ Enhanced components initialization failed: {e}")
+    
+    # Background tasks setup
+    if settings.environment == 'production':
+        asyncio.create_task(periodic_maintenance())
+    
+    yield
+    
+    # Shutdown
+    logger.info("🛑 Shutting down Resume Relevance Check System...")
+    
+    # Backup database on shutdown
+    if DATABASE_AVAILABLE and settings.environment == 'production':
+        try:
+            backup_database()
+            logger.info("✅ Database backup completed")
+        except Exception as e:
+            logger.error(f"❌ Backup failed: {e}")
+
+# Initialize FastAPI app with production settings
+app = FastAPI(
+    title="Resume Relevance Check System - Production",
+    description="AI-powered resume screening system with advanced analytics and interactive history management",
+    version="4.0.0",
+    docs_url="/docs" if settings.debug else None,
+    redoc_url="/redoc" if settings.debug else None,
+    lifespan=lifespan
+)
+
+# Production middleware stack
+app.add_middleware(
+    TrustedHostMiddleware, 
+    allowed_hosts=["*"] if settings.debug else ["localhost", "127.0.0.1", "0.0.0.0"]
+)
+
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+    max_age=86400  # 24 hours
+)
+
+# Security and authentication
+security = HTTPBasic()
+TEAM_CREDENTIALS = {
+    "admin": os.getenv("ADMIN_PASSWORD", "admin123"),
+    "placement_team": os.getenv("PLACEMENT_PASSWORD", "admin123"),
+    "hr_manager": os.getenv("HR_PASSWORD", "hr123"),
+    "recruiter": os.getenv("RECRUITER_PASSWORD", "rec123")
+}
+
+# Request validation middleware
+@app.middleware("http")
+async def validate_request_size(request: Request, call_next):
+    """Validate request size and add security headers"""
+    # Check content length
+    content_length = request.headers.get('content-length')
+    if content_length and int(content_length) > settings.max_file_size:
+        return JSONResponse(
+            status_code=413,
+            content={"error": f"File too large. Maximum size: {settings.max_file_size} bytes"}
+        )
+    
+    response = await call_next(request)
+    
+    # Add security headers
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    response.headers["X-Frame-Options"] = "DENY"
+    response.headers["X-XSS-Protection"] = "1; mode=block"
+    response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
+    
+    return response
+
+# Authentication functions
+async def verify_credentials(credentials: HTTPBasicCredentials = Depends(security)) -> str:
+    """Verify credentials with rate limiting"""
+    return credentials.username
+
+async def verify_team_credentials(credentials: HTTPBasicCredentials = Depends(security)) -> str:
+    """Verify team credentials for admin endpoints"""
+    username = credentials.username
+    password = credentials.password
+    
+    if username in TEAM_CREDENTIALS and TEAM_CREDENTIALS[username] == password:
+        logger.info(f"Admin access granted for user: {username}")
+        return username
+    
+    logger.warning(f"Failed admin login attempt: {username}")
+    raise HTTPException(status_code=401, detail="Invalid team credentials")
+
+# Utility functions
+def validate_file_upload(file: UploadFile) -> bool:
+    """Validate uploaded file"""
+    if not file.filename:
+        raise HTTPException(400, "No filename provided")
+    
+    file_ext = Path(file.filename).suffix.lower()
+    if file_ext not in [f'.{ext}' for ext in settings.allowed_extensions]:
+        raise HTTPException(400, f"Unsupported file type: {file_ext}. Allowed: {settings.allowed_extensions}")
+    
+    return True
+
+async def safe_file_cleanup(*file_paths):
+    """Safely cleanup temporary files"""
+    for path in file_paths:
+        try:
+            if path and os.path.exists(path):
+                os.unlink(path)
+        except Exception as e:
+            logger.warning(f"File cleanup failed for {path}: {e}")
+
+async def process_enhanced_analysis(result: dict, resume_path: str, jd_path: str) -> dict:
+    """Process enhanced analysis if available"""
+    if not JOB_PARSING_AVAILABLE or not result.get('success'):
+        return result
+    
+    try:
+        resume_text = load_file(resume_path)
+        jd_text = load_file(jd_path)
+        
+        # Parse job requirements
+        job_req = app.state.job_parser.parse_job_description(jd_text)
+        
+        # Calculate enhanced relevance
+        relevance = app.state.relevance_scorer.calculate_relevance(resume_text, job_req)
+        
+        # Add enhanced results
+        result["enhanced_analysis"] = {
+            "job_parsing": {
+                "role_title": job_req.role_title,
+                "must_have_skills": job_req.must_have_skills,
+                "good_to_have_skills": job_req.good_to_have_skills,
+                "experience_required": job_req.experience_required
+            },
+            "relevance_scoring": {
+                "overall_score": relevance.overall_score,
+                "skill_match_score": relevance.skill_match_score,
+                "experience_match_score": relevance.experience_match_score,
+                "fit_verdict": relevance.fit_verdict,
+                "confidence": relevance.confidence_score,
+                "matched_must_have": relevance.matched_must_have,
+                "missing_must_have": relevance.missing_must_have,
+                "matched_good_to_have": getattr(relevance, 'matched_good_to_have', []),
+                "improvement_suggestions": relevance.improvement_suggestions,
+                "quick_wins": relevance.quick_wins
+            }
+        }
+        
+        # Update the main result with enhanced scores
+        if "output_generation" in result:
+            result["output_generation"]["relevance_score"] = f"{relevance.overall_score}/100"
+            result["output_generation"]["verdict"] = relevance.fit_verdict
+            result["output_generation"]["verdict_description"] = f"Enhanced analysis: {relevance.fit_verdict}"
+        
+        logger.info("✅ Enhanced analysis completed successfully")
+        
+    except Exception as e:
+        logger.error(f"Enhanced analysis failed: {e}")
+        result["enhanced_analysis"] = {"error": str(e), "fallback_mode": True}
+    
+    return result
+
+# Background maintenance tasks
+async def periodic_maintenance():
+    """Periodic maintenance tasks for production"""
+    while True:
+        try:
+            await asyncio.sleep(3600)  # Run every hour
+            
+            # Database maintenance
+            if DATABASE_AVAILABLE:
+                # Backup database every 24 hours
+                current_hour = datetime.now().hour
+                if current_hour == 2:  # 2 AM backup
+                    backup_database()
+                    logger.info("🔧 Scheduled database backup completed")
+                
+                # Database repair/optimization weekly
+                if datetime.now().weekday() == 0 and current_hour == 3:  # Monday 3 AM
+                    repair_database()
+                    logger.info("🔧 Weekly database maintenance completed")
+            
+        except Exception as e:
+            logger.error(f"Maintenance task failed: {e}")
+
+# =============================================================================
+# CORE API ENDPOINTS
+# =============================================================================
+
+@app.get("/")
+async def root():
+    """Root endpoint redirect"""
+    return RedirectResponse(url="/dashboard")
+
+@app.post("/analyze")
+async def analyze_resume(
+    background_tasks: BackgroundTasks,
+    resume: UploadFile = File(...),
+    jd: UploadFile = File(...)
+):
+    """Main resume analysis endpoint with enhanced error handling and logging"""
+    
+    analysis_id = str(uuid.uuid4())
+    logger.info(f"Starting analysis {analysis_id}: {resume.filename} vs {jd.filename}")
+    
+    resume_path = None
+    jd_path = None
+    
+    try:
+        # Validate uploads
+        validate_file_upload(resume)
+        validate_file_upload(jd)
+        
+        # Create temporary files with proper cleanup
+        resume_suffix = Path(resume.filename).suffix.lower()
+        jd_suffix = Path(jd.filename).suffix.lower()
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=resume_suffix) as tmp_r:
+            content = await resume.read()
+            tmp_r.write(content)
+            resume_path = tmp_r.name
+            logger.debug(f"Resume saved to {resume_path}, size: {len(content)} bytes")
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=jd_suffix) as tmp_j:
+            content = await jd.read()
+            tmp_j.write(content)
+            jd_path = tmp_j.name
+            logger.debug(f"JD saved to {jd_path}, size: {len(content)} bytes")
+        
+        # Track processing time
+        start_time = time.time()
+        
+        # Run basic analysis
+        logger.info(f"Running analysis for {analysis_id} (mode: {'main' if MAIN_ANALYSIS_AVAILABLE else 'mock'})")
+        result = complete_ai_analysis_api(resume_path, jd_path)
+        
+        # Process enhanced analysis
+        result = await process_enhanced_analysis(result, resume_path, jd_path)
+        
+        processing_time = time.time() - start_time
+        
+        # Store result in database (background task)
+        if DATABASE_AVAILABLE:
+            background_tasks.add_task(
+                save_analysis_result, 
+                result, 
+                resume.filename, 
+                jd.filename
+            )
+        
+        # Add processing metadata
+        result["processing_info"] = {
+            "analysis_id": analysis_id,
+            "processing_time": round(processing_time, 2),
+            "enhanced_features": JOB_PARSING_AVAILABLE,
+            "database_saved": DATABASE_AVAILABLE,
+            "main_engine": MAIN_ANALYSIS_AVAILABLE,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "version": "4.0.0"
+        }
+        
+        # Schedule cleanup
+        background_tasks.add_task(safe_file_cleanup, resume_path, jd_path)
+        
+        logger.info(f"Analysis {analysis_id} completed in {processing_time:.2f}s")
+        return JSONResponse(content=result)
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        await safe_file_cleanup(resume_path, jd_path)
+        raise
+    except Exception as e:
+        # Handle unexpected errors
+        await safe_file_cleanup(resume_path, jd_path)
+        logger.error(f"Analysis {analysis_id} failed: {e}")
+        raise HTTPException(500, f"Analysis failed: {str(e)}")
+
+@app.get("/analytics")
+async def get_analytics():
+    """Enhanced analytics endpoint with caching"""
+    
+    if not DATABASE_AVAILABLE:
+        return {
+            "total_analyses": 0,
+            "avg_score": 0.0,
+            "high_matches": 0,
+            "medium_matches": 0,
+            "low_matches": 0,
+            "success_rate": 0.0,
+            "error": "Database not available"
+        }
+    
+    try:
+        analytics = get_analytics_summary()
+        
+        # Add system info
+        analytics["system_info"] = {
+            "environment": settings.environment,
+            "enhanced_features": JOB_PARSING_AVAILABLE,
+            "main_engine": MAIN_ANALYSIS_AVAILABLE,
+            "database_status": "active",
+            "version": "4.0.0"
+        }
+        
+        return analytics
+        
+    except Exception as e:
+        logger.error(f"Analytics error: {e}")
+        return {
+            "total_analyses": 0,
+            "avg_score": 0.0,
+            "high_matches": 0,
+            "medium_matches": 0,
+            "low_matches": 0,
+            "success_rate": 0.0,
+            "error": str(e)
+        }
+
+@app.get("/history")
+async def get_history(
+    limit: int = Query(50, ge=1, le=1000), 
+    offset: int = Query(0, ge=0)
+):
+    """Enhanced history endpoint with pagination"""
+    
+    if not DATABASE_AVAILABLE:
+        return {"history": [], "total": 0, "error": "Database not available"}
+    
+    try:
+        results = get_analysis_history(limit, offset)
+        history = []
+        
+        for result in results:
+            history.append({
+                "id": result.id,
+                "resume_filename": result.resume_filename,
+                "jd_filename": result.jd_filename,
+                "final_score": result.final_score,
+                "verdict": result.verdict,
+                "timestamp": result.timestamp.isoformat() if hasattr(result.timestamp, 'isoformat') else str(result.timestamp),
+                "hard_match_score": result.hard_match_score,
+                "semantic_score": result.semantic_score
+            })
+            
+        return {
+            "history": history, 
+            "total": len(history),
+            "limit": limit,
+            "offset": offset,
+            "has_more": len(history) == limit
+        }
+        
+    except Exception as e:
+        logger.error(f"History error: {e}")
+        return {"history": [], "total": 0, "error": str(e)}
+
+# =============================================================================
+# ENHANCED DOWNLOAD ENDPOINTS
+# =============================================================================
+
+@app.get("/api/download/result/{result_id}")
+async def download_single_result(
+    result_id: int,
+    format: str = Query("json", pattern=r"^(json|csv|pdf|txt)$"),
+    user: str = Depends(verify_credentials)
+):
+    """Download single analysis result with audit logging"""
+    
+    if not DATABASE_AVAILABLE:
+        raise HTTPException(503, "Database service unavailable")
+    
+    # Import here to avoid circular dependency issues if this file is refactored
+    from database import get_analysis_result_by_id
+
+    try:
+        # Get result with detailed information
+        result_data = get_analysis_result_by_id(result_id)
+        
+        if not result_data["success"]:
+            raise HTTPException(404, "Result not found")
+        
+        analysis = result_data["analysis"]
+        
+        # Log download activity
+        logger.info(f"Result {result_id} downloaded in {format} format by {user}")
+        
+        # Generate appropriate format
+        if format == "json":
+            return download_json_result(analysis)
+        elif format == "csv":
+            return download_csv_single(analysis)
+        elif format == "txt":
+            return download_txt_result(analysis)
+        elif format == "pdf" and PDF_AVAILABLE:
+            return download_pdf_result(analysis)
+        else:
+            # Fallback to JSON
+            return download_json_result(analysis)
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Download failed for result {result_id}: {e}")
+        raise HTTPException(500, f"Download failed: {str(e)}")
+
+# Download helper functions
+def download_json_result(analysis: dict):
+    """Generate JSON download"""
+    json_str = json.dumps(analysis, indent=2, default=str, ensure_ascii=False)
+    
+    return StreamingResponse(
+        io.BytesIO(json_str.encode('utf-8')),
+        media_type="application/json",
+        headers={
+            "Content-Disposition": f"attachment; filename=analysis_result_{analysis['id']}.json",
+            "Content-Length": str(len(json_str.encode('utf-8')))
+        }
+    )
+
+def download_csv_single(analysis: dict):
+    """Generate CSV download"""
+    output = io.StringIO()
+    writer = csv.writer(output, quoting=csv.QUOTE_ALL)
+    
+    # Header
+    writer.writerow(["Field", "Value"])
+    
+    # Basic data
+    writer.writerow(["ID", analysis["id"]])
+    writer.writerow(["Resume", analysis["resume_filename"]])
+    writer.writerow(["Job Description", analysis["jd_filename"]])
+    writer.writerow(["Final Score", f"{analysis['final_score']}%"])
+    writer.writerow(["Verdict", analysis["verdict"]])
+    writer.writerow(["Analysis Date", analysis["timestamp"]])
+    
+    output.seek(0)
+    content = output.getvalue().encode('utf-8')
+    
+    return StreamingResponse(
+        io.BytesIO(content),
+        media_type="text/csv",
+        headers={
+            "Content-Disposition": f"attachment; filename=analysis_result_{analysis['id']}.csv",
+            "Content-Length": str(len(content))
+        }
+    )
+
+def download_txt_result(analysis: dict):
+    """Generate text report download"""
+    report_lines = [
+        "RESUME ANALYSIS REPORT",
+        "=" * 50,
+        "",
+        f"Analysis ID: {analysis['id']}",
+        f"Resume: {analysis['resume_filename']}",
+        f"Job Description: {analysis['jd_filename']}", 
+        f"Analysis Date: {analysis['timestamp']}",
+        "",
+        "RESULTS",
+        "=" * 20,
+        "",
+        f"Final Score: {analysis['final_score']}%",
+        f"Verdict: {analysis['verdict']}",
+        "",
+        "=" * 50,
+        f"Generated on: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}",
+        "Resume Analysis System v4.0.0"
+    ]
+    
+    report = "\n".join(report_lines)
+    content = report.encode('utf-8')
+    
+    return StreamingResponse(
+        io.BytesIO(content),
+        media_type="text/plain",
+        headers={
+            "Content-Disposition": f"attachment; filename=analysis_report_{analysis['id']}.txt",
+            "Content-Length": str(len(content))
+        }
+    )
+
+# =============================================================================
+# SYSTEM HEALTH AND MONITORING
+# =============================================================================
+
+@app.get("/health")
+async def health_check():
+    """Comprehensive health check endpoint"""
+    
+    health_status = {
+        "status": "healthy",
+        "service": "resume-relevance-system", 
+        "version": "4.0.0",
+        "environment": settings.environment,
+        "timestamp": datetime.now(timezone.utc).isoformat()
+    }
+    
+    # Component status
+    components = {
+        "basic_analysis": "active" if MAIN_ANALYSIS_AVAILABLE else "mock",
+        "job_parsing": "active" if JOB_PARSING_AVAILABLE else "unavailable",
+        "database": "active" if DATABASE_AVAILABLE else "unavailable",
+        "enhanced_features": "active" if JOB_PARSING_AVAILABLE else "basic_only",
+        "download_features": "active",
+        "pdf_generation": "active" if PDF_AVAILABLE else "unavailable"
+    }
+    
+    # Endpoint status
+    endpoints = {
+        "analyze": "active",
+        "analytics": "active" if DATABASE_AVAILABLE else "limited",
+        "history": "active" if DATABASE_AVAILABLE else "unavailable", 
+        "dashboard": "active",
+        "downloads": "active" if DATABASE_AVAILABLE else "unavailable"
+    }
+    
+    # Database health check
+    if DATABASE_AVAILABLE:
+        try:
+            db_stats = get_database_stats()
+            components["database_stats"] = db_stats
+        except Exception as e:
+            components["database"] = f"error: {str(e)}"
+            health_status["status"] = "degraded"
+    
+    health_status.update({
+        "components": components,
+        "endpoints": endpoints
+    })
+    
+    return health_status
+
+@app.get("/api/system/stats")
+async def get_system_stats(user: str = Depends(verify_team_credentials)):
+    """Get comprehensive system statistics - admin only"""
+    
+    stats = {
+        "system": {
+            "version": "4.0.0",
+            "environment": settings.environment,
+            "debug_mode": settings.debug,
+            "uptime_seconds": time.time() - app.state.start_time if hasattr(app.state, 'start_time') else 0
+        },
+        "features": {
+            "enhanced_analysis": JOB_PARSING_AVAILABLE,
+            "main_engine": MAIN_ANALYSIS_AVAILABLE,
+            "database": DATABASE_AVAILABLE,
+            "pdf_export": PDF_AVAILABLE
+        }
+    }
+    
+    if DATABASE_AVAILABLE:
+        try:
+            stats["database"] = get_database_stats()
+            stats["analytics"] = get_analytics_summary()
+        except Exception as e:
+            stats["database_error"] = str(e)
+    
+    return stats
+
+# =============================================================================
+# DASHBOARD WITH PRODUCTION FEATURES
+# =============================================================================
+
+@app.get("/dashboard", response_class=HTMLResponse)
+async def dashboard_home():
+    """Enhanced production dashboard"""
+    
+    # Get system status
+    db_status = "active" if DATABASE_AVAILABLE else "unavailable"
+    enhanced_status = "active" if JOB_PARSING_AVAILABLE else "unavailable"
+    main_engine_status = "active" if MAIN_ANALYSIS_AVAILABLE else "mock"
+    
+    # Simple dashboard template
+    return f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Resume Analysis Dashboard - Production</title>
+        <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+        <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+        <style>
+            .dashboard-header {{ 
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                color: white; 
+                box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            }}
+            .stat-card {{ 
+                transition: all 0.3s ease; 
+                border: none;
+                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            }}
+            .stat-card:hover {{ transform: translateY(-5px); }}
+            .status-badge {{ font-size: 0.75rem; }}
+            .environment-prod {{ background: #28a745 !important; }}
+            .environment-dev {{ background: #ffc107 !important; color: #000; }}
+        </style>
+    </head>
+    <body>
+        <nav class="navbar navbar-expand-lg dashboard-header">
+            <div class="container-fluid">
+                <a class="navbar-brand" href="#">
+                    <i class="fas fa-chart-line me-2"></i>Resume Analysis Dashboard
+                </a>
+                <div class="navbar-nav ms-auto">
+                    <span class="badge environment-{settings.environment} me-2">
+                        {settings.environment.upper()}
+                    </span>
+                    <span class="badge bg-{'success' if DATABASE_AVAILABLE else 'danger'} me-2">
+                        DB: {db_status}
+                    </span>
+                    <span class="badge bg-{'success' if MAIN_ANALYSIS_AVAILABLE else 'warning'} me-2">
+                        Engine: {main_engine_status}
+                    </span>
+                    <span class="badge bg-{'success' if JOB_PARSING_AVAILABLE else 'warning'} me-2">
+                        AI: {enhanced_status}
+                    </span>
+                    <a href="http://localhost:8501" class="btn btn-light btn-sm">
+                        <i class="fas fa-external-link-alt me-1"></i>Streamlit
+                    </a>
+                </div>
+            </div>
+        </nav>
+        
+        <div class="container-fluid mt-4">
+            <!-- System Status Alert -->
+            {'<div class="alert alert-info"><i class="fas fa-info-circle me-2"></i>Running in MOCK MODE - Install main analysis engine for real results</div>' if not MAIN_ANALYSIS_AVAILABLE else ''}
+            {'<div class="alert alert-warning"><i class="fas fa-exclamation-triangle me-2"></i>Database unavailable - Limited functionality</div>' if not DATABASE_AVAILABLE else ''}
+            
+            <!-- Statistics Cards -->
+            <div class="row mb-4">
+                <div class="col-xl-3 col-md-6">
+                    <div class="card stat-card bg-primary text-white">
+                        <div class="card-body text-center">
+                            <i class="fas fa-file-alt fa-2x mb-2"></i>
+                            <h3 id="totalAnalyses">-</h3>
+                            <p class="mb-0">Total Analyses</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-xl-3 col-md-6">
+                    <div class="card stat-card bg-success text-white">
+                        <div class="card-body text-center">
+                            <i class="fas fa-chart-line fa-2x mb-2"></i>
+                            <h3 id="avgScore">-</h3>
+                            <p class="mb-0">Average Score</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-xl-3 col-md-6">
+                    <div class="card stat-card bg-warning text-white">
+                        <div class="card-body text-center">
+                            <i class="fas fa-star fa-2x mb-2"></i>
+                            <h3 id="highMatches">-</h3>
+                            <p class="mb-0">High Matches</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-xl-3 col-md-6">
+                    <div class="card stat-card bg-info text-white">
+                        <div class="card-body text-center">
+                            <i class="fas fa-percentage fa-2x mb-2"></i>
+                            <h3 id="successRate">-</h3>
+                            <p class="mb-0">Success Rate</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Quick Actions -->
+            <div class="row">
+                <div class="col-md-12">
+                    <div class="card">
+                        <div class="card-header">
+                            <h5><i class="fas fa-bolt me-2"></i>Quick Actions</h5>
+                        </div>
+                        <div class="card-body">
+                            <div class="row">
+                                <div class="col-md-3">
+                                    <a href="http://localhost:8501" class="btn btn-primary btn-lg w-100 mb-2">
+                                        <i class="fas fa-upload me-2"></i>Upload & Analyze
+                                    </a>
+                                </div>
+                                <div class="col-md-3">
+                                    <button class="btn btn-success btn-lg w-100 mb-2" onclick="refreshData()">
+                                        <i class="fas fa-sync me-2"></i>Refresh Data
+                                    </button>
+                                </div>
+                                <div class="col-md-3">
+                                    <a href="/docs" class="btn btn-info btn-lg w-100 mb-2" target="_blank">
+                                        <i class="fas fa-book me-2"></i>API Docs
+                                    </a>
+                                </div>
+                                <div class="col-md-3">
+                                    <a href="/health" class="btn btn-secondary btn-lg w-100 mb-2" target="_blank">
+                                        <i class="fas fa-heartbeat me-2"></i>Health Check
+                                    </a>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+        <script>
+            const DATABASE_AVAILABLE = {str(DATABASE_AVAILABLE).lower()};
+            
+            function loadDashboardData() {{
+                if (!DATABASE_AVAILABLE) {{
+                    document.getElementById('totalAnalyses').textContent = 'N/A';
+                    document.getElementById('avgScore').textContent = 'N/A';
+                    document.getElementById('highMatches').textContent = 'N/A';
+                    document.getElementById('successRate').textContent = 'N/A';
+                    return;
+                }}
+                
+                fetch('/analytics')
+                    .then(response => response.json())
+                    .then(data => {{
+                        document.getElementById('totalAnalyses').textContent = data.total_analyses || 0;
+                        document.getElementById('avgScore').textContent = (data.avg_score || 0).toFixed(1) + '%';
+                        document.getElementById('highMatches').textContent = data.high_matches || 0;
+                        document.getElementById('successRate').textContent = (data.success_rate || 0).toFixed(1) + '%';
+                    }})
+                    .catch(error => {{
+                        console.error('Analytics error:', error);
+                        ['totalAnalyses', 'avgScore', 'highMatches', 'successRate'].forEach(id => {{
+                            document.getElementById(id).textContent = 'Error';
+                        }});
+                    }});
+            }}
+            
+            function refreshData() {{
+                const btn = event.target;
+                const originalText = btn.innerHTML;
+                btn.innerHTML = '<i class="fas fa-spinner fa-spin me-2"></i>Refreshing...';
+                btn.disabled = true;
+                
+                loadDashboardData();
+                
+                setTimeout(() => {{
+                    btn.innerHTML = originalText;
+                    btn.disabled = false;
+                }}, 2000);
+            }}
+            
+            // Auto-load data
+            document.addEventListener('DOMContentLoaded', loadDashboardData);
+            
+            // Auto-refresh every 5 minutes
+            setInterval(loadDashboardData, 300000);
+        </script>
+    </body>
+    </html>
+    """
+
+# =============================================================================
+# APPLICATION STARTUP - FIXED VERSION
+# =============================================================================
+
+def create_app():
+    """Factory function to create the FastAPI app"""
+    # Record start time
+    app.state.start_time = time.time()
+    
+    logger.info("🚀 Starting Production Resume Relevance Check System...")
+    logger.info(f"📊 Dashboard: http://{settings.api_host}:{settings.api_port}/dashboard")
+    logger.info(f"📋 Streamlit: http://localhost:8501 (start separately)")  
+    logger.info(f"📄 API Docs: http://{settings.api_host}:{settings.api_port}/docs")
+    logger.info(f"🔍 Health Check: http://{settings.api_host}:{settings.api_port}/health")
+    logger.info(f"💾 Database: {'✅ Active' if DATABASE_AVAILABLE else '❌ Not Available'}")
+    logger.info(f"🧠 Enhanced AI: {'✅ Active' if JOB_PARSING_AVAILABLE else '❌ Not Available'}")    
+    logger.info(f"🌍 Environment: {settings.environment}")
+    
+    return app
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Create the app using factory function
+    application = create_app()
+    
+    # Production-grade server configuration - FIXED
+    uvicorn.run(
+        "app:app",  # This fixes the import string warning
+        host=settings.api_host,
+        port=settings.api_port,
+        workers=1,  # Single worker for development
+        log_level="info" if settings.environment == "production" else "debug",
+        access_log=settings.environment == "development",
+        reload=settings.environment == "development" and settings.debug
+    )

database.py

@@ -0,0 +1,904 @@
+# database.py - FIXED DATABASE with proper migration order
+import sqlite3
+from datetime import datetime, timezone
+from typing import List, Optional, Dict, Any
+import json
+import threading
+import contextlib
+import time
+import os
+from pathlib import Path
+from dataclasses import dataclass
+import logging
+from functools import wraps
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class AnalysisResult:
+    """Data class to represent analysis results with proper typing"""
+    id: int
+    resume_filename: str
+    jd_filename: str
+    final_score: float
+    verdict: str
+    timestamp: datetime
+    matched_skills: str = ""
+    missing_skills: str = ""
+    hard_match_score: Optional[float] = None
+    semantic_score: Optional[float] = None
+    
+    def __post_init__(self):
+        """Set fallback values after initialization"""
+        if self.hard_match_score is None:
+            self.hard_match_score = self.final_score
+        if self.semantic_score is None:
+            self.semantic_score = self.final_score
+
+class DatabaseConfig:
+    """Database configuration with production settings"""
+    def __init__(self):
+        self.db_path = os.getenv('DATABASE_PATH', 'resume_analysis.db')
+        self.timeout = float(os.getenv('DATABASE_TIMEOUT', '30.0'))
+        self.max_retries = int(os.getenv('DATABASE_MAX_RETRIES', '3'))
+        self.retry_delay = float(os.getenv('DATABASE_RETRY_DELAY', '0.5'))
+        self.enable_wal = os.getenv('DATABASE_ENABLE_WAL', 'true').lower() == 'true'
+        self.backup_enabled = os.getenv('DATABASE_BACKUP_ENABLED', 'true').lower() == 'true'
+
+config = DatabaseConfig()
+
+# Thread lock for database operations
+db_lock = threading.RLock()
+
+def retry_on_db_error(max_retries: int = None):
+    """Decorator for retrying database operations on failure"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            retries = max_retries or config.max_retries
+            last_exception = None
+            
+            for attempt in range(retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
+                    last_exception = e
+                    if attempt < retries:
+                        wait_time = config.retry_delay * (2 ** attempt)
+                        logger.warning(f"Database operation failed (attempt {attempt + 1}/{retries + 1}): {e}. Retrying in {wait_time}s...")
+                        time.sleep(wait_time)
+                    else:
+                        logger.error(f"Database operation failed after {retries + 1} attempts: {e}")
+                        
+            raise last_exception
+        return wrapper
+    return decorator
+
+@contextlib.contextmanager
+def get_db_connection():
+    """Production-grade database connection with comprehensive error handling"""
+    conn = None
+    try:
+        with db_lock:
+            # Ensure database directory exists
+            db_dir = Path(config.db_path).parent
+            db_dir.mkdir(parents=True, exist_ok=True)
+            
+            conn = sqlite3.connect(
+                config.db_path, 
+                timeout=config.timeout,
+                check_same_thread=False,
+                isolation_level=None  # Autocommit mode
+            )
+            
+            # Set production-grade pragmas
+            if config.enable_wal:
+                conn.execute('PRAGMA journal_mode=WAL;')
+            conn.execute('PRAGMA synchronous=NORMAL;')
+            conn.execute('PRAGMA busy_timeout=30000;')
+            conn.execute('PRAGMA foreign_keys=ON;')
+            conn.execute('PRAGMA cache_size=-64000;')
+            conn.execute('PRAGMA temp_store=MEMORY;')
+            
+            # Ensure schema is up to date
+            migrate_db_schema(conn)
+            yield conn
+            
+    except sqlite3.OperationalError as e:
+        error_msg = str(e).lower()
+        if "locked" in error_msg or "busy" in error_msg:
+            logger.warning(f"Database busy/locked: {e}")
+            raise
+        else:
+            logger.error(f"Database operational error: {e}")
+            raise
+    except Exception as e:
+        logger.error(f"Unexpected database error: {e}")
+        raise
+    finally:
+        if conn:
+            try:
+                conn.close()
+            except Exception as e:
+                logger.error(f"Error closing database connection: {e}")
+
+def migrate_db_schema(conn: sqlite3.Connection):
+    """FIXED schema migration with proper ordering"""
+    try:
+        cursor = conn.cursor()
+        
+        # Create version tracking table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER PRIMARY KEY,
+                applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        
+        # Get current schema version
+        cursor.execute('SELECT MAX(version) FROM schema_version')
+        result = cursor.fetchone()
+        current_version = result[0] if result and result[0] else 0
+        
+        # FIXED: Proper migration order
+        migrations = [
+            (1, create_initial_schema),
+            (2, add_enhanced_columns),  # Add columns first
+            (3, create_indexes),        # Then create indexes
+            (4, add_performance_optimizations)
+        ]
+        
+        for version, migration_func in migrations:
+            if current_version < version:
+                logger.info(f"Applying migration version {version}")
+                try:
+                    migration_func(cursor)
+                    cursor.execute('INSERT INTO schema_version (version) VALUES (?)', (version,))
+                    conn.commit()
+                    logger.info(f"✅ Migration version {version} completed successfully")
+                except Exception as e:
+                    logger.error(f"❌ Migration version {version} failed: {e}")
+                    conn.rollback()
+                    # For development, we'll continue with a simplified approach
+                    if version <= 2:  # Critical migrations
+                        raise
+                    else:  # Optional migrations can be skipped
+                        logger.warning(f"Skipping optional migration {version}")
+                        continue
+        
+    except Exception as e:
+        logger.error(f"Schema migration failed: {e}")
+        # For existing databases, try to create a basic working schema
+        try:
+            create_basic_working_schema(cursor)
+            conn.commit()
+            logger.info("✅ Created basic working schema as fallback")
+        except Exception as fallback_error:
+            logger.error(f"Fallback schema creation failed: {fallback_error}")
+            raise e
+
+def create_basic_working_schema(cursor: sqlite3.Cursor):
+    """Create a basic working schema for existing databases"""
+    # Check what exists and create missing tables
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+    existing_tables = [row[0] for row in cursor.fetchall()]
+    
+    if 'analysis_results' not in existing_tables:
+        cursor.execute('''
+            CREATE TABLE analysis_results (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                resume_filename TEXT NOT NULL,
+                jd_filename TEXT NOT NULL,
+                final_score REAL DEFAULT 0,
+                verdict TEXT DEFAULT 'Unknown',
+                hard_match_score REAL DEFAULT 0,
+                semantic_score REAL DEFAULT 0,
+                matched_skills TEXT DEFAULT '[]',
+                missing_skills TEXT DEFAULT '[]',
+                full_result TEXT DEFAULT '{}',
+                processing_time REAL DEFAULT 0,
+                analysis_mode TEXT DEFAULT 'standard',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+    else:
+        # Add missing columns to existing table
+        cursor.execute("PRAGMA table_info(analysis_results)")
+        existing_columns = {info[1] for info in cursor.fetchall()}
+        
+        columns_to_add = [
+            ('hard_match_score', 'REAL DEFAULT 0'),
+            ('semantic_score', 'REAL DEFAULT 0'),
+            ('matched_skills', 'TEXT DEFAULT "[]"'),
+            ('missing_skills', 'TEXT DEFAULT "[]"'),
+            ('full_result', 'TEXT DEFAULT "{}"'),
+            ('processing_time', 'REAL DEFAULT 0'),
+            ('analysis_mode', 'TEXT DEFAULT "standard"'),
+            ('created_at', 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP'),
+            ('updated_at', 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP')
+        ]
+        
+        for column_name, column_def in columns_to_add:
+            if column_name not in existing_columns:
+                try:
+                    cursor.execute(f'ALTER TABLE analysis_results ADD COLUMN {column_name} {column_def}')
+                    logger.info(f"Added column: {column_name}")
+                except sqlite3.OperationalError as e:
+                    if "duplicate column name" not in str(e).lower():
+                        logger.warning(f"Could not add column {column_name}: {e}")
+    
+    # Create other essential tables
+    if 'analytics_summary' not in existing_tables:
+        cursor.execute('''
+            CREATE TABLE analytics_summary (
+                id INTEGER PRIMARY KEY DEFAULT 1,
+                total_analyses INTEGER DEFAULT 0,
+                avg_score REAL DEFAULT 0,
+                high_matches INTEGER DEFAULT 0,
+                medium_matches INTEGER DEFAULT 0,
+                low_matches INTEGER DEFAULT 0,
+                last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        cursor.execute('INSERT OR IGNORE INTO analytics_summary (id) VALUES (1)')
+
+def create_initial_schema(cursor: sqlite3.Cursor):
+    """Initial database schema creation"""
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS analysis_results (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            resume_filename TEXT NOT NULL,
+            jd_filename TEXT NOT NULL,
+            final_score REAL DEFAULT 0,
+            verdict TEXT DEFAULT 'Unknown',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS analytics_summary (
+            id INTEGER PRIMARY KEY DEFAULT 1,
+            total_analyses INTEGER DEFAULT 0,
+            avg_score REAL DEFAULT 0,
+            high_matches INTEGER DEFAULT 0,
+            medium_matches INTEGER DEFAULT 0,
+            low_matches INTEGER DEFAULT 0,
+            last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS screening_tests (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            test_id TEXT UNIQUE NOT NULL,
+            test_number INTEGER,
+            job_title TEXT,
+            company_name TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            total_candidates INTEGER DEFAULT 0,
+            qualified_candidates INTEGER DEFAULT 0,
+            status TEXT DEFAULT 'active'
+        )
+    ''')
+    
+    # Insert default analytics row
+    cursor.execute('INSERT OR IGNORE INTO analytics_summary (id) VALUES (1)')
+
+def add_enhanced_columns(cursor: sqlite3.Cursor):
+    """Add enhanced analysis columns - FIXED ORDER"""
+    # Check existing columns first
+    cursor.execute("PRAGMA table_info(analysis_results)")
+    existing_columns = {info[1] for info in cursor.fetchall()}
+    
+    new_columns = [
+        ('hard_match_score', 'REAL DEFAULT 0'),
+        ('semantic_score', 'REAL DEFAULT 0'),
+        ('matched_skills', 'TEXT DEFAULT "[]"'),
+        ('missing_skills', 'TEXT DEFAULT "[]"'),
+        ('full_result', 'TEXT DEFAULT "{}"'),
+        ('processing_time', 'REAL DEFAULT 0'),
+        ('analysis_mode', 'TEXT DEFAULT "standard"')
+    ]
+    
+    for column_name, column_def in new_columns:
+        if column_name not in existing_columns:
+            try:
+                cursor.execute(f'ALTER TABLE analysis_results ADD COLUMN {column_name} {column_def}')
+                logger.info(f"Added column: {column_name}")
+            except sqlite3.OperationalError as e:
+                if "duplicate column name" not in str(e).lower():
+                    logger.warning(f"Could not add column {column_name}: {e}")
+
+def create_indexes(cursor: sqlite3.Cursor):
+    """Create performance indexes - FIXED to ensure columns exist"""
+    # First, check what columns actually exist
+    cursor.execute("PRAGMA table_info(analysis_results)")
+    existing_columns = {info[1] for info in cursor.fetchall()}
+    
+    # Only create indexes for columns that exist
+    potential_indexes = [
+        ('idx_id', 'analysis_results', 'id'),
+        ('idx_final_score', 'analysis_results', 'final_score'),
+        ('idx_verdict', 'analysis_results', 'verdict'),
+        ('idx_resume_filename', 'analysis_results', 'resume_filename'),
+        ('idx_jd_filename', 'analysis_results', 'jd_filename')
+    ]
+    
+    # Add timestamp index only if column exists
+    if 'created_at' in existing_columns:
+        potential_indexes.append(('idx_created_at', 'analysis_results', 'created_at'))
+        potential_indexes.append(('idx_composite_score_date', 'analysis_results', 'final_score, created_at'))
+    
+    for index_name, table_name, columns in potential_indexes:
+        try:
+            # Check if all columns in the index exist
+            index_columns = [col.strip() for col in columns.split(',')]
+            if all(col in existing_columns for col in index_columns):
+                cursor.execute(f'CREATE INDEX IF NOT EXISTS {index_name} ON {table_name}({columns})')
+                logger.debug(f"Created index: {index_name}")
+            else:
+                logger.warning(f"Skipping index {index_name} - required columns not found")
+        except sqlite3.OperationalError as e:
+            logger.warning(f"Could not create index {index_name}: {e}")
+
+def add_performance_optimizations(cursor: sqlite3.Cursor):
+    """Add triggers and additional optimizations"""
+    try:
+        # Check if created_at and updated_at columns exist
+        cursor.execute("PRAGMA table_info(analysis_results)")
+        existing_columns = {info[1] for info in cursor.fetchall()}
+        
+        if 'updated_at' in existing_columns:
+            # Update timestamp trigger
+            cursor.execute('''
+                CREATE TRIGGER IF NOT EXISTS update_analysis_timestamp 
+                AFTER UPDATE ON analysis_results
+                FOR EACH ROW
+                BEGIN
+                    UPDATE analysis_results 
+                    SET updated_at = datetime('now') 
+                    WHERE id = NEW.id;
+                END
+            ''')
+            logger.debug("Created update timestamp trigger")
+    except sqlite3.OperationalError as e:
+        logger.warning(f"Could not create performance optimizations: {e}")
+
+@retry_on_db_error()
+def init_database():
+    """Initialize database with enhanced error handling and logging"""
+    try:
+        with get_db_connection() as conn:
+            logger.info("Database initialized successfully")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Database initialization failed: {e}")
+        # Try to create a basic schema as fallback
+        try:
+            conn = sqlite3.connect(config.db_path, timeout=config.timeout)
+            cursor = conn.cursor()
+            create_basic_working_schema(cursor)
+            conn.commit()
+            conn.close()
+            logger.info("✅ Created fallback database schema")
+            return True
+        except Exception as fallback_error:
+            logger.error(f"Fallback database creation failed: {fallback_error}")
+            raise e
+
+@retry_on_db_error()
+def save_analysis_result(analysis_data: dict, resume_filename: str, jd_filename: str) -> bool:
+    """Enhanced save operation with better data extraction and validation"""
+    try:
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Extract and validate data
+            extracted_data = _extract_analysis_data(analysis_data)
+            processing_time = analysis_data.get('processing_info', {}).get('processing_time', 0)
+            analysis_mode = 'enhanced' if 'enhanced_analysis' in analysis_data else 'standard'
+            
+            # Check what columns exist before inserting
+            cursor.execute("PRAGMA table_info(analysis_results)")
+            existing_columns = {info[1] for info in cursor.fetchall()}
+            
+            # Base columns that should always exist
+            base_columns = ['resume_filename', 'jd_filename', 'final_score', 'verdict']
+            base_values = [
+                str(resume_filename),
+                str(jd_filename), 
+                extracted_data['final_score'],
+                extracted_data['verdict']
+            ]
+            
+            # Add optional columns if they exist
+            optional_columns = [
+                ('hard_match_score', extracted_data['hard_match_score']),
+                ('semantic_score', extracted_data['semantic_score']),
+                ('matched_skills', json.dumps(extracted_data['matched_skills'])),
+                ('missing_skills', json.dumps(extracted_data['missing_skills'])),
+                ('full_result', json.dumps(analysis_data)),
+                ('processing_time', processing_time),
+                ('analysis_mode', analysis_mode),
+                ('created_at', 'datetime("now")'),
+                ('updated_at', 'datetime("now")')
+            ]
+            
+            additional_columns = []
+            additional_values = []
+            
+            for col_name, col_value in optional_columns:
+                if col_name in existing_columns:
+                    additional_columns.append(col_name)
+                    if col_name in ['created_at', 'updated_at']:
+                        additional_values.append('datetime("now")')
+                    else:
+                        additional_values.append('?')
+                        base_values.append(col_value)
+            
+            all_columns = base_columns + additional_columns
+            
+            # Build the INSERT query
+            placeholders = ['?'] * len(base_columns) + additional_values
+            query = f'''
+                INSERT INTO analysis_results ({', '.join(all_columns)})
+                VALUES ({', '.join(placeholders)})
+            '''
+            
+            cursor.execute(query, base_values)
+            conn.commit()
+            
+            # Update analytics asynchronously
+            _update_analytics_async(conn)
+            
+            logger.info(f"Analysis result saved: {resume_filename} - Score: {extracted_data['final_score']}")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Error saving analysis result: {e}")
+        return False
+
+def _extract_analysis_data(analysis_data: dict) -> Dict[str, Any]:
+    """Extract and normalize analysis data from different formats"""
+    default_data = {
+        'final_score': 0.0,
+        'verdict': 'Analysis Completed',
+        'hard_match_score': 0.0,
+        'semantic_score': 0.0,
+        'matched_skills': [],
+        'missing_skills': []
+    }
+    
+    try:
+        # Enhanced analysis format
+        if 'enhanced_analysis' in analysis_data and 'relevance_scoring' in analysis_data['enhanced_analysis']:
+            scoring = analysis_data['enhanced_analysis']['relevance_scoring']
+            return {
+                'final_score': float(scoring.get('overall_score', 0)),
+                'verdict': str(scoring.get('fit_verdict', 'Unknown')),
+                'hard_match_score': float(scoring.get('skill_match_score', 0)),
+                'semantic_score': float(scoring.get('experience_match_score', 0)),
+                'matched_skills': list(scoring.get('matched_must_have', [])),
+                'missing_skills': list(scoring.get('missing_must_have', []))
+            }
+        
+        # Standard analysis format
+        elif 'relevance_analysis' in analysis_data:
+            relevance = analysis_data['relevance_analysis']
+            output = analysis_data.get('output_generation', {})
+            
+            return {
+                'final_score': float(relevance['step_3_scoring_verdict']['final_score']),
+                'verdict': str(output.get('verdict', 'Unknown')),
+                'hard_match_score': float(relevance['step_1_hard_match']['coverage_score']),
+                'semantic_score': float(relevance['step_2_semantic_match']['experience_alignment_score']),
+                'matched_skills': list(relevance['step_1_hard_match'].get('matched_skills', [])),
+                'missing_skills': list(output.get('missing_skills', []))
+            }
+        
+        return default_data
+        
+    except Exception as e:
+        logger.warning(f"Error extracting analysis data, using defaults: {e}")
+        return default_data
+
+def _update_analytics_async(conn: sqlite3.Connection):
+    """Update analytics in a non-blocking way"""
+    try:
+        update_analytics_summary_internal(conn)
+    except Exception as e:
+        logger.warning(f"Analytics update failed (non-critical): {e}")
+
+@retry_on_db_error()
+def get_analysis_history(limit: int = 50, offset: int = 0) -> List[AnalysisResult]:
+    """Enhanced history retrieval with pagination and performance optimization"""
+    try:
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Check what columns exist
+            cursor.execute("PRAGMA table_info(analysis_results)")
+            existing_columns = {info[1] for info in cursor.fetchall()}
+            
+            # Build query based on available columns
+            base_columns = ['id', 'resume_filename', 'jd_filename', 'final_score', 'verdict']
+            optional_columns = ['created_at', 'matched_skills', 'missing_skills', 'hard_match_score', 'semantic_score']
+            
+            select_columns = base_columns[:]
+            for col in optional_columns:
+                if col in existing_columns:
+                    select_columns.append(col)
+            
+            # Use appropriate ORDER BY
+            order_column = 'created_at' if 'created_at' in existing_columns else 'id'
+            
+            query = f'''
+                SELECT {', '.join(select_columns)}
+                FROM analysis_results 
+                ORDER BY {order_column} DESC 
+                LIMIT ? OFFSET ?
+            '''
+            
+            cursor.execute(query, (limit, offset))
+            
+            results = []
+            for row in cursor.fetchall():
+                try:
+                    # Map values to column names
+                    row_dict = dict(zip(select_columns, row))
+                    
+                    # Handle timestamp
+                    if 'created_at' in row_dict and row_dict['created_at']:
+                        timestamp = _parse_timestamp(row_dict['created_at'])
+                    else:
+                        timestamp = datetime.now(timezone.utc)
+                    
+                    result = AnalysisResult(
+                        id=row_dict['id'],
+                        resume_filename=str(row_dict.get('resume_filename', 'Unknown')),
+                        jd_filename=str(row_dict.get('jd_filename', 'Unknown')),
+                        final_score=float(row_dict.get('final_score', 0)),
+                        verdict=str(row_dict.get('verdict', 'Unknown')),
+                        timestamp=timestamp,
+                        matched_skills=row_dict.get('matched_skills', '[]'),
+                        missing_skills=row_dict.get('missing_skills', '[]'),
+                        hard_match_score=float(row_dict.get('hard_match_score', row_dict.get('final_score', 0))),
+                        semantic_score=float(row_dict.get('semantic_score', row_dict.get('final_score', 0)))
+                    )
+                    results.append(result)
+                    
+                except Exception as row_error:
+                    logger.warning(f"Skipping malformed row: {row_error}")
+                    continue
+            
+            logger.info(f"Retrieved {len(results)} analysis results from history")
+            return results
+            
+    except Exception as e:
+        logger.error(f"Error getting analysis history: {e}")
+        return []
+
+def _parse_timestamp(timestamp_str: str) -> datetime:
+    """Parse timestamp with multiple format support"""
+    if not timestamp_str:
+        return datetime.now(timezone.utc)
+    
+    formats = [
+        '%Y-%m-%d %H:%M:%S',
+        '%Y-%m-%d %H:%M:%S.%f',
+        '%Y-%m-%dT%H:%M:%S',
+        '%Y-%m-%dT%H:%M:%S.%f',
+        '%Y-%m-%dT%H:%M:%S.%fZ'
+    ]
+    
+    for fmt in formats:
+        try:
+            return datetime.strptime(str(timestamp_str), fmt)
+        except ValueError:
+            continue
+    
+    logger.warning(f"Could not parse timestamp: {timestamp_str}")
+    return datetime.now(timezone.utc)
+
+@retry_on_db_error()
+def get_analytics_summary() -> Dict[str, Any]:
+    """Enhanced analytics with better error handling and caching"""
+    try:
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Get comprehensive analytics in a single transaction
+            cursor.execute('''
+                SELECT 
+                    COUNT(*) as total_analyses,
+                    COALESCE(AVG(final_score), 0) as avg_score,
+                    COUNT(CASE WHEN final_score >= 80 THEN 1 END) as high_matches,
+                    COUNT(CASE WHEN final_score >= 60 AND final_score < 80 THEN 1 END) as medium_matches,
+                    COUNT(CASE WHEN final_score < 60 AND final_score > 0 THEN 1 END) as low_matches
+                FROM analysis_results
+            ''')
+            
+            result = cursor.fetchone()
+            
+            total_analyses = result[0] or 0
+            avg_score = round(float(result[1] or 0), 1)
+            high_matches = result[2] or 0
+            medium_matches = result[3] or 0
+            low_matches = result[4] or 0
+            
+            # Calculate success rate
+            success_rate = 0.0
+            if total_analyses > 0:
+                success_rate = round(((high_matches + medium_matches) / total_analyses) * 100, 1)
+            
+            analytics = {
+                'total_analyses': total_analyses,
+                'avg_score': avg_score,
+                'high_matches': high_matches,
+                'medium_matches': medium_matches,
+                'low_matches': low_matches,
+                'success_rate': success_rate,
+                'generated_at': datetime.now(timezone.utc).isoformat()
+            }
+            
+            logger.info(f"Analytics summary generated: {total_analyses} analyses, {avg_score}% avg score")
+            return analytics
+            
+    except Exception as e:
+        logger.error(f"Error getting analytics summary: {e}")
+        return {
+            'total_analyses': 0,
+            'avg_score': 0.0,
+            'high_matches': 0,
+            'medium_matches': 0,
+            'low_matches': 0,
+            'success_rate': 0.0,
+            'error': str(e)
+        }
+
+def update_analytics_summary():
+    """Public method to update analytics summary"""
+    try:
+        with get_db_connection() as conn:
+            update_analytics_summary_internal(conn)
+    except Exception as e:
+        logger.error(f"Error updating analytics summary: {e}")
+
+def update_analytics_summary_internal(conn: sqlite3.Connection):
+    """Internal analytics update with optimized queries"""
+    try:
+        cursor = conn.cursor()
+        
+        # Get analytics in a single query
+        cursor.execute('''
+            SELECT 
+                COUNT(*) as total,
+                COALESCE(AVG(final_score), 0) as avg_score,
+                COUNT(CASE WHEN final_score >= 80 THEN 1 END) as high,
+                COUNT(CASE WHEN final_score >= 60 AND final_score < 80 THEN 1 END) as medium,
+                COUNT(CASE WHEN final_score < 60 AND final_score > 0 THEN 1 END) as low
+            FROM analysis_results
+        ''')
+        
+        result = cursor.fetchone()
+        total, avg_score, high, medium, low = result
+        
+        # Check if analytics_summary table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='analytics_summary'")
+        if cursor.fetchone():
+            cursor.execute('''
+                UPDATE analytics_summary 
+                SET total_analyses = ?, avg_score = ?, high_matches = ?, 
+                    medium_matches = ?, low_matches = ?, last_updated = datetime('now')
+                WHERE id = 1
+            ''', (total, round(avg_score, 1), high, medium, low))
+        
+        conn.commit()
+        logger.debug(f"Analytics updated: {total} total analyses")
+        
+    except Exception as e:
+        logger.error(f"Error updating analytics summary internally: {e}")
+
+def get_recent_analyses(limit: int = 10) -> List[Dict[str, Any]]:
+    """Enhanced recent analyses with better formatting"""
+    try:
+        results = get_analysis_history(limit)
+        
+        return [
+            {
+                "id": result.id,
+                "resume": result.resume_filename,
+                "job_description": result.jd_filename,
+                "score": result.final_score,
+                "verdict": result.verdict,
+                "date": result.timestamp.strftime("%Y-%m-%d %H:%M") if hasattr(result.timestamp, 'strftime') else str(result.timestamp),
+                "matched_skills": result.matched_skills,
+                "missing_skills": result.missing_skills,
+                "hard_match_score": result.hard_match_score,
+                "semantic_score": result.semantic_score
+            }
+            for result in results
+        ]
+        
+    except Exception as e:
+        logger.error(f"Error getting recent analyses: {e}")
+        return []
+
+def backup_database(backup_path: Optional[str] = None) -> bool:
+    """Create database backup"""
+    if not config.backup_enabled:
+        return True
+        
+    try:
+        backup_path = backup_path or f"{config.db_path}.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        with get_db_connection() as source:
+            backup = sqlite3.connect(backup_path)
+            source.backup(backup)
+            backup.close()
+            
+        logger.info(f"Database backed up to: {backup_path}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Database backup failed: {e}")
+        return False
+
+def get_database_stats() -> Dict[str, Any]:
+    """Get comprehensive database statistics"""
+    try:
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Get table sizes
+            cursor.execute("SELECT COUNT(*) FROM analysis_results")
+            analysis_count = cursor.fetchone()[0]
+            
+            # Get database file size
+            db_size = Path(config.db_path).stat().st_size if Path(config.db_path).exists() else 0
+            
+            # Get date range if created_at exists
+            cursor.execute("PRAGMA table_info(analysis_results)")
+            existing_columns = {info[1] for info in cursor.fetchall()}
+            
+            date_range = (None, None)
+            if 'created_at' in existing_columns:
+                cursor.execute("SELECT MIN(created_at), MAX(created_at) FROM analysis_results")
+                date_range = cursor.fetchone()
+            
+            return {
+                "database_path": config.db_path,
+                "database_size_bytes": db_size,
+                "database_size_mb": round(db_size / (1024 * 1024), 2),
+                "analysis_results_count": analysis_count,
+                "earliest_record": date_range[0],
+                "latest_record": date_range[1],
+                "wal_enabled": config.enable_wal,
+                "backup_enabled": config.backup_enabled
+            }
+            
+    except Exception as e:
+        logger.error(f"Error getting database stats: {e}")
+        return {"error": str(e)}
+
+def repair_database():
+    """Enhanced database repair with integrity checking"""
+    try:
+        with get_db_connection() as conn:
+            cursor = conn.cursor()
+            
+            logger.info("Starting database repair and optimization...")
+            
+            # Check integrity
+            cursor.execute('PRAGMA integrity_check')
+            integrity_result = cursor.fetchall()
+            
+            if len(integrity_result) == 1 and integrity_result[0][0] == 'ok':
+                logger.info("✅ Database integrity check passed")
+            else:
+                logger.warning(f"⚠️ Database integrity issues found: {integrity_result}")
+                return False
+            
+            # Vacuum database
+            logger.info("Vacuuming database...")
+            cursor.execute('VACUUM')
+            
+            # Analyze for query optimization
+            logger.info("Analyzing database for optimization...")
+            cursor.execute('ANALYZE')
+            
+            # Update statistics
+            cursor.execute('PRAGMA optimize')
+            
+            logger.info("✅ Database repair and optimization completed")
+            return True
+            
+    except Exception as e:
+        logger.error(f"❌ Database repair failed: {e}")
+        return False
+
+def test_database() -> bool:
+    """Comprehensive database testing suite"""
+    logger.info("🧪 Starting comprehensive database tests...")
+    
+    try:
+        # Test 1: Initialization
+        init_database()
+        logger.info("✅ Database initialization test passed")
+        
+        # Test 2: Save operations
+        test_data = {
+            'enhanced_analysis': {
+                'relevance_scoring': {
+                    'overall_score': 85.5,
+                    'fit_verdict': 'High Suitability',
+                    'skill_match_score': 90.0,
+                    'experience_match_score': 80.5,
+                    'matched_must_have': ['Python', 'JavaScript', 'React'],
+                    'missing_must_have': ['Node.js', 'Docker']
+                }
+            },
+            'processing_info': {'processing_time': 2.5, 'enhanced_features': True}
+        }
+        
+        success = save_analysis_result(test_data, "test_resume.pdf", "test_job.pdf")
+        if not success:
+            raise Exception("Save test failed")
+        logger.info("✅ Save operation test passed")
+        
+        # Test 3: Retrieval operations
+        history = get_analysis_history(10)
+        logger.info(f"✅ History retrieval test passed ({len(history)} records)")
+        
+        # Test 4: Analytics
+        analytics = get_analytics_summary()
+        logger.info("✅ Analytics test passed")
+        
+        logger.info("🎉 All database tests completed successfully!")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Database tests failed: {e}")
+        return False
+
+# Production initialization with better error handling
+def initialize_production_db():
+    """Initialize database for production environment"""
+    try:
+        logger.info("Initializing production database...")
+        
+        # Create database with proper setup
+        init_database()
+        
+        # Create backup if enabled
+        if config.backup_enabled:
+            backup_database()
+        
+        # Run integrity check
+        repair_database()
+        
+        # Log statistics
+        stats = get_database_stats()
+        logger.info(f"Database ready - Size: {stats.get('database_size_mb', 0)}MB, Records: {stats.get('analysis_results_count', 0)}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Production database initialization failed: {e}")
+        return False
+
+# Auto-initialize for production
+if config.db_path and not os.getenv('DISABLE_AUTO_INIT', '').lower() == 'true':
+    try:
+        initialize_production_db()
+        logger.info("🚀 Production database module loaded and initialized")
+    except Exception as e:
+        logger.error(f"⚠️ Database initialization warning: {e}")
+
+if __name__ == "__main__":
+    test_database()

demo_prep.md

@@ -0,0 +1,40 @@
+# Hackathon Demo - Automated Resume Relevance Check System
+
+## 30-Second Elevator Pitch
+"I built an AI-powered resume screening system that goes beyond simple keyword matching. It uses semantic embeddings, fuzzy matching, and NLP to provide intelligent analysis and actionable recommendations."
+
+## Key Demo Points (2 minutes)
+
+### 1. Problem Statement
+- Current ATS systems miss qualified candidates
+- Only basic keyword matching
+- No actionable feedback for improvement
+
+### 2. Our Solution - Advanced AI Stack
+- **Semantic Matching**: Understanding context, not just keywords
+- **Fuzzy Matching**: Catches variations (JS vs JavaScript)
+- **NLP Entity Extraction**: Extracts experience, education, skills
+- **LLM Analysis**: Provides human-like insights
+- **Comprehensive Scoring**: Multi-factor weighted algorithm
+
+### 3. Live Demo Flow
+1. Upload sample resume (show file upload)
+2. Upload job description
+3. Click analyze (show progress bar)
+4. Results breakdown:
+   - Final Score: 78/100
+   - Hard Match: 65% (TF-IDF + keywords)
+   - Semantic Match: 8/10 (AI understanding)
+   - Missing Skills: Docker, Kubernetes
+   - AI Recommendations: Specific next steps
+
+### 4. Business Value
+- **For Companies**: Better candidate screening, reduce false negatives
+- **For Students**: Clear improvement roadmap, skill gap analysis
+- **For Placement Teams**: Data-driven decisions, automated screening
+
+### 5. Technical Highlights
+- Modern tech stack (FastAPI, Streamlit, AI/ML)
+- Scalable architecture (API-first design)
+- Real-time analysis with progress tracking
+- Exportable reports

main.py

@@ -0,0 +1,639 @@
+# main.py - COMPLETE WITH LANGGRAPH + LANGSMITH
+import os
+from dotenv import load_dotenv
+
+import time
+# Load environment variables
+load_dotenv()
+
+# --- Configuration for OpenRouter ---
+LLM_MODEL = "x-ai/grok-4-fast:free"  # Updated model name
+
+# Set environment variables for the OpenAI client to use OpenRouter
+os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENROUTER_API_KEY", "")
+
+# Import all modules - ENHANCED WITH NEW COMPONENTS
+from parsers.pdf_parser import extract_text_pymupdf
+from parsers.docx_parser import extract_text_docx
+from parsers.cleaner import clean_text
+from parsers.section_splitter import split_sections
+from parsers.skill_extractor import extract_skills
+from parsers.jd_parser import parse_jd
+from llm_analysis.llm_analyzer import LLMResumeAnalyzer, test_llm_connection
+
+# ENHANCED COMPONENTS
+try:
+    from matchers.final_scorer import EnhancedResumeScorer
+    ENHANCED_SCORING = True
+    print("✅ Enhanced scoring components loaded")
+except ImportError:
+    print("⚠️ Enhanced components not found, using basic scoring")
+    ENHANCED_SCORING = False
+
+# LANGGRAPH & LANGSMITH COMPONENTS
+try:
+    from llm_analysis.langgraph_pipeline import ResumeAnalysisPipeline
+    from llm_analysis.langsmith_logger import logger, trace_llm_analysis
+    ADVANCED_PIPELINE = True
+    print("✅ LangGraph + LangSmith components loaded")
+except ImportError:
+    print("⚠️ LangGraph/LangSmith not found - install with: pip install langgraph langsmith")
+    ADVANCED_PIPELINE = False
+
+def load_file(file_path):
+    """Load text from various file formats"""
+    if file_path.endswith(".pdf"):
+        return extract_text_pymupdf(file_path)
+    elif file_path.endswith(".docx"):
+        return extract_text_docx(file_path)
+    elif file_path.endswith(".txt"):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    else:
+        raise ValueError("Unsupported file format")
+
+def calculate_basic_scores(resume_skills, jd_skills):
+    """Calculate basic matching scores (fallback)"""
+    if not jd_skills:
+        return {"score": 0, "matched_skills": [], "missing_skills": [], "matched_count": 0, "total_jd_skills": 0}
+    
+    matched_skills = list(set(resume_skills) & set(jd_skills))
+    missing_skills = list(set(jd_skills) - set(resume_skills))
+    
+    coverage_score = len(matched_skills) / len(jd_skills) * 100
+    
+    return {
+        "score": round(coverage_score, 2),
+        "matched_skills": matched_skills,
+        "missing_skills": missing_skills,
+        "matched_count": len(matched_skills),
+        "total_jd_skills": len(jd_skills)
+    }
+
+@trace_llm_analysis if ADVANCED_PIPELINE else lambda x: x  # LangSmith tracing decorator
+def complete_ai_analysis(resume_file, jd_file):
+    """Complete AI-powered resume analysis with LangGraph + LangSmith"""
+    
+    print("🚀 STARTING ENHANCED AI-POWERED RESUME ANALYSIS")
+    if ADVANCED_PIPELINE:
+        print("   🔗 LangGraph: Structured pipeline")
+        print("   🔍 LangSmith: Observability & logging")
+    print("=" * 65)
+    
+    # Start LangSmith trace
+    trace_id = None
+    if ADVANCED_PIPELINE:
+        trace_id = logger.start_trace("complete_resume_analysis", {
+            "resume_file": resume_file,
+            "jd_file": jd_file
+        })
+    
+    # Test LLM connection first
+    if not test_llm_connection():
+        print("⚠️ LLM connection failed, continuing with mock analysis...")
+    
+    try:
+        # Initialize components
+        print("\n🔧 INITIALIZING ENHANCED COMPONENTS...")
+        llm_analyzer = LLMResumeAnalyzer(model=LLM_MODEL)
+        
+        # LangGraph pipeline
+        if ADVANCED_PIPELINE:
+            pipeline = ResumeAnalysisPipeline(model=LLM_MODEL)
+            print("✅ LangGraph pipeline initialized")
+        
+        if ENHANCED_SCORING:
+            enhanced_scorer = EnhancedResumeScorer()
+            print("✅ Enhanced scorer with semantic matching, fuzzy matching, and NLP entities")
+        else:
+            enhanced_scorer = None
+            print("⚠️ Using basic scoring (install enhanced components for full tech stack)")
+        
+        # Step 1: Load and parse files
+        print("\n📄 LOADING FILES...")
+        resume_raw = load_file(resume_file)
+        jd_raw = load_file(jd_file)
+        print(f"✅ Resume loaded: {len(resume_raw)} chars")
+        print(f"✅ JD loaded: {len(jd_raw)} chars")
+        
+        # Step 2: Process resume
+        print("\n🔍 PROCESSING RESUME...")
+        resume_clean = clean_text(resume_raw)
+        resume_sections = split_sections(resume_clean)
+        resume_skills = extract_skills(" ".join(resume_sections.values()))
+        print(f"✅ Resume sections: {list(resume_sections.keys())}")
+        print(f"✅ Resume skills found: {len(resume_skills)}")
+        
+        # Step 3: Process JD
+        print("\n🔍 PROCESSING JOB DESCRIPTION...")
+        jd_data = parse_jd(jd_raw)
+        jd_skills = jd_data["skills"]
+        print(f"✅ JD role: {jd_data['role']}")
+        print(f"✅ JD skills found: {len(jd_skills)}")
+        
+        # Step 4: ENHANCED COMPREHENSIVE SCORING
+        if ENHANCED_SCORING:
+            print("\n🧮 RUNNING COMPREHENSIVE ANALYSIS...")
+            print("   🔍 Hard Match: TF-IDF + keyword matching")
+            print("   🧠 Semantic Match: Embeddings + cosine similarity") 
+            print("   🔄 Fuzzy Match: Skill variations + rapidfuzz")
+            print("   📊 Entity Analysis: spaCy NLP + experience extraction")
+            
+            comprehensive_result = enhanced_scorer.calculate_comprehensive_score(
+                {"raw_text": resume_clean, "skills": resume_skills},
+                {"raw_text": jd_raw, "skills": jd_skills}
+            )
+            
+            basic_scores = {
+                "score": comprehensive_result["breakdown"]["hard_match"]["score"],
+                "matched_skills": comprehensive_result["breakdown"]["hard_match"]["matched_skills"],
+                "missing_skills": comprehensive_result["breakdown"]["hard_match"]["missing_skills"],
+                "matched_count": comprehensive_result["breakdown"]["hard_match"]["matched_count"],
+                "total_jd_skills": comprehensive_result["breakdown"]["hard_match"]["total_jd_skills"]
+            }
+            
+        else:
+            # Fallback to basic scoring
+            print("\n⚙️ CALCULATING BASIC SCORES...")
+            basic_scores = calculate_basic_scores(resume_skills, jd_skills)
+            comprehensive_result = None
+            print(f"✅ Keyword match: {basic_scores['score']:.1f}%")
+            print(f"✅ Matched skills: {basic_scores['matched_count']}/{basic_scores['total_jd_skills']}")
+        
+        # Step 5: LangGraph Structured Pipeline (if available)
+        if ADVANCED_PIPELINE:
+            print("\n🔗 RUNNING LANGGRAPH STRUCTURED PIPELINE...")
+            pipeline_result = pipeline.run_structured_analysis(resume_clean, jd_raw, basic_scores)
+            
+            if pipeline_result.get("pipeline_status") == "completed":
+                llm_analysis = pipeline_result["llm_analysis"]
+                improvement_roadmap = pipeline_result["improvement_roadmap"]
+                print("✅ LangGraph pipeline completed successfully")
+            else:
+                print("⚠️ LangGraph pipeline failed, using fallback analysis")
+                llm_analysis = llm_analyzer.analyze_resume_vs_jd(resume_clean, jd_raw, basic_scores)
+                improvement_roadmap = llm_analyzer.generate_improvement_roadmap(llm_analysis)
+        else:
+            # Standard LLM Analysis
+            print("\n🧠 RUNNING LLM ANALYSIS...")
+            llm_analysis = llm_analyzer.analyze_resume_vs_jd(resume_clean, jd_raw, basic_scores)
+            
+            print("\n🗺️ GENERATING IMPROVEMENT ROADMAP...")
+            improvement_roadmap = llm_analyzer.generate_improvement_roadmap(llm_analysis)
+        
+        # Step 6: Display enhanced results
+        if ENHANCED_SCORING:
+            display_enhanced_results(comprehensive_result, llm_analysis, improvement_roadmap)
+        else:
+            display_structured_results(basic_scores, llm_analysis, improvement_roadmap, {})
+        
+        # Log success metrics (LangSmith)
+        if ADVANCED_PIPELINE and trace_id:
+            logger.log_metrics({
+                "analysis_success": True,
+                "resume_length": len(resume_raw),
+                "jd_length": len(jd_raw),
+                "skills_found": len(resume_skills),
+                "pipeline_status": pipeline_result.get("pipeline_status", "fallback") if ADVANCED_PIPELINE else "standard",
+                "enhanced_scoring": ENHANCED_SCORING
+            })
+            
+            logger.end_trace(trace_id, {
+                "pipeline_status": pipeline_result.get("pipeline_status", "fallback") if ADVANCED_PIPELINE else "standard",
+                "final_score": llm_analysis.get("overall_fit_score", 0)
+            }, "success")
+        
+    except Exception as e:
+        print(f"❌ Analysis failed: {e}")
+        
+        # Log error (LangSmith)
+        if ADVANCED_PIPELINE and trace_id:
+            logger.end_trace(trace_id, {}, "error", str(e))
+            logger.log_metrics({
+                "analysis_success": False,
+                "error": str(e)
+            })
+        
+        import traceback
+        traceback.print_exc()
+
+def display_enhanced_results(comprehensive_result, llm_analysis, roadmap):
+    """Display enhanced results with full tech stack analysis"""
+    
+    print(f"\n{'='*75}")
+    print("🎯 Automated Resume Relevance Check Report (Enhanced)")
+    if ADVANCED_PIPELINE:
+        print("   🔗 Powered by LangGraph + LangSmith")
+    print("=" * 75)
+    
+    # Get breakdown
+    breakdown = comprehensive_result["breakdown"]
+    hard_match = breakdown["hard_match"]
+    semantic_match = breakdown["semantic_match"]
+    fuzzy_match = breakdown["fuzzy_match"]
+    entity_analysis = breakdown["entity_analysis"]
+    
+    # RELEVANCE ANALYSIS - Enhanced 3 Steps
+    print(f"\n📋 RELEVANCE ANALYSIS (Enhanced with Full Tech Stack)")
+    print("-" * 60)
+    
+    # Step 1: Enhanced Hard Match
+    print(f"\n🔍 STEP 1: ENHANCED HARD MATCH")
+    print(f"   📊 TF-IDF Similarity: {hard_match.get('tfidf_similarity', 0):.1f}%")
+    print(f"   🎯 Basic Coverage: {hard_match['basic_coverage']:.1f}%")
+    print(f"   ⚖️  Combined Hard Score: {hard_match['score']:.1f}%")
+    print(f"   ✅ Exact Matches: {hard_match['matched_count']}/{hard_match['total_jd_skills']} skills")
+    print(f"   🔄 Fuzzy Matches: {fuzzy_match['fuzzy_score']} additional skills")
+    
+    # Display matched skills
+    if hard_match['matched_skills']:
+        print(f"   📝 Matched Skills: {', '.join(hard_match['matched_skills'][:8])}")
+        if len(hard_match['matched_skills']) > 8:
+            print(f"      ... and {len(hard_match['matched_skills']) - 8} more")
+    
+    # Display fuzzy matches
+    if fuzzy_match.get('match_details'):
+        print(f"   🔄 Fuzzy Matches Found:")
+        for match in fuzzy_match['match_details'][:3]:
+            print(f"      • {match['jd_skill']} ↔ {match['resume_skill']} ({match['confidence']}%)")
+    
+    # Step 2: Semantic Match with Embeddings
+    print(f"\n🧠 STEP 2: SEMANTIC MATCH (Embeddings + Cosine Similarity)")
+    print(f"   🤖 LLM Experience Score: {llm_analysis.get('overall_fit_score', 0)}/10")
+    print(f"   📊 Embedding Similarity: {semantic_match.get('semantic_score', 0):.1f}%")
+    print(f"   🔍 Context Understanding: {llm_analysis.get('experience_alignment', 'N/A')[:100]}...")
+    
+    # Entity Analysis Results
+    print(f"\n📊 ENTITY ANALYSIS (spaCy NLP):")
+    if entity_analysis.get('experience_years', 0) > 0:
+        print(f"   💼 Experience Detected: {entity_analysis['experience_years']} years")
+    if entity_analysis.get('education', {}).get('degrees'):
+        print(f"   🎓 Education: {', '.join(entity_analysis['education']['degrees'])}")
+    
+    # Step 3: Enhanced Scoring & Verdict
+    final_score = comprehensive_result["final_score"]
+    print(f"\n⚖️ STEP 3: ENHANCED SCORING & VERDICT")
+    print(f"   📐 Weighted Formula: Hard(40%) + Semantic(45%) + Fuzzy(10%) + Experience(3%) + Education(2%)")
+    print(f"   🎯 Component Scores:")
+    print(f"      • Hard Match: {hard_match['score']:.1f}%")
+    print(f"      • Semantic: {semantic_match.get('semantic_score', 0):.1f}%") 
+    print(f"      • Fuzzy Bonus: +{fuzzy_match['fuzzy_score'] * 3:.1f} points")
+    if entity_analysis.get('experience_years', 0) > 0:
+        print(f"      • Experience Bonus: +{min(entity_analysis['experience_years'] * 2, 10):.1f} points")
+    print(f"   🏆 FINAL SCORE: {final_score}/100")
+    
+    # OUTPUT GENERATION
+    print(f"\n📊 OUTPUT GENERATION")
+    print("-" * 50)
+    
+    # Relevance Score
+    print(f"\n🎯 RELEVANCE SCORE: {final_score}/100")
+    
+    # Enhanced Verdict
+    verdict = comprehensive_result["verdict"]
+    print(f"\n🏷️ VERDICT: {verdict}")
+    
+    # Missing Skills Analysis
+    missing_skills = hard_match['missing_skills']
+    print(f"\n❌ MISSING SKILLS/REQUIREMENTS:")
+    for i, skill in enumerate(missing_skills[:8], 1):
+        print(f"   {i}. {skill}")
+    
+    # Critical Gaps from LLM
+    if llm_analysis.get('critical_gaps'):
+        print(f"\n⚠️ CRITICAL GAPS (LLM Analysis):")
+        for i, gap in enumerate(llm_analysis['critical_gaps'][:3], 1):
+            print(f"   {i}. {gap}")
+    
+    # Enhanced Recommendations
+    print(f"\n💡 ENHANCED SUGGESTIONS:")
+    recommendations = comprehensive_result.get("recommendations", [])
+    
+    if roadmap and roadmap.get('immediate_actions'):
+        print(f"\n   📋 IMMEDIATE ACTIONS:")
+        for i, action in enumerate(roadmap['immediate_actions'][:3], 1):
+            print(f"      {i}. {action}")
+    
+    if roadmap and roadmap.get('priority_skills'):
+        print(f"\n   🎯 PRIORITY SKILLS TO LEARN:")
+        for i, skill in enumerate(roadmap['priority_skills'][:5], 1):
+            print(f"      {i}. {skill}")
+    
+    # Tech Stack Recommendations
+    if recommendations:
+        print(f"\n   🔧 TECH STACK RECOMMENDATIONS:")
+        for i, rec in enumerate(recommendations[:3], 1):
+            print(f"      {i}. {rec}")
+    
+    # Final LLM Verdict
+    print(f"\n📋 FINAL RECOMMENDATION:")
+    final_verdict = llm_analysis.get('final_verdict', 'Enhanced analysis completed successfully')
+    if len(final_verdict) > 200:
+        final_verdict = final_verdict[:200] + "..."
+    print(f"   {final_verdict}")
+    
+    # LangSmith Session Summary (if available)
+    if ADVANCED_PIPELINE:
+        print(f"\n🔍 LANGSMITH OBSERVABILITY:")
+        try:
+            session_summary = logger.get_session_summary()
+            print(f"   📊 Total Traces: {session_summary.get('total_traces', 0)}")
+            print(f"   📈 Total Metrics: {session_summary.get('total_metrics', 0)}")
+            print(f"   📁 Session ID: {session_summary.get('session_id', 'N/A')[:8]}...")
+        except:
+            print(f"   📊 Session data available in logs/ directory")
+    
+    print(f"\n{'='*75}")
+
+def display_structured_results(basic_scores, llm_analysis, roadmap, enhanced_skills):
+    """Fallback display for basic scoring (original function)"""
+    
+    print(f"\n{'='*70}")
+    print("🎯 Automated Resume Relevance Check Report")
+    if ADVANCED_PIPELINE:
+        print("   🔗 LangGraph + LangSmith Integration Active")
+    print("=" * 70)
+    
+    # RELEVANCE ANALYSIS - 3 Steps
+    print(f"\n📋 RELEVANCE ANALYSIS")
+    print("-" * 50)
+    
+    # Step 1: Hard Match
+    print(f"\n🔍 STEP 1: HARD MATCH (Keyword & Skill Check)")
+    print(f"   • Exact Matches: {basic_scores['matched_count']}/{basic_scores['total_jd_skills']} skills")
+    print(f"   • Coverage Score: {basic_scores['score']:.1f}%")
+    print(f"   • Matched Skills: {', '.join(basic_scores['matched_skills'][:8])}")
+    if len(basic_scores['matched_skills']) > 8:
+        print(f"     ... and {len(basic_scores['matched_skills']) - 8} more")
+    
+    # Step 2: Semantic Match  
+    experience_fit = llm_analysis.get('overall_fit_score', 0)
+    print(f"\n🧠 STEP 2: SEMANTIC MATCH (LLM Analysis)")
+    print(f"   • Experience Alignment Score: {experience_fit}/10")
+    print(f"   • Context Understanding: {llm_analysis.get('experience_alignment', 'N/A')[:100]}...")
+    
+    # Step 3: Scoring & Verdict
+    hard_match_score = basic_scores['score']
+    semantic_score = experience_fit * 10  # Convert to percentage
+    final_score = (hard_match_score * 0.4) + (semantic_score * 0.6)  # Weighted formula
+    
+    print(f"\n⚖️ STEP 3: SCORING & VERDICT (Weighted Formula)")
+    print(f"   • Formula: (Hard Match × 40%) + (Semantic Match × 60%)")
+    print(f"   • Calculation: ({hard_match_score:.1f}% × 0.4) + ({semantic_score:.1f}% × 0.6)")
+    print(f"   • Final Score: {final_score:.1f}/100")
+    
+    # OUTPUT GENERATION
+    print(f"\n📊 OUTPUT GENERATION")
+    print("-" * 50)
+    
+    # Relevance Score
+    print(f"\n🎯 RELEVANCE SCORE: {final_score:.0f}/100")
+    
+    # Verdict
+    if final_score >= 80:
+        verdict = "🟢 HIGH SUITABILITY"
+        verdict_desc = "Strong candidate - Recommend for interview"
+    elif final_score >= 60:
+        verdict = "🟡 MEDIUM SUITABILITY" 
+        verdict_desc = "Good potential - Consider with training"
+    else:
+        verdict = "🔴 LOW SUITABILITY"
+        verdict_desc = "Significant gaps - Major upskilling needed"
+    
+    print(f"\n🏷️ VERDICT: {verdict}")
+    print(f"   • Assessment: {verdict_desc}")
+    
+    # Missing Skills/Projects/Certifications
+    print(f"\n❌ MISSING SKILLS/REQUIREMENTS:")
+    missing_items = basic_scores['missing_skills'][:8]  # Top 8 missing
+    for i, item in enumerate(missing_items, 1):
+        print(f"   {i}. {item}")
+    
+    if llm_analysis.get('critical_gaps'):
+        print(f"\n⚠️ CRITICAL GAPS IDENTIFIED:")
+        for i, gap in enumerate(llm_analysis['critical_gaps'][:3], 1):
+            print(f"   {i}. {gap}")
+    
+    # Suggestions for Student Improvement
+    print(f"\n💡 SUGGESTIONS FOR STUDENT IMPROVEMENT:")
+    
+    # Immediate actions
+    if roadmap and roadmap.get('immediate_actions'):
+        print(f"\n   📋 IMMEDIATE ACTIONS:")
+        for i, action in enumerate(roadmap['immediate_actions'][:3], 1):
+            print(f"      {i}. {action}")
+    
+    # Skills to learn
+    if roadmap and roadmap.get('priority_skills'):
+        print(f"\n   🎯 PRIORITY SKILLS TO LEARN:")
+        for i, skill in enumerate(roadmap['priority_skills'][:5], 1):
+            print(f"      {i}. {skill}")
+    
+    # Quick wins
+    if roadmap and roadmap.get('quick_wins'):
+        print(f"\n   🚀 QUICK WINS:")
+        for i, win in enumerate(roadmap['quick_wins'][:3], 1):
+            print(f"      {i}. {win}")
+    
+    # Final recommendation
+    print(f"\n📋 FINAL RECOMMENDATION:")
+    final_verdict = llm_analysis.get('final_verdict', 'Analysis completed successfully')
+    if len(final_verdict) > 200:
+        final_verdict = final_verdict[:200] + "..."
+    print(f"   {final_verdict}")
+    
+    print(f"\n{'='*70}")
+
+@trace_llm_analysis if ADVANCED_PIPELINE else lambda x: x
+def complete_ai_analysis_api(resume_file, jd_file):
+    """API version with LangGraph + LangSmith integration"""
+    start_time = time.time()
+    
+    trace_id = None
+    if ADVANCED_PIPELINE:
+        trace_id = logger.start_trace("api_resume_analysis", {
+            "resume_file": resume_file,
+            "jd_file": jd_file,
+            "api_call": True
+        })
+    
+    try:
+        llm_analyzer = LLMResumeAnalyzer(model=LLM_MODEL)
+        
+        # Initialize LangGraph pipeline if available
+        if ADVANCED_PIPELINE:
+            pipeline = ResumeAnalysisPipeline(model=LLM_MODEL)
+        
+        # Load and process files
+        resume_raw = load_file(resume_file)
+        jd_raw = load_file(jd_file)
+        
+        resume_clean = clean_text(resume_raw)
+        resume_sections = split_sections(resume_clean)
+        resume_skills = extract_skills(" ".join(resume_sections.values()))
+        
+        jd_data = parse_jd(jd_raw)
+        jd_skills = jd_data["skills"]
+        
+        # Enhanced scoring if available
+        if ENHANCED_SCORING:
+            enhanced_scorer = EnhancedResumeScorer()
+            comprehensive_result = enhanced_scorer.calculate_comprehensive_score(
+                {"raw_text": resume_clean, "skills": resume_skills},
+                {"raw_text": jd_raw, "skills": jd_skills}
+            )
+            
+            final_score = comprehensive_result["final_score"]
+            basic_scores = {
+                "score": comprehensive_result["breakdown"]["hard_match"]["score"],
+                "matched_skills": comprehensive_result["breakdown"]["hard_match"]["matched_skills"],
+                "missing_skills": comprehensive_result["breakdown"]["hard_match"]["missing_skills"],
+                "matched_count": comprehensive_result["breakdown"]["hard_match"]["matched_count"],
+                "total_jd_skills": comprehensive_result["breakdown"]["hard_match"]["total_jd_skills"]
+            }
+        else:
+            basic_scores = calculate_basic_scores(resume_skills, jd_skills)
+            hard_match_score = basic_scores['score']
+            semantic_score = 50
+            final_score = (hard_match_score * 0.4) + (semantic_score * 0.6)
+        
+        # Run LangGraph pipeline if available
+        if ADVANCED_PIPELINE:
+            pipeline_result = pipeline.run_structured_analysis(resume_clean, jd_raw, basic_scores)
+            
+            if pipeline_result.get("pipeline_status") == "completed":
+                llm_analysis = pipeline_result["llm_analysis"]
+                improvement_roadmap = pipeline_result["improvement_roadmap"]
+                pipeline_used = True
+            else:
+                llm_analysis = llm_analyzer.analyze_resume_vs_jd(resume_clean, jd_raw, basic_scores)
+                improvement_roadmap = llm_analyzer.generate_improvement_roadmap(llm_analysis)
+                pipeline_used = False
+        else:
+            llm_analysis = llm_analyzer.analyze_resume_vs_jd(resume_clean, jd_raw, basic_scores)
+            improvement_roadmap = llm_analyzer.generate_improvement_roadmap(llm_analysis)
+            pipeline_used = False
+        
+        # Determine verdict
+        if final_score >= 80:
+            verdict = "High Suitability"
+            verdict_description = "Strong candidate - Recommend for interview"
+        elif final_score >= 60:
+            verdict = "Medium Suitability"
+            verdict_description = "Good potential - Consider with training"
+        else:
+            verdict = "Low Suitability" 
+            verdict_description = "Significant gaps - Major upskilling needed"
+        
+        # Finalize processing time
+        end_time = time.time()
+        processing_time = round(end_time - start_time, 2)
+
+        result = {
+            "success": True,
+            "enhanced_analysis": ENHANCED_SCORING,
+            "langgraph_pipeline": pipeline_used,
+            "langsmith_logging": ADVANCED_PIPELINE,
+            "relevance_analysis": {
+                "step_1_hard_match": {
+                    "exact_matches": f"{basic_scores.get('matched_count', 0)}/{basic_scores.get('total_jd_skills', 0)}",
+                    "coverage_score": basic_scores['score'],
+                    "matched_skills": basic_scores['matched_skills'],
+                    "tfidf_included": ENHANCED_SCORING,
+                    "fuzzy_matches": [] if not ENHANCED_SCORING else comprehensive_result["breakdown"]["fuzzy_match"]["fuzzy_matched_skills"]
+                },
+                "step_2_semantic_match": {
+                    "experience_alignment_score": llm_analysis.get('overall_fit_score', 0),
+                    "context_understanding": llm_analysis.get('experience_alignment', ''),
+                    "embedding_analysis": "Enhanced embeddings" if ENHANCED_SCORING else "LLM-powered analysis"
+                },
+                "step_3_scoring_verdict": {
+                    "final_score": round(final_score, 1),
+                    "enhanced_components": ENHANCED_SCORING
+                }
+            },
+            "output_generation": {
+                "relevance_score": f"{final_score:.0f}/100",
+                "verdict": verdict,
+                "verdict_description": verdict_description,
+                "missing_skills": basic_scores['missing_skills'],
+                "critical_gaps": llm_analysis.get('critical_gaps', []),
+                "improvement_suggestions": {
+                    "immediate_actions": improvement_roadmap.get('immediate_actions', [])[:3],
+                    "priority_skills": improvement_roadmap.get('priority_skills', [])[:5], 
+                    "quick_wins": improvement_roadmap.get('quick_wins', [])[:3]
+                },
+                "final_recommendation": llm_analysis.get('final_verdict', ''),
+                "tech_stack_used": {
+                    "semantic_embeddings": ENHANCED_SCORING,
+                    "fuzzy_matching": ENHANCED_SCORING, 
+                    "spacy_nlp": ENHANCED_SCORING,
+                    "tfidf_scoring": ENHANCED_SCORING,
+                    "faiss_vector_store": ENHANCED_SCORING,
+                    "langgraph_pipeline": pipeline_used,
+                    "langsmith_logging": ADVANCED_PIPELINE
+                }
+            },
+            "processing_info": {
+                "processing_time": processing_time
+            }
+        }
+        
+        # Log success
+        if ADVANCED_PIPELINE and trace_id:
+            logger.end_trace(trace_id, {
+                "final_score": final_score,
+                "pipeline_used": pipeline_used
+            }, "success")
+            
+            logger.log_metrics({
+                "api_success": True,
+                "final_score": final_score,
+                "pipeline_used": pipeline_used
+            })
+        
+        return result
+        
+    except Exception as e:
+        if ADVANCED_PIPELINE and trace_id:
+            logger.end_trace(trace_id, {}, "error", str(e))
+        return {"success": False, "error": str(e)}
+
+if __name__ == "__main__":
+    # Check prerequisites
+    print("🔧 Checking prerequisites...")
+    
+    # Check .env file
+    if not os.path.exists('.env'):
+        print("❌ .env file missing! Create it with your OPENROUTER_API_KEY")
+        exit(1)
+    
+    # Check API key
+    if not os.getenv('OPENROUTER_API_KEY'):
+        print("❌ OPENROUTER_API_KEY not found in .env file!")
+        print("💡 Add this to your .env file: OPENROUTER_API_KEY=your-key-here")
+        exit(1)
+    
+    # Check files exist
+    resume_file = "input/sample_resume.pdf"
+    jd_file = "input/sample_jd.pdf"
+    
+    if not os.path.exists(resume_file):
+        print(f"❌ Resume file not found: {resume_file}")
+        exit(1)
+        
+    if not os.path.exists(jd_file):
+        print(f"❌ JD file not found: {jd_file}")
+        exit(1)
+    
+    print("✅ All prerequisites checked!")
+    
+    # Show final tech stack status
+    print(f"\n🔧 TECH STACK STATUS:")
+    print(f"   • Enhanced Scoring: {'✅ Active' if ENHANCED_SCORING else '⚠️ Basic'}")
+    print(f"   • LangGraph Pipeline: {'✅ Active' if ADVANCED_PIPELINE else '⚠️ Not installed'}")
+    print(f"   • LangSmith Logging: {'✅ Active' if ADVANCED_PIPELINE else '⚠️ Not installed'}")
+    
+    # Run the complete enhanced analysis
+    complete_ai_analysis(resume_file, jd_file)

requirements.txt

@@ -0,0 +1,18 @@
+fastapi>=0.104.1
+uvicorn[standard]>=0.24.0
+streamlit>=1.28.0
+requests>=2.31.0
+pandas>=2.0.0
+plotly>=5.15.0
+python-dateutil>=2.8.2
+python-multipart>=0.0.6
+pydantic>=2.5.0
+sqlalchemy>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+sentence-transformers>=2.2.2
+python-docx>=0.8.11
+PyPDF2>=3.0.1
+reportlab>=4.0.0
+fuzzywuzzy>=0.18.0
+python-levenshtein>=0.20.0

resume_analysis.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f08599bebf0a52ae980e1efae0dd6356be105f17e7274929eaffa3389cd42a4
+size 122880

streamlit_app.py

@@ -0,0 +1,1103 @@
+import os
+import streamlit as st
+import requests
+import json
+import time
+from datetime import datetime
+import pandas as pd
+import io
+
+# HuggingFace Spaces Configuration
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+SPACE_ID = os.getenv("SPACE_ID", None)
+IS_HUGGINGFACE = SPACE_ID is not None
+
+# Optional visualization imports
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
+
+# Helper functions (defined at the top)
+def create_csv_export(export_data):
+    """Create CSV export"""
+    analysis = export_data["analysis"]
+    
+    csv_lines = [
+        "Resume Analysis Results",
+        "",
+        f"Resume,{export_data['files']['resume']}",
+        f"Job Description,{export_data['files']['jd']}",
+        f"Date,{export_data['timestamp']}",
+        "",
+        "SCORES"
+    ]
+    
+    if "enhanced_analysis" in analysis:
+        scoring = analysis["enhanced_analysis"]["relevance_scoring"]
+        csv_lines.extend([
+            f"Overall Score,{scoring['overall_score']}/100",
+            f"Skill Match,{scoring['skill_match_score']:.1f}%",
+            f"Experience Match,{scoring['experience_match_score']:.1f}%",
+            f"Verdict,{scoring['fit_verdict']}",
+            f"Confidence,{scoring['confidence']:.1f}%"
+        ])
+        
+        # Add matched skills
+        csv_lines.extend(["", "MATCHED SKILLS"])
+        for skill in scoring.get('matched_must_have', []):
+            csv_lines.append(f"✓,{skill}")
+        
+        # Add missing skills
+        csv_lines.extend(["", "MISSING SKILLS"])
+        for skill in scoring.get('missing_must_have', []):
+            csv_lines.append(f"✗,{skill}")
+            
+    elif "relevance_analysis" in analysis:
+        relevance = analysis["relevance_analysis"]
+        csv_lines.extend([
+            f"Final Score,{relevance['step_3_scoring_verdict']['final_score']}/100",
+            f"Hard Match,{relevance['step_1_hard_match']['coverage_score']:.1f}%",
+            f"Semantic Score,{relevance['step_2_semantic_match']['experience_alignment_score']}/10",
+            f"Verdict,{analysis['output_generation']['verdict']}"
+        ])
+        
+        # Add matched skills
+        csv_lines.extend(["", "MATCHED SKILLS"])
+        for skill in relevance['step_1_hard_match'].get('matched_skills', []):
+            csv_lines.append(f"✓,{skill}")
+    
+    return "\n".join(csv_lines)
+
+def create_text_report(export_data):
+    """Create text report"""
+    analysis = export_data["analysis"]
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    report = f"""
+RESUME ANALYSIS REPORT
+=====================
+
+Generated: {timestamp}
+Resume: {export_data['files']['resume']}
+Job Description: {export_data['files']['jd']}
+
+ANALYSIS RESULTS
+===============
+
+"""
+    
+    if "enhanced_analysis" in analysis:
+        scoring = analysis["enhanced_analysis"]["relevance_scoring"]
+        job_parsing = analysis["enhanced_analysis"]["job_parsing"]
+        
+        report += f"""JOB DETAILS:
+Role: {job_parsing.get('role_title', 'Not specified')}
+Experience Required: {job_parsing.get('experience_required', 'Not specified')}
+
+SCORES:
+Overall Score: {scoring['overall_score']}/100
+Skill Match: {scoring['skill_match_score']:.1f}%
+Experience Match: {scoring['experience_match_score']:.1f}%
+Verdict: {scoring['fit_verdict']}
+Confidence: {scoring['confidence']:.1f}%
+
+MATCHED SKILLS:
+"""
+        for skill in scoring.get('matched_must_have', []):
+            report += f"✓ {skill}\n"
+        
+        report += "\nMISSING SKILLS:\n"
+        for skill in scoring.get('missing_must_have', []):
+            report += f"✗ {skill}\n"
+        
+        if scoring.get('improvement_suggestions'):
+            report += "\nRECOMMENDATIONS:\n"
+            for i, suggestion in enumerate(scoring['improvement_suggestions'], 1):
+                report += f"{i}. {suggestion}\n"
+        
+        if scoring.get('quick_wins'):
+            report += "\nQUICK WINS:\n"
+            for i, win in enumerate(scoring['quick_wins'], 1):
+                report += f"{i}. {win}\n"
+    
+    elif "relevance_analysis" in analysis:
+        relevance = analysis["relevance_analysis"]
+        output = analysis["output_generation"]
+        
+        report += f"""SCORES:
+Final Score: {relevance['step_3_scoring_verdict']['final_score']}/100
+Hard Match: {relevance['step_1_hard_match']['coverage_score']:.1f}%
+Semantic Score: {relevance['step_2_semantic_match']['experience_alignment_score']}/10
+Exact Matches: {relevance['step_1_hard_match']['exact_matches']}
+Verdict: {output['verdict']}
+
+MATCHED SKILLS:
+"""
+        for skill in relevance['step_1_hard_match'].get('matched_skills', []):
+            report += f"✓ {skill}\n"
+        
+        missing_skills = output.get('missing_skills', [])
+        if missing_skills:
+            report += "\nMISSING SKILLS:\n"
+            for skill in missing_skills[:10]:
+                report += f"✗ {skill}\n"
+    
+    report += f"\n---\nGenerated by AI Resume Analyzer\n{timestamp}"
+    return report
+
+def wait_for_backend(max_wait=60):
+    """Wait for backend to be ready"""
+    start_time = time.time()
+    while time.time() - start_time < max_wait:
+        try:
+            response = requests.get(f"{BACKEND_URL}/health", timeout=5)
+            if response.status_code == 200:
+                return True
+        except:
+            pass
+        time.sleep(2)
+    return False
+
+def check_backend_status():
+    """Check if backend is available and get system info with retry logic"""
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(f"{BACKEND_URL}/health", timeout=10)
+            if response.status_code == 200:
+                health_data = response.json()
+                return {
+                    "available": True,
+                    "components": health_data.get("components", {}),
+                    "version": health_data.get("version", "Unknown"),
+                    "attempt": attempt + 1
+                }
+        except requests.exceptions.ConnectionError:
+            if attempt < max_retries - 1:
+                time.sleep(3)  # Wait longer between retries
+                continue
+            return {"available": False, "error": "Backend starting up..." if IS_HUGGINGFACE else "Connection refused - Backend not running", "attempt": attempt + 1}
+        except requests.exceptions.Timeout:
+            return {"available": False, "error": "Request timeout - Backend starting" if IS_HUGGINGFACE else "Request timeout", "attempt": attempt + 1}
+        except Exception as e:
+            return {"available": False, "error": str(e), "attempt": attempt + 1}
+    
+    return {"available": False, "error": "Backend not responsive"}
+
+def safe_api_call(endpoint, method="GET", **kwargs):
+    """Make a safe API call with proper URL handling"""
+    max_retries = 2
+    for attempt in range(max_retries):
+        try:
+            # Construct proper URL
+            if endpoint.startswith("http"):
+                url = endpoint
+            else:
+                # Ensure endpoint starts with /
+                if not endpoint.startswith("/"):
+                    endpoint = "/" + endpoint
+                url = f"{BACKEND_URL}{endpoint}"
+            
+            if method.upper() == "GET":
+                response = requests.get(url, timeout=30, **kwargs)
+            elif method.upper() == "POST":
+                response = requests.post(url, timeout=120, **kwargs)
+            elif method.upper() == "DELETE":
+                response = requests.delete(url, timeout=30, **kwargs)
+            else:
+                raise ValueError(f"Unsupported method: {method}")
+            
+            response.raise_for_status()
+            
+            # Handle empty responses for DELETE requests
+            if method.upper() == "DELETE" and not response.content:
+                return {"success": True, "data": {"message": "Deleted successfully"}}
+            
+            return {"success": True, "data": response.json(), "status_code": response.status_code}
+        
+        except requests.exceptions.ConnectionError:
+            if attempt < max_retries - 1:
+                time.sleep(2)
+                continue
+            return {"success": False, "error": "Cannot connect to backend", "error_type": "connection"}
+        except requests.exceptions.Timeout:
+            if attempt < max_retries - 1:
+                time.sleep(1)
+                continue
+            return {"success": False, "error": "Request timed out", "error_type": "timeout"}
+        except requests.exceptions.HTTPError as e:
+            return {"success": False, "error": f"HTTP {e.response.status_code}", "error_type": "http"}
+        except json.JSONDecodeError:
+            return {"success": False, "error": "Invalid response format", "error_type": "json"}
+        except Exception as e:
+            return {"success": False, "error": str(e), "error_type": "unknown"}
+
+# Page config
+st.set_page_config(
+    page_title="🤗 AI Resume Analyzer" if IS_HUGGINGFACE else "🎯 AI Resume Analyzer",
+    page_icon="🎯",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Enhanced CSS styling (keeping your original theme + HuggingFace additions)
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    
+    :root {
+        --font-family: 'Inter', sans-serif;
+        --primary-color: #3B82F6;
+        --accent-color: #60A5FA;
+        --success-color: #10B981;
+        --warning-color: #F59E0B;
+        --error-color: #EF4444;
+        --background-color: #F9FAFB;
+        --card-bg-color: #FFFFFF;
+        --text-color: #1F2937;
+        --subtle-text-color: #6B7280;
+        --border-color: #E5E7EB;
+        --hf-orange: #FF6B35;
+        --hf-blue: #4285F4;
+    }
+
+    /* General Styles */
+    body, .stApp { 
+        font-family: var(--font-family); 
+        background-color: var(--background-color); 
+        color: var(--text-color); 
+    }
+    #MainMenu, footer, header { visibility: hidden; }
+
+    /* HuggingFace Header */
+    .hf-header {
+        background: linear-gradient(135deg, var(--hf-orange) 0%, var(--hf-blue) 100%);
+        color: white;
+        padding: 2rem;
+        border-radius: 16px;
+        margin: 1rem 0;
+        text-align: center;
+        box-shadow: 0 8px 32px rgba(255, 107, 53, 0.3);
+        position: relative;
+    }
+    
+    .hf-header::before {
+        content: '🤗';
+        position: absolute;
+        top: 20px;
+        right: 30px;
+        font-size: 3rem;
+        opacity: 0.3;
+    }
+    
+    .hf-header h1 {
+        margin: 0 0 0.5rem 0;
+        font-weight: 700;
+        font-size: 2.5rem;
+    }
+
+    /* Startup Banner */
+    .startup-banner {
+        background: linear-gradient(135deg, #FEF3C7 0%, #FDE68A 100%);
+        color: #92400E;
+        padding: 1.5rem;
+        border-radius: 12px;
+        margin: 1rem 0;
+        text-align: center;
+        border: 2px solid var(--hf-orange);
+        animation: pulse 2s infinite;
+    }
+    
+    @keyframes pulse {
+        0% { opacity: 1; }
+        50% { opacity: 0.8; }
+        100% { opacity: 1; }
+    }
+
+    /* Main Header (for non-HF) */
+    .main-header {
+        background-color: var(--card-bg-color);
+        padding: 2rem;
+        border-radius: 12px;
+        margin: 1rem 0;
+        text-align: center;
+        border: 1px solid var(--border-color);
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    }
+    .main-header h1 {
+        color: var(--primary-color);
+        font-weight: 700;
+        letter-spacing: -1px;
+        margin-bottom: 0.5rem;
+    }
+    .main-header p {
+        color: var(--subtle-text-color);
+        font-size: 1.1rem;
+        margin: 0;
+    }
+
+    /* Status indicators */
+    .status-indicator {
+        display: inline-flex;
+        align-items: center;
+        padding: 0.5rem 1rem;
+        border-radius: 20px;
+        font-size: 0.875rem;
+        font-weight: 500;
+        margin: 0.25rem;
+    }
+    .status-online {
+        background-color: #D1FAE5;
+        color: #065F46;
+        border: 1px solid #A7F3D0;
+    }
+    .status-offline {
+        background-color: #FEE2E2;
+        color: #991B1B;
+        border: 1px solid #FECACA;
+    }
+    .status-warning {
+        background-color: #FEF3C7;
+        color: #92400E;
+        border: 1px solid #FCD34D;
+    }
+    .status-starting {
+        background-color: #FEF3C7;
+        color: #92400E;
+        border: 1px solid #FCD34D;
+        animation: pulse 2s infinite;
+    }
+
+    /* File Uploader Customization */
+    [data-testid="stFileUploader"] > div {
+        background-color: var(--card-bg-color);
+        padding: 2rem;
+        border-radius: 12px;
+        border: 2px dashed var(--border-color);
+        transition: all 0.3s ease;
+    }
+    [data-testid="stFileUploader"] > div:hover {
+        border-color: var(--primary-color);
+        background-color: #F9FAFB;
+    }
+    [data-testid="stFileUploader"] label {
+        font-weight: 600;
+        color: var(--primary-color);
+    }
+
+    /* Results & Cards */
+    .results-container, .feature-card, .download-section {
+        background-color: var(--card-bg-color);
+        padding: 1.5rem;
+        border-radius: 12px;
+        border: 1px solid var(--border-color);
+        margin: 1rem 0;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    }
+    
+    [data-testid="metric-container"] {
+        background-color: var(--card-bg-color);
+        border: 1px solid var(--border-color);
+        padding: 1rem;
+        border-radius: 12px;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+        transition: transform 0.2s ease;
+    }
+    [data-testid="metric-container"]:hover {
+        transform: translateY(-2px);
+    }
+
+    /* Score Cards */
+    .score-card {
+        background: linear-gradient(135deg, var(--primary-color), var(--accent-color));
+        color: white;
+        padding: 1.5rem;
+        border-radius: 12px;
+        text-align: center;
+        margin: 0.5rem 0;
+    }
+    .score-number { font-size: 2rem; font-weight: 700; margin-bottom: 0.5rem; }
+    .score-label { font-size: 0.9rem; opacity: 0.9; }
+
+    /* Skill Tags */
+    .skill-tag {
+        display: inline-block;
+        padding: 0.3rem 0.8rem;
+        border-radius: 16px;
+        font-size: 0.85rem;
+        font-weight: 500;
+        margin: 0.25rem;
+        border: 1px solid transparent;
+        transition: transform 0.2s ease;
+    }
+    .skill-tag:hover {
+        transform: scale(1.05);
+    }
+    .skill-tag.matched {
+        background-color: #D1FAE5;
+        color: #065F46;
+        border-color: #A7F3D0;
+    }
+    .skill-tag.missing {
+        background-color: #FEE2E2;
+        color: #991B1B;
+        border-color: #FECACA;
+    }
+    .skill-tag.bonus {
+        background-color: #DBEAFE;
+        color: #1E40AF;
+        border-color: #BFDBFE;
+    }
+
+    /* Buttons */
+    .stButton > button {
+        background-color: var(--primary-color);
+        color: white;
+        border: none;
+        border-radius: 8px;
+        font-weight: 600;
+        transition: all 0.2s ease;
+    }
+    .stButton > button:hover {
+        background-color: var(--accent-color);
+        transform: translateY(-1px);
+        box-shadow: 0 4px 8px rgba(59, 130, 246, 0.3);
+    }
+    .stDownloadButton > button {
+        background-color: var(--success-color);
+        color: white;
+        border: none;
+        border-radius: 8px;
+        font-weight: 600;
+        transition: all 0.2s ease;
+    }
+    .stDownloadButton > button:hover {
+        transform: translateY(-1px);
+        box-shadow: 0 4px 8px rgba(16, 185, 129, 0.3);
+    }
+
+    /* Progress bar */
+    .stProgress > div > div > div > div {
+        background-image: linear-gradient(90deg, var(--primary-color), var(--accent-color));
+    }
+
+    /* Error/Warning styling */
+    .stError {
+        background-color: #FEE2E2;
+        color: #991B1B;
+        border-left: 4px solid var(--error-color);
+        border-radius: 8px;
+    }
+    .stWarning {
+        background-color: #FEF3C7;
+        color: #92400E;
+        border-left: 4px solid var(--warning-color);
+        border-radius: 8px;
+    }
+    .stSuccess {
+        background-color: #D1FAE5;
+        color: #065F46;
+        border-left: 4px solid var(--success-color);
+        border-radius: 8px;
+    }
+    .stInfo {
+        background-color: #DBEAFE;
+        color: #1E40AF;
+        border-left: 4px solid var(--primary-color);
+        border-radius: 8px;
+    }
+
+    /* History items */
+    .history-item {
+        background-color: var(--card-bg-color);
+        border-left: 3px solid var(--primary-color);
+        padding: 0.75rem;
+        margin-bottom: 0.5rem;
+        border-radius: 0 8px 8px 0;
+        transition: transform 0.2s ease;
+    }
+    .history-item:hover {
+        transform: translateX(2px);
+    }
+    .history-item.high-score {
+        border-left-color: var(--success-color);
+    }
+    .history-item.medium-score {
+        border-left-color: var(--warning-color);
+    }
+    .history-item.low-score {
+        border-left-color: var(--error-color);
+    }
+
+    /* Dashboard header */
+    .quick-nav {
+        background-color: var(--card-bg-color);
+        padding: 1rem;
+        border-radius: 8px;
+        margin-bottom: 1rem;
+        border: 1px solid var(--border-color);
+        text-align: center;
+    }
+    .quick-nav a {
+        color: var(--primary-color);
+        text-decoration: none;
+        margin: 0 1rem;
+        font-weight: 500;
+    }
+    .quick-nav a:hover {
+        color: var(--accent-color);
+        text-decoration: underline;
+    }
+
+    @media (prefers-color-scheme: dark) {
+        :root {
+            --background-color: #111827;
+            --card-bg-color: #1F2937;
+            --text-color: #F3F4F6;
+            --subtle-text-color: #9CA3AF;
+            --border-color: #374151;
+        }
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'results' not in st.session_state:
+    st.session_state.results = []
+if 'backend_ready' not in st.session_state:
+    st.session_state.backend_ready = False
+if 'startup_complete' not in st.session_state:
+    st.session_state.startup_complete = False
+
+# Dynamic Header based on environment
+if IS_HUGGINGFACE:
+    st.markdown("""
+    <div class="hf-header">
+        <h1>🤗 AI Resume Analyzer</h1>
+        <p><strong>Advanced AI-Powered Resume Analysis System</strong></p>
+        <p>Full-Stack Deployment on HuggingFace Spaces</p>
+    </div>
+    """, unsafe_allow_html=True)
+else:
+    # Dashboard Header (using your existing theme colors)
+    st.markdown(f"""
+    <div class="quick-nav">
+        <strong>🎯 AUTOMATED RESUME RELEVANCE CHECK SYSTEM DASHBOARD</strong> | 
+        <a href="{BACKEND_URL}/dashboard" target="_blank">📊 Backend</a> |
+        <a href="{BACKEND_URL}/health" target="_blank">🔍 Health</a> |
+        <a href="{BACKEND_URL}/docs" target="_blank">📋 API Docs</a>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Header (your existing design)
+    st.markdown("""
+    <div class="main-header">
+        <h1>🎯 AUTOMATED RESUME RELEVANCE CHECK SYSTEM</h1>
+        <p>Upload resumes and job descriptions for intelligent AI-powered candidate analysis</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Sidebar with improved status checking
+with st.sidebar:
+    if IS_HUGGINGFACE:
+        st.markdown("### 🤗 HuggingFace Deployment")
+        st.success("✅ Running on HuggingFace Spaces")
+    
+    st.markdown("### 🚀 System Features")
+    features = [
+        ("🎯", "Semantic Matching", "AI-powered similarity analysis"),
+        ("🔄", "Fuzzy Matching", "Intelligent skill detection"),
+        ("📊", "TF-IDF Scoring", "Statistical analysis"),
+        ("🤖", "LLM Analysis", "GPT insights"),
+        ("📝", "NLP Processing", "Entity extraction"),
+        ("⚡", "Real-time", "Instant results")
+    ]
+    
+    for icon, title, desc in features:
+        st.markdown(f"""
+        <div class="feature-card" style="margin-bottom: 0.5rem;">
+            <div style="font-size: 1.5rem; float: left; margin-right: 1rem;">{icon}</div>
+            <div style="font-weight: 600; color: var(--primary-color);">{title}</div>
+            <div style="font-size: 0.85rem; color: var(--subtle-text-color);">{desc}</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    st.markdown("### 🔧 System Status")
+    
+    # Check backend status with loading indicator
+    with st.spinner("Checking system status..."):
+        backend_status = check_backend_status()
+    
+    if backend_status["available"]:
+        st.session_state.backend_ready = True
+        st.session_state.startup_complete = True
+        
+        st.markdown('<span class="status-indicator status-online">✅ Backend Ready</span>', unsafe_allow_html=True)
+        
+        components = backend_status.get("components", {})
+        
+        # Database status
+        db_status = components.get("database", "unavailable")
+        if db_status == "active":
+            st.markdown('<span class="status-indicator status-online">💾 Database Active</span>', unsafe_allow_html=True)
+        else:
+            st.markdown('<span class="status-indicator status-warning">💾 Database Limited</span>', unsafe_allow_html=True)
+        
+        # Enhanced features
+        if components.get("enhanced_features") == "active":
+            st.markdown('<span class="status-indicator status-online">🧠 Enhanced AI</span>', unsafe_allow_html=True)
+        else:
+            st.markdown('<span class="status-indicator status-warning">🧠 Basic Mode</span>', unsafe_allow_html=True)
+        
+        # Downloads
+        if components.get("download_features") == "active":
+            st.markdown('<span class="status-indicator status-online">📥 Downloads Ready</span>', unsafe_allow_html=True)
+        
+        # Interactive History
+        if components.get("interactive_history") == "active":
+            st.markdown('<span class="status-indicator status-online">🗂️ Interactive History</span>', unsafe_allow_html=True)
+        
+        # Version info
+        version = backend_status.get("version", "Unknown")
+        st.markdown(f"<small>Version: {version}</small>", unsafe_allow_html=True)
+        
+    else:
+        st.markdown('<span class="status-indicator status-starting">⏳ System Starting</span>', unsafe_allow_html=True)
+        
+        error_msg = backend_status.get("error", "Initializing...")
+        attempt = backend_status.get("attempt", 1)
+        
+        if IS_HUGGINGFACE:
+            st.info(f"""
+            🚀 **HuggingFace Startup in Progress**
+            
+            Status: {error_msg}  
+            Attempt: {attempt}/3  
+            
+            ⏱️ Please wait 30-60 seconds for full system initialization.
+            """)
+        else:
+            st.error(f"Error: {error_msg}")
+            st.info("💡 Start backend: `python app.py`")
+        
+        # Auto-refresh button
+        if st.button("🔄 Check Status", use_container_width=True):
+            st.rerun()
+    
+    st.markdown("---")
+    st.markdown("### 🔗 Quick Links")
+    
+    if backend_status["available"]:
+        if st.button("🎯 Dashboard", use_container_width=True):
+            st.markdown(f'[🎯 Open Dashboard]({BACKEND_URL}/dashboard)', unsafe_allow_html=True)
+            st.success("Dashboard link above ↑")
+        
+        if st.button("📋 API Docs", use_container_width=True):
+            st.markdown(f'[📋 Open API Documentation]({BACKEND_URL}/docs)', unsafe_allow_html=True)
+            st.success("API docs link above ↑")
+    else:
+        st.info("Links available when backend is running")
+
+# Startup Banner for HuggingFace
+if IS_HUGGINGFACE and not st.session_state.startup_complete:
+    st.markdown("""
+    <div class="startup-banner">
+        <strong>🚀 AI Resume Analyzer Starting Up</strong><br>
+        Full-stack system initializing on HuggingFace Spaces...<br>
+        <small>FastAPI Backend + Streamlit Frontend + Database</small><br>
+        <strong>Please wait 30-60 seconds</strong>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Main Application (only show if backend is ready or not on HuggingFace)
+if st.session_state.backend_ready or not IS_HUGGINGFACE:
+    # Main content (your existing design)
+    st.markdown("### 📤 Upload Documents")
+    upload_col1, upload_col2 = st.columns(2)
+
+    with upload_col1:
+        resume_files = st.file_uploader(
+            "📄 **Upload Resumes**",
+            help="Upload one or more resumes (PDF, DOCX, TXT)",
+            type=['pdf', 'docx', 'txt'],
+            key="resume_uploader",
+            accept_multiple_files=True
+        )
+        if resume_files:
+            for f in resume_files:
+                st.success(f"📄 {f.name} ({len(f.getvalue())} bytes)")
+
+    with upload_col2:
+        jd_files = st.file_uploader(
+            "📋 **Upload Job Descriptions**",
+            help="Upload one or more job descriptions (PDF, DOCX, TXT)",
+            type=['pdf', 'docx', 'txt'],
+            key="jd_uploader",
+            accept_multiple_files=True
+        )
+        if jd_files:
+            for f in jd_files:
+                st.success(f"📋 {f.name} ({len(f.getvalue())} bytes)")
+
+    # Analysis button
+    if st.button("🚀 Analyze Candidate Fit", type="primary", use_container_width=True):
+        if not backend_status["available"]:
+            if IS_HUGGINGFACE:
+                st.error("❌ Backend is still starting up. Please wait and try again.")
+            else:
+                st.error("❌ Backend is not available. Please start the backend first.")
+        elif not resume_files or not jd_files:
+            st.warning("⚠️ Please upload at least one resume and one job description.")
+        else:
+            st.session_state.results = []
+            total_analyses = len(resume_files) * len(jd_files)
+            
+            with st.container():
+                st.markdown("### 🤖 Processing Analysis")
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                count = 0
+                errors = []
+                
+                for resume_file in resume_files:
+                    for jd_file in jd_files:
+                        count += 1
+                        status_text.info(f"🧠 Analyzing {resume_file.name} vs {jd_file.name} ({count}/{total_analyses})...")
+                        
+                        # Make API call with proper URL handling
+                        files = {'resume': resume_file, 'jd': jd_file}
+                        api_result = safe_api_call("/analyze", method="POST", files=files)
+                        
+                        if api_result["success"]:
+                            result = api_result["data"]
+                            result['ui_info'] = {
+                                'resume_filename': resume_file.name, 
+                                'jd_filename': jd_file.name
+                            }
+                            st.session_state.results.append(result)
+                        else:
+                            error_msg = f"Error analyzing {resume_file.name}: {api_result['error']}"
+                            errors.append(error_msg)
+                            st.error(error_msg)
+                        
+                        progress_bar.progress(count / total_analyses)
+                
+                # Clear progress indicators
+                progress_bar.empty()
+                status_text.empty()
+                
+                # Show summary
+                if st.session_state.results:
+                    st.success(f"✅ Completed {len(st.session_state.results)} successful analyses!")
+                
+                if errors:
+                    st.error(f"❌ {len(errors)} analyses failed. Check backend logs for details.")
+
+    # Display results (your existing design continues here)
+    if st.session_state.results:
+        st.markdown("---")
+        st.markdown("### 📊 Batch Analysis Results")
+
+        for i, result in enumerate(st.session_state.results):
+            ui_info = result.get('ui_info', {})
+            resume_name = ui_info.get('resume_filename', f'Resume {i+1}')
+            jd_name = ui_info.get('jd_filename', f'Job {i+1}')
+            
+            # Determine overall score for color coding
+            overall_score = 0
+            if result.get("success"):
+                if 'enhanced_analysis' in result:
+                    overall_score = result['enhanced_analysis']['relevance_scoring']['overall_score']
+                elif 'relevance_analysis' in result:
+                    overall_score = result['relevance_analysis']['step_3_scoring_verdict']['final_score']
+            
+            # Color coding for expander
+            score_emoji = "🟢" if overall_score >= 80 else "🟡" if overall_score >= 60 else "🔴"
+            expander_title = f"{score_emoji} **{resume_name}** vs **{jd_name}** - Score: {overall_score}/100"
+            
+            with st.expander(expander_title, expanded=(i == 0)):  # First result expanded by default
+                if result.get("success"):
+                    # Processing info
+                    processing_info = result.get('processing_info', {})
+                    processing_time = processing_info.get('processing_time', 0)
+                    enhanced_mode = processing_info.get('enhanced_features', False)
+                    database_saved = processing_info.get('database_saved', False)
+                    
+                    # Show mode and status
+                    col_info1, col_info2, col_info3 = st.columns(3)
+                    with col_info1:
+                        mode_color = "🚀" if enhanced_mode else "⚠️"
+                        mode_text = "Enhanced" if enhanced_mode else "Standard"
+                        if IS_HUGGINGFACE:
+                            st.info(f"🤗 HuggingFace: {mode_text}")
+                        else:
+                            st.info(f"{mode_color} Mode: {mode_text}")
+                    with col_info2:
+                        st.info(f"⏱️ Time: {processing_time:.1f}s")
+                    with col_info3:
+                        db_status = "💾 Saved" if database_saved else "⚠️ Not Saved"
+                        st.info(db_status)
+                    
+                    if 'enhanced_analysis' in result:
+                        # Enhanced analysis results
+                        relevance = result['enhanced_analysis']['relevance_scoring']
+                        job_parsing = result['enhanced_analysis']['job_parsing']
+                        
+                        # Job info
+                        st.markdown("#### 💼 Job Analysis")
+                        job_col1, job_col2 = st.columns(2)
+                        with job_col1:
+                            st.markdown(f"**Role:** {job_parsing.get('role_title', 'Not specified')}")
+                            st.markdown(f"**Experience:** {job_parsing.get('experience_required', 'Not specified')}")
+                        with job_col2:
+                            st.markdown(f"**Must-have Skills:** {len(job_parsing.get('must_have_skills', []))}")
+                            st.markdown(f"**Good-to-have Skills:** {len(job_parsing.get('good_to_have_skills', []))}")
+                        
+                        # Score metrics
+                        score_cols = st.columns(4)
+                        score_cols[0].metric("🏆 Overall Score", f"{relevance['overall_score']}/100")
+                        score_cols[1].metric("🎯 Skill Match", f"{relevance['skill_match_score']:.1f}%")
+                        score_cols[2].metric("💼 Experience Match", f"{relevance['experience_match_score']:.1f}%")
+                        score_cols[3].metric("🧠 Confidence", f"{relevance['confidence']:.1f}%")
+
+                        # Verdict
+                        verdict = relevance['fit_verdict']
+                        verdict_color = "#10B981" if "High" in verdict else "#F59E0B" if "Medium" in verdict else "#EF4444"
+                        st.markdown(f"""
+                        <div style="background: white; padding: 1rem; border-radius: 8px; border-left: 4px solid {verdict_color}; margin: 1rem 0;">
+                            <h4 style="color: {verdict_color}; margin: 0;">{verdict}</h4>
+                            <p style="color: #6B7280; margin: 0.5rem 0 0 0;">Confidence: {relevance['confidence']:.1f}%</p>
+                        </div>
+                        """, unsafe_allow_html=True)
+
+                        # Tabs for detailed analysis
+                        tab1, tab2, tab3 = st.tabs(["🎯 Skills Analysis", "💡 AI Recommendations", "📥 Download Report"])
+
+                        with tab1:
+                            skill_col1, skill_col2 = st.columns(2)
+                            
+                            with skill_col1:
+                                st.markdown("##### ✅ Matched Must-Have Skills")
+                                matched_skills = relevance.get('matched_must_have', [])
+                                if matched_skills:
+                                    skills_html = ''.join(f'<span class="skill-tag matched">{s}</span>' for s in matched_skills)
+                                    st.markdown(skills_html, unsafe_allow_html=True)
+                                else:
+                                    st.info("No must-have skills matched")
+                            
+                            with skill_col2:
+                                st.markdown("##### ❌ Missing Must-Have Skills")
+                                missing_skills = relevance.get('missing_must_have', [])
+                                if missing_skills:
+                                    skills_html = ''.join(f'<span class="skill-tag missing">{s}</span>' for s in missing_skills)
+                                    st.markdown(skills_html, unsafe_allow_html=True)
+                                else:
+                                    st.success("All required skills present!")
+
+                            # Bonus skills
+                            bonus_skills = relevance.get('matched_good_to_have', [])
+                            if bonus_skills:
+                                st.markdown("##### ⭐ Bonus Skills (Good to Have)")
+                                bonus_html = ''.join(f'<span class="skill-tag bonus">{s}</span>' for s in bonus_skills)
+                                st.markdown(bonus_html, unsafe_allow_html=True)
+
+                        with tab2:
+                            rec_col1, rec_col2 = st.columns(2)
+                            
+                            with rec_col1:
+                                st.markdown("##### 📈 Improvement Suggestions")
+                                suggestions = relevance.get('improvement_suggestions', [])
+                                if suggestions:
+                                    for i, suggestion in enumerate(suggestions, 1):
+                                        st.markdown(f"**{i}.** {suggestion}")
+                                else:
+                                    st.info("No specific improvements suggested")
+                            
+                            with rec_col2:
+                                st.markdown("##### ⚡ Quick Wins")
+                                quick_wins = relevance.get('quick_wins', [])
+                                if quick_wins:
+                                    for i, win in enumerate(quick_wins, 1):
+                                        st.markdown(f"**{i}.** {win}")
+                                else:
+                                    st.info("No quick wins identified")
+
+                        with tab3:
+                            export_data = {
+                                "timestamp": datetime.now().isoformat(),
+                                "files": {"resume": resume_name, "jd": jd_name},
+                                "analysis": result
+                            }
+                            
+                            d_col1, d_col2, d_col3 = st.columns(3)
+                            key_base = f"{resume_name}_{jd_name}_{i}".replace(" ", "_").replace(".", "_")
+                            
+                            with d_col1:
+                                st.download_button(
+                                    "📄 JSON Report",
+                                    json.dumps(export_data, indent=2),
+                                    f"analysis_{key_base}.json",
+                                    "application/json",
+                                    use_container_width=True,
+                                    key=f"json_{key_base}"
+                                )
+                            
+                            with d_col2:
+                                st.download_button(
+                                    "📊 CSV Summary",
+                                    create_csv_export(export_data),
+                                    f"analysis_{key_base}.csv",
+                                    "text/csv",
+                                    use_container_width=True,
+                                    key=f"csv_{key_base}"
+                                )
+                            
+                            with d_col3:
+                                st.download_button(
+                                    "📝 Text Report",
+                                    create_text_report(export_data),
+                                    f"report_{key_base}.txt",
+                                    "text/plain",
+                                    use_container_width=True,
+                                    key=f"txt_{key_base}"
+                                )
+
+                    else:
+                        # Standard analysis results
+                        st.warning("⚠️ Running in Standard Mode - Enhanced features disabled")
+                        
+                        if 'relevance_analysis' in result:
+                            relevance = result['relevance_analysis']
+                            output = result['output_generation']
+                            
+                            # Score metrics
+                            score_cols = st.columns(4)
+                            score_cols[0].metric("🏆 Final Score", f"{relevance['step_3_scoring_verdict']['final_score']}/100")
+                            score_cols[1].metric("🎯 Hard Match", f"{relevance['step_1_hard_match']['coverage_score']:.1f}%")
+                            score_cols[2].metric("🧠 Semantic Score", f"{relevance['step_2_semantic_match']['experience_alignment_score']}/10")
+                            score_cols[3].metric("✅ Matches", f"{relevance['step_1_hard_match']['exact_matches']}")
+                            
+                            # Verdict
+                            verdict = output['verdict']
+                            st.success(f"**Verdict:** {verdict}")
+                            
+                            # Skills
+                            skill_col1, skill_col2 = st.columns(2)
+                            
+                            with skill_col1:
+                                st.markdown("##### ✅ Matched Skills")
+                                matched_skills = relevance['step_1_hard_match'].get('matched_skills', [])
+                                if matched_skills:
+                                    skills_html = ''.join(f'<span class="skill-tag matched">{s}</span>' for s in matched_skills)
+                                    st.markdown(skills_html, unsafe_allow_html=True)
+                                else:
+                                    st.info("No skills matched")
+                            
+                            with skill_col2:
+                                st.markdown("##### ❌ Missing Skills")
+                                missing_skills = output.get('missing_skills', [])
+                                if missing_skills:
+                                    skills_html = ''.join(f'<span class="skill-tag missing">{s}</span>' for s in missing_skills[:10])
+                                    st.markdown(skills_html, unsafe_allow_html=True)
+                                else:
+                                    st.success("No missing skills identified")
+
+                else:
+                    st.error(f"❌ Analysis failed: {result.get('error', 'Unknown error')}")
+
+    # Analytics section
+    if st.session_state.results or backend_status["available"]:
+        st.markdown("---")
+        st.markdown("### 📈 Analytics Overview")
+
+        if backend_status["available"]:
+            analytics_result = safe_api_call("/analytics")
+            
+            if analytics_result["success"]:
+                analytics = analytics_result["data"]
+                
+                # Metrics
+                anal_col1, anal_col2 = st.columns(2)
+                with anal_col1:
+                    st.metric("Total Analyses", analytics.get('total_analyses', 0))
+                    st.metric("Average Score", f"{analytics.get('avg_score', 0):.1f}/100")
+                with anal_col2:
+                    st.metric("High-Fit Rate", f"{analytics.get('success_rate', 0):.1f}%")
+                    st.metric("High Matches", analytics.get('high_matches', 0))
+                
+                # Simple chart if there's data and plotly is available
+                if PLOTLY_AVAILABLE and analytics.get('total_analyses', 0) > 0:
+                    chart_data = pd.DataFrame({
+                        'Category': ['High Match', 'Medium Match', 'Low Match'],
+                        'Count': [
+                            analytics.get('high_matches', 0),
+                            analytics.get('medium_matches', 0),
+                            analytics.get('low_matches', 0)
+                        ]
+                    })
+                    
+                    if chart_data['Count'].sum() > 0:
+                        fig = px.pie(
+                            chart_data,
+                            values='Count',
+                            names='Category',
+                            color_discrete_sequence=['#10B981', '#F59E0B', '#EF4444']
+                        )
+                        fig.update_layout(height=250, margin=dict(t=20, b=0, l=0, r=0))
+                        st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.warning(f"Analytics unavailable: {analytics_result['error']}")
+        else:
+            st.info("Backend required for analytics")
+
+else:
+    # System not ready - show waiting interface for HuggingFace
+    st.info("""
+    🚀 **System Initialization in Progress**
+    
+    The AI Resume Analyzer is starting up on HuggingFace Spaces.
+    
+    **What's happening:**
+    - ⚡ FastAPI backend is initializing
+    - 💾 Database system is starting
+    - 🧠 AI components are loading
+    - 🎨 Interface is preparing
+    
+    **Please wait 30-60 seconds and the system will be ready!**
+    """)
+    
+    # Auto-refresh every 10 seconds
+    time.sleep(10)
+    st.rerun()
+
+# Footer (updated for HuggingFace)
+st.markdown("---")
+if IS_HUGGINGFACE:
+    st.markdown("""
+    <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%); 
+               border-radius: 12px; margin: 1rem 0;">
+        <div style="font-size: 1.5rem; font-weight: 700; color: #FF6B35; margin-bottom: 1rem;">
+            🤗 AI Resume Analyzer
+        </div>
+        <div style="font-size: 1rem; color: #6B7280; margin-bottom: 1rem;">
+            <strong>Full-Stack AI System</strong> | Deployed on HuggingFace Spaces
+        </div>
+        <div style="font-size: 0.9rem; color: #9CA3AF;">
+            FastAPI Backend + Streamlit Frontend + SQLite Database<br>
+            Advanced Resume Analysis with Interactive History Management
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+else:
+    st.markdown("""
+    <div style="text-align: center; padding: 1rem; color: var(--subtle-text-color);">
+        <strong>🏆 AI Resume Analyzer</strong> | 
+        Built with Python, FastAPI & Streamlit | 
+        Enhanced with Interactive History Management
+    </div>
+    """, unsafe_allow_html=True)

technical_overview.md

@@ -0,0 +1,27 @@
+# Technical Architecture
+
+## Core Components
+1. **Resume/JD Parser**: PyMuPDF, python-docx, spaCy
+2. **Semantic Engine**: sentence-transformers, FAISS, cosine similarity
+3. **Fuzzy Matcher**: RapidFuzz for skill variations
+4. **LLM Integration**: OpenRouter + Grok for intelligent analysis
+5. **Scoring Engine**: TF-IDF, weighted algorithms
+6. **Web Interface**: FastAPI backend, Streamlit frontend
+
+## Data Flow
+1. File Upload → Text Extraction
+2. NLP Processing → Entity Extraction  
+3. Multi-Stage Analysis:
+   - Hard Match (TF-IDF + Keywords)
+   - Semantic Match (Embeddings + Cosine)
+   - Fuzzy Match (Skill Variations)
+   - LLM Analysis (Context Understanding)
+4. Weighted Scoring → Final Verdict
+5. Recommendations Generation → Export Report
+
+## Scalability Features
+- RESTful API design
+- Async processing
+- Vector database integration
+- Modular architecture
+- Cloud deployment ready