updated

backend/services/codingo_chatbot.py

@@ -6,22 +6,7 @@ This module encapsulates the logic for Codingo's website chatbot.  It
 loads a knowledge base from ``chatbot/chatbot.txt``, builds a vector
 database using Chroma and SentenceTransformers, and uses a local LLM
 powered by ``llama‑cpp‑python`` to generate answers constrained to the
-retrieved context.  The code is written to initialise all heavy
-resources lazily on first use and to cache them for subsequent
-requests.  This prevents repeated model downloads and avoids
-recomputing embeddings for every chat query.
-
-The underlying LLM is the TinyLlama 1.1B chat model distributed via
-Hugging Face in GGUF format.  When the model file is not present
-locally it is downloaded automatically using ``huggingface_hub``.
-Depending on the environment the model will run on GPU if CUDA is
-available or fall back to CPU otherwise.  See the ``init_llm``
-function for details.
-
-Note: This module deliberately contains no references to OpenAI.  It
-relies solely on open‑source libraries available on PyPI (such as
-``llama‑cpp‑python`` and ``chromadb``) so that it can be used on
-Hugging Face Spaces without requiring proprietary API keys.
+retrieved context.
 """
 
 from __future__ import annotations
@@ -41,80 +26,54 @@ from huggingface_hub import hf_hub_download
 try:
     from llama_cpp import Llama  # type: ignore
 except Exception as exc:  # pragma: no cover - import may fail until dependency installed
-    # Provide a helpful error if llama_cpp isn't installed.
     raise ImportError(
         "llama_cpp is required for the chatbot. Please add 'llama-cpp-python' "
         "to your requirements.txt"
     ) from exc
 
-# ---------------------------------------------------------------------------
 # Configuration
-#
-# Compute the absolute path to the chatbot knowledge base.  We derive this
-# relative to this file so that the module works regardless of the working
-# directory.  The project structure places ``chatbot.txt`` at
-# ``Codingo12/chatbot/chatbot.txt``.
 PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 CHATBOT_TXT_PATH = os.path.join(PROJECT_ROOT, "chatbot", "chatbot.txt")
-
-# Directory where Chroma will persist its database.  This location is
-# writable on both local machines and Hugging Face Spaces.  It is
-# intentionally distinct from the web app instance path to avoid
-# permission issues.
 CHROMA_DB_DIR = os.path.join("/tmp", "chatbot_chroma")
 
-# Settings for the TinyLlama model.  These can be overridden via
-# environment variables if desired (for example to switch to a
-# different quantisation or to test with a smaller model).  See
-# https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF for
-# available filenames.
-LLAMA_REPO = os.getenv(
-    "LLAMA_REPO",
-    "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
-)
-LLAMA_FILE = os.getenv(
-    "LLAMA_FILE",
-    "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf",
-)
-
-# Local directory where the GGUF model file will be stored.  Using
-# ``/tmp`` avoids writing into the read‑only repository filesystem on
-# Hugging Face Spaces.  The directory will be created as needed.
+# TinyLlama model settings
+LLAMA_REPO = os.getenv("LLAMA_REPO", "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF")
+LLAMA_FILE = os.getenv("LLAMA_FILE", "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf")
 LLAMA_LOCAL_DIR = os.path.join("/tmp", "llama_models")
 
-# Generation parameters.  These values mirror those used in the
-# provided Jupyter notebook.  They can be tweaked via environment
-# variables if necessary to trade off quality against speed.
-MAX_TOKENS = int(os.getenv("LLAMA_MAX_TOKENS", "256"))
-TEMPERATURE = float(os.getenv("LLAMA_TEMPERATURE", "0.7"))
+# Generation parameters - adjusted for better responses
+MAX_TOKENS = int(os.getenv("LLAMA_MAX_TOKENS", "512"))
+TEMPERATURE = float(os.getenv("LLAMA_TEMPERATURE", "0.3"))
 TOP_P = float(os.getenv("LLAMA_TOP_P", "0.9"))
-REPEAT_PENALTY = float(os.getenv("LLAMA_REPEAT_PENALTY", "1.15"))
+REPEAT_PENALTY = float(os.getenv("LLAMA_REPEAT_PENALTY", "1.1"))
 
-# Thread lock to guard lazy initialisation in multi‑threaded Flask
-# environments.  Without this lock multiple concurrent requests may
-# attempt to download the model or populate the database at the same
-# time, leading to redundant work or race conditions.
+# Thread lock and globals
 _init_lock = threading.Lock()
-
-# Global singletons for embedder, vector collection and LLM.  These
-# variables are populated on first use and reused thereafter.
 _embedder: SentenceTransformer | None = None
 _collection: chromadb.Collection | None = None
 _llm: Llama | None = None
 
 
 def _load_chatbot_text() -> str:
-    """Read the chatbot knowledge base from disk.
-
-    If the file is missing, a small default description of Codingo is
-    returned.  This ensures the chatbot still provides a sensible
-    answer rather than crashing.
-    """
+    """Read the chatbot knowledge base from disk."""
     try:
         with open(CHATBOT_TXT_PATH, encoding="utf-8") as f:
-            return f.read()
+            content = f.read()
+            # Clean up the content to avoid meta-descriptions
+            # Remove any lines that look like instructions about the chatbot
+            lines = content.split('\n')
+            cleaned_lines = []
+            for line in lines:
+                # Skip lines that describe what the chatbot does
+                if any(phrase in line.lower() for phrase in [
+                    'the chatbot', 'this bot', 'the bot provides', 
+                    'chatbot provides', 'chatbot is used for',
+                    'official chatbot of'
+                ]):
+                    continue
+                cleaned_lines.append(line)
+            return '\n'.join(cleaned_lines)
     except FileNotFoundError:
-        # Fallback content if the knowledge base file is missing
         return (
             "Codingo is an AI‑powered recruitment platform designed to "
             "streamline job applications, candidate screening and hiring. "
@@ -124,42 +83,30 @@ def _load_chatbot_text() -> str:
 
 
 def init_embedder_and_db() -> None:
-    """Initialise the SentenceTransformer embedder and Chroma vector DB.
-
-    This function is idempotent: if the embedder and collection are
-    already initialised it returns immediately.  Otherwise it reads
-    ``chatbot.txt``, splits it into overlapping chunks, computes
-    embeddings and persists them to a Chroma collection.  The
-    resulting ``SentenceTransformer`` and collection objects are saved
-    in global variables for later reuse.
-    """
+    """Initialize the SentenceTransformer embedder and Chroma vector DB."""
     global _embedder, _collection
     if _embedder is not None and _collection is not None:
         return
     with _init_lock:
         if _embedder is not None and _collection is not None:
             return
-        # Ensure persistence directory exists
+        
         os.makedirs(CHROMA_DB_DIR, exist_ok=True)
-
-        # Read knowledge base
         text = _load_chatbot_text()
-
-        # Split into chunks; use double newlines to prefer splitting on
-        # paragraph boundaries.  Overlap helps the model maintain
-        # context across neighbouring chunks.
+        
+        # Split into chunks
         splitter = RecursiveCharacterTextSplitter(
-            chunk_size=300,
+            chunk_size=500,  # Increased for better context
             chunk_overlap=100,
-            separators=["\n\n"],
+            separators=["\n\n", "\n", ". ", " "],
         )
         docs: List[str] = [doc.strip() for doc in splitter.split_text(text) if doc.strip()]
-
-        # Initialise embedder (MiniLM).  We specify device via env.
+        
+        # Initialize embedder
         embedder = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
         embeddings = embedder.encode(docs, show_progress_bar=False, batch_size=32)
-
-        # Initialise Chroma client
+        
+        # Initialize Chroma
         client = chromadb.Client(
             Settings(
                 persist_directory=CHROMA_DB_DIR,
@@ -167,15 +114,11 @@ def init_embedder_and_db() -> None:
                 is_persistent=True,
             )
         )
-
-        # Create or get collection.  This returns an existing collection if
-        # already present on disk.
+        
+        # Create or get collection
         collection = client.get_or_create_collection("codingo_chatbot")
-
-        # Populate collection only if empty.  A naive call to
-        # ``collection.get(limit=1)`` may raise if the collection does
-        # not exist yet, so we catch any exception and treat it as an
-        # empty DB.  Distances are stored as cosine similarity.
+        
+        # Populate if empty
         need_populate = False
         try:
             existing = collection.get(limit=1)
@@ -183,137 +126,145 @@ def init_embedder_and_db() -> None:
                 need_populate = True
         except Exception:
             need_populate = True
+            
         if need_populate:
             ids = [f"doc_{i}" for i in range(len(docs))]
             collection.add(documents=docs, embeddings=embeddings.tolist(), ids=ids)
+            
         _embedder = embedder
         _collection = collection
 
 
 def init_llm() -> None:
-    """Initialise the llama‑cpp model for response generation.
-
-    This function lazily downloads the GGUF model from Hugging Face if
-    necessary and instantiates a ``llama_cpp.Llama`` object.  The
-    resulting instance is stored in the global ``_llm`` variable.  To
-    control GPU usage set the ``CUDA_VISIBLE_DEVICES`` environment
-    variable or override ``LLAMA_N_GPU_LAYERS``.  By default we use one
-    GPU layer when CUDA is available, otherwise the model runs on CPU.
-    """
+    """Initialize the llama‑cpp model for response generation."""
     global _llm
     if _llm is not None:
         return
     with _init_lock:
         if _llm is not None:
             return
-        # Ensure the model directory exists
+            
         os.makedirs(LLAMA_LOCAL_DIR, exist_ok=True)
-        # Download model if not already present
         local_path = os.path.join(LLAMA_LOCAL_DIR, LLAMA_FILE)
+        
         if not os.path.exists(local_path):
-            # The file will be downloaded to LLAMA_LOCAL_DIR.  Use
-            # ``local_dir_use_symlinks=False`` to avoid creating
-            # symlinks that may break on certain filesystems.
             local_path = hf_hub_download(
                 repo_id=LLAMA_REPO,
                 filename=LLAMA_FILE,
                 local_dir=LLAMA_LOCAL_DIR,
                 local_dir_use_symlinks=False,
             )
-        # Determine GPU usage.  We default to one GPU layer if CUDA
-        # appears available.  Users can override via LLAMA_N_GPU_LAYERS.
+        
+        # GPU configuration
         try:
-            import torch  # type: ignore
+            import torch
             use_cuda = torch.cuda.is_available()
         except Exception:
             use_cuda = False
-        n_gpu_layers_env = os.getenv("LLAMA_N_GPU_LAYERS")
-        if n_gpu_layers_env:
-            try:
-                n_gpu_layers = int(n_gpu_layers_env)
-            except ValueError:
-                n_gpu_layers = 0
-        else:
-            n_gpu_layers = 1 if use_cuda else 0
-        # Construct the Llama instance.  The context window is set
-        # generously to 2048 tokens; adjust via LLAMA_N_CTX if needed.
+            
+        n_gpu_layers = int(os.getenv("LLAMA_N_GPU_LAYERS", "35" if use_cuda else "0"))
         n_ctx = int(os.getenv("LLAMA_N_CTX", "2048"))
-        # Use half the available CPU cores for inference threads to
-        # balance responsiveness and resource use.
-        try:
-            n_threads = max(1, os.cpu_count() // 2)
-        except Exception:
-            n_threads = 2
+        n_threads = max(1, os.cpu_count() // 2) if os.cpu_count() else 4
+        
         _llm = Llama(
             model_path=local_path,
             n_ctx=n_ctx,
             n_threads=n_threads,
             n_gpu_layers=n_gpu_layers,
+            verbose=False,  # Reduce logging
         )
 
 
 def _build_prompt(query: str, context: str) -> str:
-    """Construct the full prompt for the TinyLlama chat model.
-
-    The prompt format follows the conventions used by the model as
-    illustrated in the provided notebook.  We include a system message
-    instructing the model to answer only using the given context and to
-    politely decline if the information is unavailable.
-    """
+    """Construct a natural prompt for the TinyLlama chat model."""
+    # Use a more direct, conversational system prompt
     system_prompt = (
-        "You are the official chatbot of Codingo. "
-        "Answer ONLY by using the CONTEXT. "
-        "If the information is not available for you, say it politely."
-    )
-    prompt = (
-        f"<|system|>\n{system_prompt}</s>\n"
-        f"<|user|>\n{query}\n\nCONTEXTE:\n{context}</s>\n"
-        f"<|assistant|>\n"
+        "You are LUNA, a friendly AI assistant for the Codingo recruitment platform. "
+        "Answer questions naturally and conversationally. Use the provided information "
+        "to give helpful, direct answers. Keep responses concise and relevant."
     )
+    
+    # Build the prompt with context integrated naturally
+    if context:
+        prompt = (
+            f"<|system|>\n{system_prompt}</s>\n"
+            f"<|user|>\nContext: {context}\n\n"
+            f"Question: {query}</s>\n"
+            f"<|assistant|>\n"
+        )
+    else:
+        prompt = (
+            f"<|system|>\n{system_prompt}</s>\n"
+            f"<|user|>\n{query}</s>\n"
+            f"<|assistant|>\n"
+        )
+    
     return prompt
 
 
-def get_response(query: str, k: int = 3, score_threshold: float = 2.0) -> str:
-    """Return a chatbot response for the given query.
-
-    This function performs the following steps:
-
-    1. Ensures the embedder, vector database and LLM are initialised.
-    2. Embeds the user's query and retrieves the top ``k`` most
-       similar documents from the Chroma collection.
-    3. Filters out documents whose cosine distance exceeds
-       ``score_threshold`` (larger distances indicate less similarity).
-    4. Builds a prompt containing the user query and the concatenated
-       relevant context.
-    5. Feeds the prompt to the TinyLlama model and returns its
-       response, trimming trailing whitespace.
-
-    If no relevant context is found, a fallback message is returned.
-    """
+def get_response(query: str, k: int = 3, score_threshold: float = 1.5) -> str:
+    """Return a chatbot response for the given query."""
     if not query or not query.strip():
-        return "Please type a question about the Codingo platform."
+        return "Hi! I'm LUNA, your Codingo assistant. How can I help you today?"
+    
     init_embedder_and_db()
     init_llm()
+    
     assert _embedder is not None and _collection is not None and _llm is not None
-    # Embed query and search collection
+    
+    # Handle greetings directly
+    greetings = ['hi', 'hello', 'hey', 'good morning', 'good afternoon', 'good evening']
+    if query.lower().strip() in greetings:
+        return "Hello! I'm LUNA, your AI assistant for Codingo. How can I help you with our recruitment platform today?"
+    
+    # Embed query and search
     query_vector = _embedder.encode([query])[0]
     results = _collection.query(query_embeddings=[query_vector.tolist()], n_results=k)
+    
     docs = results.get("documents", [[]])[0] if results else []
     distances = results.get("distances", [[]])[0] if results else []
-    # Filter by score
+    
+    # Filter by score (lower threshold for better matching)
     relevant: List[str] = [d for d, s in zip(docs, distances) if s < score_threshold]
+    
     if not relevant:
-        return "Sorry, I don't have enough information to answer that question."
-    context = "\n\n".join(relevant)
+        # Provide a helpful response even without specific context
+        return (
+            "I don't have specific information about that in my knowledge base. "
+            "However, I can tell you that Codingo is an AI-powered recruitment platform "
+            "that helps with job applications, candidate screening, and hiring. "
+            "Would you like to know more about our features?"
+        )
+    
+    # Join context with better formatting
+    context = " ".join(relevant[:2])  # Use top 2 most relevant chunks
     prompt = _build_prompt(query, context)
-    # Generate completion
+    
+    # Generate response with better parameters
     output = _llm(
         prompt,
         max_tokens=MAX_TOKENS,
         temperature=TEMPERATURE,
         top_p=TOP_P,
         repeat_penalty=REPEAT_PENALTY,
-        stop=["</s>"]
+        stop=["</s>", "<|user|>", "<|system|>"],
+        echo=False,
     )
+    
+    # Extract and clean the response
     text = output["choices"][0]["text"].strip()
-    return text or "I'm here to answer your questions about Codingo. What would you like to know?"
+    
+    # Remove any meta-descriptions that might have leaked through
+    lines = text.split('\n')
+    cleaned_lines = []
+    for line in lines:
+        if any(phrase in line.lower() for phrase in [
+            'the chatbot', 'this bot', 'the bot provides',
+            'in response to', 'overall,'
+        ]):
+            continue
+        cleaned_lines.append(line)
+    
+    text = '\n'.join(cleaned_lines).strip()
+    
+    return text or "I'm here to help you with Codingo. Could you please rephrase your question?"

chatbot/chatbot.txt

@@ -1,38 +1,59 @@
-INTRODUCTION: Codingo is an AI-driven recruitment platform designed to streamline job applications, candidate screening, and hiring. We aim to make hiring smarter, faster, and fairer through automation and intelligent recommendations.
+Codingo Platform Overview
 
-HOW THE PLATFORM WORKS: FOR CANDIDATES: Create a profile with personal and professional details. Upload your resume (PDF or DOC). Add portfolio links (GitHub, LinkedIn, personal website). AI matches you with job postings that suit your skills. Receive instant CV improvement tips. Apply to jobs directly or save for later.
+Codingo is an innovative AI-powered recruitment platform that revolutionizes the hiring process. We connect talented job seekers with forward-thinking employers through intelligent matching and automation.
 
-HOW THE PLATFORM WORKS: FOR EMPLOYERS: Post job descriptions with required skills and qualifications. Filter and narrow down candidate lists. Review top-matched applicants. Use the chatbot to answer candidate or hiring questions. Get automated screening insights.
+Key Features
 
-WHAT MAKES CODINGO SPECIAL: AI that understands both tech and language. Real-time CV feedback. Bias-aware algorithms. Built-in content moderation and chatbot filtering. Tailored for developers, designers, and digital professionals.
+Smart Job Matching: Our AI analyzes your skills, experience, and preferences to match you with the most suitable job opportunities. The matching algorithm considers technical skills, soft skills, experience level, and career goals.
 
-CV & PORTFOLIO TIPS: Keep resumes under 2 pages. Use action words like "developed", "led", "optimized". Include quantifiable metrics. Tailor your resume to each job. Portfolio should include 3-5 projects with clear documentation.
+Automated Resume Parsing: Upload your resume in PDF or DOCX format, and our system automatically extracts relevant information including skills, education, work experience, and contact details.
 
-CHATBOT RULES & LIMITATIONS: Only answers Codingo-related questions. Refuses to respond to personal, political, or unrelated queries. Does not provide legal or medical advice. Typo tolerance for job-related keywords and tech terms. Responds based on platform content only.
+AI-Powered Interviews: Practice with our AI interviewer LUNA, who conducts realistic interview simulations tailored to specific job roles. Get instant feedback on your responses and improve your interview skills.
 
-AI MATCHING ENGINE: Uses NLP to match skills. Cosine similarity for job description and profile comparison. Named Entity Recognition for understanding job titles. Intent detection for distinguishing job search vs application help.
+Real-Time Application Tracking: Monitor your application status in real-time. Know when recruiters view your profile and track your progress through different stages of the hiring process.
 
-SUPPORTED JOB TYPES: Frontend Developer, Backend Developer, Full-Stack Developer, Data Scientist, UI/UX Designer, DevOps Engineer, Product Manager, QA Engineer, Mobile Developer, AI/ML Engineer.
+For Job Seekers
 
-CONTENT POLICY: Professional, unbiased, safe, and aligned with the brand voice. No profanity, hate speech, or collection of personal data. No controversial topics in responses.
+Creating Your Profile: Sign up with your email and create a comprehensive profile. Include your skills, experience, education, and career objectives for better matching.
 
-SECURITY & PRIVACY: User data is encrypted and stored securely. No data used for advertising. You can delete your data anytime via profile settings.
+Improving Your Match Score: To get better job matches, ensure your profile is complete with all relevant skills listed. Use keywords from job descriptions you're interested in. Keep your experience section updated with recent projects and achievements.
 
-FREQUENTLY ASKED QUESTIONS:
-Q: How can I improve my match score?
-A: Update your profile with accurate skills and project links. Add keywords from job descriptions.
+Applying for Jobs: Browse available positions, view detailed job descriptions, and apply with one click. Your parsed resume data is automatically included with your application.
 
-Q: Can I use the chatbot to write my resume?
-A: The chatbot provides tips, but doesn't generate full resumes.
+Interview Preparation: Use our AI interview feature to practice common questions for your target role. The system provides personalized feedback to help you improve.
 
-Q: What if I see an error in my profile?
-A: Edit your profile at any time. For technical issues, contact support.
+For Recruiters
 
-Q: Is Codingo free?
-A: Profile creation and job applications are free. Premium features may be offered for advanced analytics.
+Posting Jobs: Create detailed job postings with required skills, experience level, and job descriptions. Our system helps you reach qualified candidates quickly.
 
-CONTACT & SUPPORT:
-Email: [email protected]
-Website: https://www.codingo.ai
-LinkedIn: https://linkedin.com/company/codingo
-Help Center: https://www.codingo.ai/help
+Candidate Screening: Our AI automatically screens applications and ranks candidates based on skill match, experience relevance, and other criteria you specify.
+
+Dashboard Analytics: Access comprehensive analytics about your job postings, including view counts, application rates, and candidate quality metrics.
+
+Efficient Hiring: Reduce time-to-hire by up to 60% with our automated screening and ranking system. Focus on interviewing only the most qualified candidates.
+
+Technical Information
+
+Supported File Formats: We accept PDF and DOCX formats for resume uploads. Maximum file size is 10MB.
+
+Skills Matching: Our platform recognizes over 5,000 technical and soft skills across various industries. The matching algorithm uses semantic understanding to identify related skills.
+
+Privacy and Security: All user data is encrypted and stored securely. We never share personal information without explicit consent.
+
+Platform Availability: Codingo is accessible via web browser on desktop and mobile devices. We recommend Chrome, Firefox, or Safari for the best experience.
+
+Getting Started
+
+New Users: Click "Sign Up" on the homepage. Choose whether you're a job seeker or recruiter. Complete your profile with accurate information.
+
+Job Search: Use filters to narrow down opportunities by location, salary range, experience level, and required skills.
+
+Application Tips: Tailor your profile to each application. Highlight relevant experience and skills that match the job requirements.
+
+Support and Help
+
+Contact Support: Reach out to our support team at [email protected] for technical issues or questions about the platform.
+
+FAQs: Visit our FAQ section for answers to common questions about using Codingo effectively.
+
+Best Practices: Regular profile updates increase visibility. Respond promptly to recruiter messages. Use professional language in all communications.