updated

app.py

@@ -54,23 +54,24 @@ import shutil
 shutil.rmtree("/app/chatbot/chroma_db", ignore_errors=True)
 CHATBOT_TXT_PATH = os.path.join(current_dir, 'chatbot', 'chatbot.txt')
 CHATBOT_DB_DIR = "/tmp/chroma_db"
+
 # -----------------------------------------------------------------------------
 # Hugging Face model configuration
 #
 # The chatbot uses a small conversational model hosted on Hugging Face.  To
 # allow easy experimentation, the model name can be overridden via the
 # ``HF_CHATBOT_MODEL`` environment variable.  If unset, we fall back to
-# ``facebook/blenderbot-400M-distill`` which provides a good balance of
-# quality and resource usage and is freely available without authentication.
-HF_MODEL_NAME = os.getenv("HF_CHATBOT_MODEL", "facebook/blenderbot-400M-distill")
+# ``microsoft/DialoGPT-medium`` which provides better conversational quality
+# than blenderbot for our use case.
+HF_MODEL_NAME = os.getenv("HF_CHATBOT_MODEL", "microsoft/DialoGPT-medium")
 
 # Global Hugging Face model and tokenizer.  These variables remain ``None``
 # until ``init_hf_model()`` is called.  They are reused across all chatbot
 # requests to prevent repeatedly loading the large model into memory.
-_hf_model: 'AutoModelForSeq2SeqLM | None' = None  # type: ignore[type-arg]
-_hf_tokenizer: 'AutoTokenizer | None' = None  # type: ignore[type-arg]
+_hf_model = None
+_hf_tokenizer = None
 
-def init_hf_model() -> None:
+def init_hf_model():
     """
     Initialise the Hugging Face conversational model and tokenizer.
 
@@ -83,25 +84,30 @@ def init_hf_model() -> None:
     if _hf_model is not None and _hf_tokenizer is not None:
         return
 
-    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer  # type: ignore
+    from transformers import AutoModelForCausalLM, AutoTokenizer
     import torch
 
     model_name = HF_MODEL_NAME
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    print(f"Loading model {model_name} on device {device}")
 
-    # Load tokenizer and model from Hugging Face.  We deliberately avoid
-    # specifying ``use_auth_token`` here since the default models are
-    # publicly accessible.  Should you wish to use a private model, set
-    # HF_HOME/HF_TOKEN environment variables accordingly.
+    # Load tokenizer and model from Hugging Face
     tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
+    model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
+    
+    # Set pad token to eos token if not set
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
 
     _hf_model = model
     _hf_tokenizer = tokenizer
+    print(f"Model loaded successfully on {device}")
+
 _chatbot_embedder = None
 _chatbot_collection = None
 
-def init_chatbot() -> None:
+def init_chatbot():
     """Initialise the Chroma vector DB with chatbot.txt content."""
     global _chatbot_embedder, _chatbot_collection
     if _chatbot_embedder is not None and _chatbot_collection is not None:
@@ -115,81 +121,130 @@ def init_chatbot() -> None:
 
     os.makedirs(CHATBOT_DB_DIR, exist_ok=True)
 
-    with open(CHATBOT_TXT_PATH, encoding="utf-8") as f:
-        text = f.read()
+    # Read and parse the chatbot knowledge base
+    try:
+        with open(CHATBOT_TXT_PATH, encoding="utf-8") as f:
+            text = f.read()
+    except FileNotFoundError:
+        print(f"Warning: {CHATBOT_TXT_PATH} not found, using default content")
+        text = """
+        Codingo is an AI-powered recruitment platform designed to streamline job applications, 
+        candidate screening, and hiring. We make hiring smarter, faster, and fairer through 
+        automation and intelligent recommendations.
+        """
+
+    # Split text into chunks for vector search
     splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=100)
-    docs = [doc.strip() for doc in splitter.split_text(text)]
+    docs = [doc.strip() for doc in splitter.split_text(text) if doc.strip()]
 
+    # Initialize embedder
     embedder = SentenceTransformer("all-MiniLM-L6-v2")
     embeddings = embedder.encode(docs, show_progress_bar=False, batch_size=32)
 
-    client = chromadb.Client(Settings(persist_directory=CHATBOT_DB_DIR, anonymized_telemetry=False))
+    # Initialize Chroma client
+    client = chromadb.Client(Settings(
+        persist_directory=CHATBOT_DB_DIR, 
+        anonymized_telemetry=False,
+        is_persistent=True
+    ))
+    
+    # Get or create collection
     collection = client.get_or_create_collection("chatbot")
-    ids = [f"doc_{i}" for i in range(len(docs))]
+    
+    # Check if collection is empty and populate if needed
     try:
-        existing = collection.get(ids=ids[:1])
+        existing = collection.get(limit=1)
         if not existing.get("documents"):
             raise ValueError("Empty Chroma DB")
     except Exception:
-        collection.add(documents=docs, embeddings=embeddings, ids=ids)
+        # Add documents to collection
+        ids = [f"doc_{i}" for i in range(len(docs))]
+        collection.add(
+            documents=docs, 
+            embeddings=embeddings.tolist(), 
+            ids=ids
+        )
+        print(f"Added {len(docs)} documents to Chroma DB")
 
     _chatbot_embedder = embedder
     _chatbot_collection = collection
 
-
 def get_chatbot_response(query: str) -> str:
     """Generate a reply to the user's query using Chroma + Hugging Face model."""
-    init_chatbot()
-    init_hf_model()
-
-    # Safety: prevent empty input
-    if not query or not query.strip():
-        return "Please type a question about the Codingo platform."
-
-    embedder = _chatbot_embedder
-    collection = _chatbot_collection
-    model = _hf_model
-    tokenizer = _hf_tokenizer
-    device = model.device
-
-    # Retrieve context from Chroma
-    query_embedding = embedder.encode([query])[0]
-    results = collection.query(query_embeddings=[query_embedding], n_results=3)
-    retrieved_docs = results.get("documents", [[]])[0] if results else []
-    context = "\n".join(retrieved_docs)
-
-    # System instruction
-    system_prompt = (
-        "You are a helpful assistant for the Codingo website. "
-        "Only answer questions relevant to the context provided. "
-        "If unrelated, reply: 'I'm only trained to answer questions about the Codingo platform.'"
-    )
-
-    prompt = f"{system_prompt}\n\nContext:\n{context}\n\nQuestion: {query}\n\nAnswer:"
-
-    # ✅ Safe tokenization with truncation to avoid CUDA indexing issues
-    inputs = tokenizer(
-        prompt,
-        return_tensors="pt",
-        truncation=True,
-        max_length=256,  # Prevents long inputs
-        padding=True
-    ).to(device)
-
     try:
-        output_ids = model.generate(
-            **inputs,
-            max_length=200,
-            num_beams=3,
-            do_sample=False,
-            early_stopping=True
+        init_chatbot()
+        init_hf_model()
+
+        # Safety: prevent empty input
+        if not query or not query.strip():
+            return "Please type a question about the Codingo platform."
+
+        embedder = _chatbot_embedder
+        collection = _chatbot_collection
+        model = _hf_model
+        tokenizer = _hf_tokenizer
+        device = model.device
+
+        # Retrieve context from Chroma
+        query_embedding = embedder.encode([query])[0]
+        results = collection.query(
+            query_embeddings=[query_embedding.tolist()], 
+            n_results=3
+        )
+        retrieved_docs = results.get("documents", [[]])[0] if results else []
+        context = "\n".join(retrieved_docs[:3])  # Limit context to top 3 results
+
+        # Build conversational prompt
+        system_instruction = (
+            "You are LUNA AI, a helpful assistant for the Codingo recruitment platform. "
+            "Use the provided context to answer questions about Codingo. "
+            "If the question is not related to Codingo, politely redirect the conversation. "
+            "Keep responses concise and friendly."
         )
-        reply = tokenizer.decode(output_ids[0], skip_special_tokens=True)
-        if reply.startswith(prompt):
-            reply = reply[len(prompt):]
-        return reply.strip()
+
+        # Format prompt for DialoGPT
+        prompt = f"{system_instruction}\n\nContext:\n{context}\n\nUser: {query}\nLUNA AI:"
+
+        # Tokenize with proper truncation
+        inputs = tokenizer.encode(
+            prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512,
+            padding=True
+        ).to(device)
+
+        # Generate response
+        with torch.no_grad():
+            output_ids = model.generate(
+                inputs,
+                max_length=inputs.shape[1] + 150,
+                num_beams=3,
+                do_sample=True,
+                temperature=0.7,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                early_stopping=True
+            )
+
+        # Decode response
+        response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        
+        # Extract only the bot's response
+        if "LUNA AI:" in response:
+            response = response.split("LUNA AI:")[-1].strip()
+        elif prompt in response:
+            response = response.replace(prompt, "").strip()
+        
+        # Fallback if response is empty
+        if not response:
+            response = "I'm here to help you with questions about the Codingo platform. What would you like to know?"
+
+        return response
+
     except Exception as e:
-        return f"Error generating response: {str(e)}"
+        print(f"Chatbot error: {str(e)}")
+        return "I'm having trouble processing your request. Please try again or ask about Codingo's features, job matching, or how to use the platform."
 
 # Initialize Flask app
 app = Flask(
@@ -197,37 +252,20 @@ app = Flask(
     static_folder='backend/static',
     static_url_path='/static',
     template_folder='backend/templates',
-    instance_path=safe_instance_path  # ✅ points to writable '/tmp/flask_instance'
+    instance_path=safe_instance_path
 )
 
 app.config['SECRET_KEY'] = 'saadi'
 
-# -----------------------------------------------------------------------------
 # Cookie configuration for Hugging Face Spaces
-#
-# When running this app inside an iframe (as is typical on Hugging Face Spaces),
-# browsers will drop cookies that have the default SameSite policy of ``Lax``.
-# This prevents the Flask session cookie from being stored and means that
-# ``login_user()`` will appear to have no effect – the user will be redirected
-# back to the home page but remain anonymous. By explicitly setting the
-# SameSite policy to ``None`` and enabling the ``Secure`` flag, we allow the
-# session and remember cookies to be sent even when the app is embedded in an
-# iframe. Without these settings the sign‑up and login flows work locally
-# but silently fail in Spaces, causing the "redirect to home page without
-# anything" behaviour reported by users.
 app.config['SESSION_COOKIE_SAMESITE'] = 'None'
 app.config['SESSION_COOKIE_SECURE'] = True
 app.config['REMEMBER_COOKIE_SAMESITE'] = 'None'
 app.config['REMEMBER_COOKIE_SECURE'] = True
 
 # Configure the database connection
-# Use /tmp directory for database in Hugging Face Spaces
-# Note: Data will be lost when the space restarts
 app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/codingo.db'
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
-from flask_wtf.csrf import CSRFProtect
-
-# csrf = CSRFProtect(app)
 
 # Create necessary directories in writable locations
 os.makedirs('/tmp/static/audio', exist_ok=True)
@@ -249,7 +287,7 @@ def load_user(user_id):
 app.register_blueprint(auth_bp)
 app.register_blueprint(interview_api, url_prefix="/api")
 
-# Routes (keep your existing routes)
+# Routes
 @app.route('/')
 def index():
     return render_template('index.html')
@@ -269,30 +307,17 @@ def job_detail(job_id):
 def apply(job_id):
     job = Job.query.get_or_404(job_id)
     if request.method == 'POST':
-        # Retrieve the uploaded resume file from the request.  The ``name``
-        # attribute in the HTML form is ``resume``.
         file = request.files.get('resume')
-        # Use our safe upload helper to store the resume.  ``filepath``
-        # contains the location where the file was saved so that recruiters
-        # can download it later. Resume parsing has been disabled, so
-        # ``features`` will always be an empty dictionary.
         features, error, filepath = handle_resume_upload(file)
 
-        # If there was an error saving the resume, notify the user.  We no
-        # longer attempt to parse the resume contents, so the manual fields
-        # collected below will form the entire feature set.
         if error:
             flash("Resume upload failed. Please try again.", "danger")
             return render_template('apply.html', job=job)
 
-        # Collect the manually entered fields for skills, experience and education.
-        # Users can separate entries with commas, semicolons or newlines; we
-        # normalise the input into lists of trimmed strings.
         def parse_entries(raw_value: str):
             import re
             entries = []
             if raw_value:
-                # Split on commas, semicolons or newlines
                 for item in re.split(r'[\n,;]+', raw_value):
                     item = item.strip()
                     if item:
@@ -309,10 +334,6 @@ def apply(job_id):
             "education": parse_entries(education_input)
         }
 
-        # Prepare the application record.  We ignore the empty ``features``
-        # returned by ``handle_resume_upload`` and instead persist the
-        # manually collected attributes.  The extracted_features column
-        # expects a JSON string; json.dumps handles proper serialization.
         application = Application(
             job_id=job_id,
             user_id=current_user.id,
@@ -338,43 +359,33 @@ def my_applications():
     ).order_by(Application.date_applied.desc()).all()
     return render_template('my_applications.html', applications=applications)
 
-# -----------------------------------------------------------------------------
 # Chatbot API endpoint
-#
-# This route receives a JSON payload containing a ``message`` field from the
-# front‑end chat widget.  It validates the input, invokes the chatbot
-# response function and returns a JSON response.  Any errors are surfaced
-# as a 400 or 500 response with an ``error`` message field.
 @app.route('/chatbot', methods=['POST'])
 def chatbot_endpoint():
-    data = request.get_json(silent=True) or {}
-    user_input = str(data.get('message', '')).strip()
-    if not user_input:
-        return jsonify({"error": "Empty message"}), 400
+    """Handle chatbot queries from the frontend."""
     try:
+        data = request.get_json(silent=True) or {}
+        user_input = str(data.get('message', '')).strip()
+        
+        if not user_input:
+            return jsonify({"error": "Empty message"}), 400
+        
+        # Get chatbot response
         reply = get_chatbot_response(user_input)
         return jsonify({"response": reply})
+        
     except Exception as exc:
-        # Log the exception to stderr for debugging in the console.  In a
-        # production setting you might want to log this to a proper logging
-        # facility instead.
-        print(f"Chatbot error: {exc}", file=sys.stderr)
-        return jsonify({"error": str(exc)}), 500
+        print(f"Chatbot endpoint error: {exc}", file=sys.stderr)
+        return jsonify({"error": "I'm having trouble right now. Please try again."}), 500
 
 @app.route('/parse_resume', methods=['POST'])
 def parse_resume():
     file = request.files.get('resume')
     features, error, filepath = handle_resume_upload(file)
 
-    # If the upload failed, return an error.  Parsing is no longer
-    # supported, so we do not attempt to inspect the resume contents.
     if error:
         return {"error": "Error processing resume. Please try again."}, 400
 
-    # If no features were extracted (the normal case now), respond with
-    # empty fields rather than an error.  This preserves the API
-    # contract expected by any front‑end code that might call this
-    # endpoint.
     if not features:
         return {
             "name": "",
@@ -386,8 +397,6 @@ def parse_resume():
             "summary": ""
         }, 200
 
-    # Should features contain values (unlikely in the new implementation),
-    # pass them through to the client.
     response = {
         "name": features.get('name', ''),
         "email": features.get('email', ''),
@@ -415,30 +424,20 @@ def interview_page(job_id):
     cv_data = json.loads(application.extracted_features)
     return render_template("interview.html", job=job, cv=cv_data)
 
-
-# -----------------------------------------------------------------------------
-# Recruiter job posting route
-#
-# Authenticated users with a recruiter or admin role can access this page to
-# create new job listings.  Posted jobs are associated with the current
-# recruiter via the ``recruiter_id`` foreign key on the ``Job`` model.
 @app.route('/post_job', methods=['GET', 'POST'])
 @login_required
 def post_job():
-    # Only allow recruiters and admins to post jobs
     if current_user.role not in ('recruiter', 'admin'):
         flash('You do not have permission to post jobs.', 'warning')
         return redirect(url_for('jobs'))
 
     if request.method == 'POST':
-        # Extract fields from the form
         role_title = request.form.get('role', '').strip()
         description = request.form.get('description', '').strip()
         seniority = request.form.get('seniority', '').strip()
         skills_input = request.form.get('skills', '').strip()
         company = request.form.get('company', '').strip()
 
-        # Validate required fields
         errors = []
         if not role_title:
             errors.append('Job title is required.')
@@ -456,12 +455,9 @@ def post_job():
                 flash(err, 'danger')
             return render_template('post_job.html')
 
-        # Normalise the skills input into a JSON encoded list.  Users can
-        # separate entries with commas, semicolons or newlines.
         skills_list = [s.strip() for s in re.split(r'[\n,;]+', skills_input) if s.strip()]
         skills_json = json.dumps(skills_list)
 
-        # Create and persist the new job
         new_job = Job(
             role=role_title,
             description=description,
@@ -476,52 +472,35 @@ def post_job():
         flash('Job posted successfully!', 'success')
         return redirect(url_for('jobs'))
 
-    # GET request returns the form
     return render_template('post_job.html')
 
-
-# -----------------------------------------------------------------------------
-# Recruiter dashboard route
-#
-# Displays a list of candidates who applied to jobs posted by the current
-# recruiter.  Candidates are sorted by a simple skill match score computed
-# against the job requirements.  A placeholder download button is provided
-# for future PDF report functionality.
 @app.route('/dashboard')
 @login_required
 def dashboard():
-    # Only recruiters and admins can view the dashboard
     if current_user.role not in ('recruiter', 'admin'):
         flash('You do not have permission to access the dashboard.', 'warning')
         return redirect(url_for('index'))
 
-    # Fetch jobs posted by the current recruiter
     posted_jobs = Job.query.filter_by(recruiter_id=current_user.id).all()
     job_ids = [job.id for job in posted_jobs]
 
     candidates_with_scores = []
     if job_ids:
-        # Fetch applications associated with these job IDs
         candidate_apps = Application.query.filter(Application.job_id.in_(job_ids)).all()
 
-        # Helper to compute a match score based on skills overlap
         def compute_score(application):
             try:
-                # Extract candidate skills from stored JSON
                 candidate_features = json.loads(application.extracted_features) if application.extracted_features else {}
                 candidate_skills = candidate_features.get('skills', [])
-                # Retrieve the job's required skills and parse from JSON
                 job_skills = json.loads(application.job.skills) if application.job and application.job.skills else []
                 if not job_skills:
-                    return ('Medium', 2)  # Default when job specifies no skills
+                    return ('Medium', 2)
 
-                # Compute case‑insensitive intersection
                 candidate_set = {s.lower() for s in candidate_skills}
                 job_set = {s.lower() for s in job_skills}
                 common = candidate_set & job_set
                 ratio = len(common) / len(job_set) if job_set else 0
 
-                # Map ratio to qualitative score
                 if ratio >= 0.75:
                     return ('Excellent', 4)
                 elif ratio >= 0.5:
@@ -533,7 +512,6 @@ def dashboard():
             except Exception:
                 return ('Medium', 2)
 
-        # Build a list of candidate applications with computed scores
         for app_record in candidate_apps:
             score_label, score_value = compute_score(app_record)
             candidates_with_scores.append({
@@ -542,15 +520,34 @@ def dashboard():
                 'score_value': score_value
             })
 
-        # Sort candidates from highest to lowest score
         candidates_with_scores.sort(key=lambda item: item['score_value'], reverse=True)
 
     return render_template('dashboard.html', candidates=candidates_with_scores)
 
 if __name__ == '__main__':
     print("Starting Codingo application...")
+    
+    # Import torch to check GPU availability
+    try:
+        import torch
+        if torch.cuda.is_available():
+            print(f"GPU Available: {torch.cuda.get_device_name(0)}")
+            print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+        else:
+            print("No GPU available, using CPU")
+    except ImportError:
+        print("PyTorch not installed, chatbot will use CPU")
+    
     with app.app_context():
         db.create_all()
+        # Pre-initialize chatbot on startup for faster first response
+        print("Initializing chatbot...")
+        try:
+            init_chatbot()
+            init_hf_model()
+            print("Chatbot initialized successfully")
+        except Exception as e:
+            print(f"Chatbot initialization warning: {e}")
     
     # Use port from environment or default to 7860
     port = int(os.environ.get('PORT', 7860))

requirements.txt

@@ -28,15 +28,12 @@ cohere==5.16.1
 # Vector DB
 qdrant-client==1.14.3
 
-# PDF & DOCX parsing (removed; resume parsing is no longer supported)
-
 # Audio processing
 ffmpeg-python==0.2.0
 inputimeout==1.0.4
 evaluate==0.4.5
 accelerate==0.29.3
 huggingface_hub==0.20.3
-# textract removed; no resume parsing
 bitsandbytes
 faster-whisper==0.10.0
 edge-tts==6.1.2
@@ -46,17 +43,17 @@ gunicorn
 python-dotenv
 
 # --- Chatbot Dependencies ---
-# The chatbot feature relies on a vector database for semantic search over
-# the knowledge base stored in ``chatbot/chatbot.txt``.  ``chromadb`` provides
-# this capability.  We removed the OpenAI dependency in favour of a local
-# Hugging Face model, so no openai package is required.  ``flask-cors`` is
-# retained to allow cross‑origin requests should the chat UI be decoupled in
-# the future.
+# Vector database for semantic search
 chromadb>=0.4.0
+# CORS support for potential future decoupling
 flask-cors>=4.0.0
 
 # Audio format conversion (critical for WebM/WAV handling)
 pydub>=0.25.1
 
 # Better error handling for API calls
-requests>=2.31.0
+requests>=2.31.0
+
+# Additional dependencies for improved chatbot functionality
+# Note: We're using DialoGPT which requires transformers (already included above)
+# No OpenAI dependency needed - using Hugging Face models instead