feat: implement recommendation engine architecture with chatbot logic, intent classification, and project validation modules.

src/recommendation_engine/chatbot_engine.py

@@ -26,12 +26,125 @@ from src.recommendation_engine.full_project_generator import (
 
 import re
 
+# ─────────────────────────────────────────────
+#  Project Idea Validator + Categorizer
+# ─────────────────────────────────────────────
+def validate_and_categorize_project(title: str, abstract: str = "") -> dict:
+    """
+    Uses Gemini to:
+    1. Verify whether the title is a valid graduation project idea.
+    2. Assign it to the best-matching domain from the known list.
+
+    Returns:
+        {
+            "is_valid": bool,
+            "domain": str | None,
+            "reason": str
+        }
+    """
+    known_domains = [d for d in DOMAIN_KEYWORDS.keys() if d != "Others"]
+    domain_list_str = "\n".join(f"- {d}" for d in known_domains)
+
+    prompt = f"""
+You are an expert academic advisor evaluating graduation project ideas.
+
+Project Title: "{title}"
+{"Abstract: " + abstract[:400] if abstract else ""}
+
+Task 1 – Validity Check:
+Is this a valid, feasible graduation project idea for a university student?
+- It must be a technical or academic topic (not a random phrase, celebrity name, or nonsense)
+- It should be specific enough to build something real
+Answer: YES or NO
+
+Task 2 – Domain Classification:
+If valid, which ONE of the following domains best fits this project?
+{domain_list_str}
+
+Return your answer in this EXACT format (two lines only):
+VALID: YES
+DOMAIN: <domain name from the list above>
+
+If invalid:
+VALID: NO
+DOMAIN: None
+REASON: <one sentence why>
+"""
+    try:
+        raw = generate_text(prompt, task="intent").strip()
+        lines = {line.split(":", 1)[0].strip().upper(): line.split(":", 1)[1].strip()
+                 for line in raw.splitlines() if ":" in line}
+
+        is_valid = lines.get("VALID", "NO").upper() == "YES"
+        domain = lines.get("DOMAIN", "").strip()
+        reason = lines.get("REASON", "")
+
+        if domain == "None" or domain not in known_domains:
+            domain = None
+        return {"is_valid": is_valid, "domain": domain, "reason": reason}
+
+    except Exception:
+        return {"is_valid": True, "domain": None, "reason": ""}
+
+
 def extract_number(text: str, default=5):
 
     nums = re.findall(r"\d+", text)
 
     return min(int(nums[0]), 20) if nums else default
 
+def classify_input_context(user_input: str) -> str:
+    prompt = f"""
+You are an advanced AI assistant classifying user input for a graduation project recommendation engine.
+Analyze the user's input and classify its intent and context into exactly ONE of the following categories:
+
+1. greeting: A greeting like "hello", "hi", "hey".
+2. confirmation_yes: A positive response/agreement like "yes", "yeah", "yep", "sure".
+3. confirmation_no: A negative response/disagreement like "no", "nope", "not really", "la".
+4. idea_request: Asking to suggest, recommend, or generate project ideas (e.g., "give me AI ideas", "ideas for healthcare").
+5. feature_request: Asking to generate or suggest features for a project (e.g., "generate features", "suggest features").
+6. full_project_request: Asking to generate a full project specification or complete project (e.g., "generate full project", "complete project").
+7. project_title: Providing a potential graduation project title to start or evaluate (e.g., "Smart hospital system", "AI-based library portal").
+8. general_chat: General questions, questions about coding, concepts, general knowledge, or any explanation requests that are NOT a project title (e.g., "what is front end", "what is graduation project", "explain blockchain", "tell me about world cup", "i want know what is graduation project").
+
+User input: "{user_input}"
+
+Return ONLY the classification name as a single word from: greeting, confirmation_yes, confirmation_no, idea_request, feature_request, full_project_request, project_title, general_chat.
+Do not include any other text or punctuation.
+"""
+    try:
+        res = generate_text(prompt, task="intent").strip().lower()
+        res = res.split()[0].strip().replace(".", "").replace(",", "")
+        return res
+    except Exception as e:
+        return "general_chat"
+
+def is_valid_graduation_project_domain(domain: str) -> bool:
+    # 1. Quick local validation for standard domains
+    extracted = extract_domain(domain)
+    if extracted and extracted.lower() != "others":
+        return True
+
+    # 2. Fall back to LLM validation
+    prompt = f"""
+Determine if the following domain/field is a valid academic, engineering, scientific, or technology domain suitable for a university graduation project (e.g., Computer Science, Engineering, Medicine, Business, Agriculture, Biology, etc.).
+
+Domain to evaluate: "{domain}"
+
+Rules:
+- If it is a valid field of study, technology, or academic discipline (e.g., "artificial intelligence", "robotics", "bioinformatics", "educational games") -> Return YES
+- If it is unrelated to academic/technology graduation projects, or contains names of celebrities, sports teams, food, pop culture, or random questions (e.g., "messi", "fc barcelona", "pizza", "what is this") -> Return NO
+
+Return ONLY "YES" or "NO".
+"""
+    try:
+        res = generate_text(prompt, task="intent").strip().upper()
+        if not res:
+            return True
+        return "YES" in res
+    except Exception:
+        return True
+
 def is_weak_project_title(title: str) -> bool:
 
     if not title:
@@ -117,9 +230,6 @@ def looks_like_real_project_title(title: str) -> bool:
 
     lowered = title.lower()
 
-     
-    
-    
     question_starts = (
         "how ",
         "what ",
@@ -135,7 +245,9 @@ def looks_like_real_project_title(title: str) -> bool:
         "does "
     )
 
-    
+    for qs in question_starts:
+        if lowered.startswith(qs):
+            return False
 
     for p in nonsense_patterns:
         if p in lowered:
@@ -188,7 +300,24 @@ def looks_like_real_project_title(title: str) -> bool:
     "system",
     "platform",
     "application",
-    "app"
+    "app",
+    "website",
+    "portal",
+    "tool",
+    "game",
+    "generator",
+    "engine",
+    "software",
+    "database",
+    "model",
+    "chatbot",
+    "chat",
+    "assistant",
+    "network",
+    "api",
+    "mobile",
+    "web",
+    "smart"
 }
 
     if not any(
@@ -258,7 +387,12 @@ def is_gibberish_text(text: str) -> bool:
             "ux",
             "vr",
             "ar",
-            "iot"
+            "iot",
+            "no",
+            "la",
+            "n",
+            "y",
+            "ok"
         }
 
         if text in allowed_short:
@@ -352,6 +486,30 @@ def is_project_related(text: str) -> bool:
         for keyword in keywords
     )
 
+def is_general_question_or_unrelated_chat(text: str) -> bool:
+    lowered = text.strip().lower()
+    
+    # Ends with question mark
+    if lowered.endswith("?"):
+        return True
+        
+    # Starts with common question words
+    question_starts = (
+        "how ", "what ", "why ", "when ", "where ", "can ", "could ", "should ", 
+        "is ", "are ", "do ", "does ", "explain ", "tell me ", "show me ", "describe "
+    )
+    if lowered.startswith(question_starts):
+        return True
+        
+    # Contains common question phrases
+    question_phrases = (
+        "what is", "what's", "tell me about", "can you", "could you", "how to", "how do"
+    )
+    if any(phrase in lowered for phrase in question_phrases):
+        return True
+        
+    return False
+
 def chatbot(user_id: str, user_input: str):
 
     text = user_input.lower().strip()
@@ -374,11 +532,13 @@ def chatbot(user_id: str, user_input: str):
         "ideas"
     ]
 
-    if any(x in text for x in explicit_idea_requests):
-
-        state = get_user_memory(user_id).get("state") or default_state()
-
-        state["waiting_for_domain"] = True
+    if any(x in text for x in explicit_idea_requests) or text in ["change domain", "new domain", "reset domain", "reset", "restart"]:
+        memory = get_user_memory(user_id)
+        current_state = memory.get("state") or default_state()
+        
+        if not current_state.get("waiting_for_niche_domain"):
+            state = default_state()
+            state["waiting_for_domain"] = True
 
         save_user_memory(user_id, {
             "history": get_user_memory(user_id).get("history", []),
@@ -387,9 +547,10 @@ def chatbot(user_id: str, user_input: str):
 
         domain_list = "\n".join(f"- {d}" for d in DOMAIN_KEYWORDS.keys() if d != "Others")
         return (
-            f"Here are the available domains:\n\n"
+            f"Which domain is your project in? 📚\n\n"
             f"{domain_list}\n\n"
-            f"If your domain doesn't match any of these, you can choose 'Others'."
+            f"💡 Just type one of the domains above (e.g. **AI** or **Healthcare**)\n"
+            f"If your domain isn't listed, type **Others** to see more options."
         )
 
     
@@ -403,12 +564,12 @@ def chatbot(user_id: str, user_input: str):
     if is_gibberish_text(text):
 
         return (
-            "⚠️ I could not understand your request.\n\n"
-            "Try something meaningful like:\n"
-            "- generate AI project ideas\n"
-            "- generate features for smart hospital system\n"
-            "- improve my project\n"
-            "- suggest technologies for fintech app"
+            "Hmm, I didn't quite catch that 🤔\n\n"
+            "Here are some things you can try:\n"
+            "- Type **idea** → get graduation project ideas\n"
+            "- Type your project title → get smart features\n"
+            "- Type **generate full project** → complete project spec\n\n"
+            "💡 Tip: Start with **idea** if you're not sure!"
         )
     
     
@@ -425,6 +586,274 @@ def chatbot(user_id: str, user_input: str):
 
     state = memory.get("state") or default_state()
 
+    # Clear weak_title_candidate if user is submitting a new input
+    if state.get("weak_title_candidate"):
+        state["weak_title_candidate"] = None
+
+    words = text.split()
+    INAPPROPRIATE_KEYWORDS_QUICK = {
+        "fuck", "shit", "bitch", "ass", "dick", "cock", "pussy",
+        "porn", "sex", "naked", "nude", "rape", "kill", "murder",
+        "bastard", "whore", "slut", "cunt", "nigga", "nigger"
+    }
+    if any(w.lower() in INAPPROPRIATE_KEYWORDS_QUICK for w in words):
+        return (
+            "I can only help with graduation project topics 🎓\n\n"
+            "Please keep it academic! Type **idea** to get started."
+        )
+
+    # Early rejection of unrelated single-word inputs (like 'dia', 'diea') when not in an active flow
+    is_in_active_flow = (
+        state.get("waiting_for_domain") or
+        state.get("waiting_for_niche_domain") or
+        state.get("waiting_for_full_project_domain") or
+        state.get("waiting_for_full_project_selection") or
+        state.get("waiting_for_feature_title") or
+        state.get("waiting_for_title_confirmation") or
+        state.get("waiting_for_project_idea_confirm") or
+        state.get("weak_title_candidate")
+    )
+
+    if not is_in_active_flow:
+        if len(words) == 1:
+            allowed_single_words = {
+                "hi", "hello", "hey", "welcome",
+                "yes", "no", "y", "n", "ok", "yeah", "yep", "nope", "sure", "la",
+                "idea", "ideas", "suggest", "generate", "others", "other",
+                "exit", "quit", "clear", "reset", "restart", "change", "new", "discuss", "features", "feature", "chat",
+                "1", "2", "3"
+            }
+            for d, d_words in DOMAIN_KEYWORDS.items():
+                allowed_single_words.add(d.lower())
+                for w in d_words:
+                    allowed_single_words.update(w.lower().split())
+            
+            if words[0] not in allowed_single_words:
+                word = words[0]
+                # Otherwise treat it as a short/weak project title and guide the user
+                state["weak_title_candidate"] = user_input.strip()
+                save_user_memory(user_id, {
+                    "history": get_user_memory(user_id).get("history", []),
+                    "state": state
+                })
+                return (
+                    "📝 Your project title seems too short!\n\n"
+                    "A good graduation project title should be descriptive. For example:\n"
+                    "- AI-powered smart library recommendation system\n"
+                    "- Smart hospital emergency response platform\n"
+                    "- Blockchain-secured academic certificate verification\n\n"
+                    "Please enter a more descriptive title.\n\n"
+                    "💡 Or type **idea** to browse ready-made project ideas!"
+                )
+
+    state.setdefault("waiting_for_title_confirmation", False)
+    state.setdefault("pending_title", None)
+
+    context = classify_input_context(user_input)
+
+    # Intercept general questions / unrelated chat if no project is active yet
+    is_in_domain_or_selection_state = (
+        state.get("waiting_for_domain") or
+        state.get("waiting_for_niche_domain") or
+        state.get("waiting_for_full_project_domain") or
+        state.get("waiting_for_full_project_selection") or
+        state.get("waiting_for_feature_title") or
+        state.get("weak_title_candidate")
+    )
+
+    if not state.get("project_title") and not state.get("waiting_for_title_confirmation"):
+        should_intercept = False
+        if is_general_question_or_unrelated_chat(user_input):
+            should_intercept = True
+        elif context == "general_chat" and not is_in_domain_or_selection_state:
+            should_intercept = True
+
+        if should_intercept:
+            if context not in ["greeting", "confirmation_yes", "confirmation_no", "idea_request", "feature_request", "full_project_request"]:
+                # ── Content Safety Pre-Filter ──────────────────────────────────
+                # Reject clearly inappropriate/vulgar inputs before asking confirmation
+                INAPPROPRIATE_KEYWORDS = {
+                    "fuck", "shit", "bitch", "ass", "dick", "cock", "pussy",
+                    "porn", "sex", "naked", "nude", "rape", "kill", "murder",
+                    "bastard", "whore", "slut", "cunt", "nigga", "nigger",
+                    "idiot", "stupid", "dumb", "hate"
+                }
+                input_words = set(user_input.lower().split())
+                if input_words & INAPPROPRIATE_KEYWORDS:
+                    save_user_memory(user_id, {
+                        "history": history,
+                        "state": state
+                    })
+                    return (
+                        "I can only help with graduation project topics 🎓\n\n"
+                        "Please keep it academic! Try:\n"
+                        "- Type **idea** to browse project ideas\n"
+                        "- Type a real project title to get features"
+                    )
+                # ──────────────────────────────────────────────────────────────
+                state["waiting_for_title_confirmation"] = True
+                state["pending_title"] = user_input.strip()
+                save_user_memory(user_id, {
+                    "history": history,
+                    "state": state
+                })
+                return (
+                    f"Just to confirm — is this your graduation project title?\n\n"
+                    f"📝 \"{user_input.strip()}\"\n\n"
+                    "Reply **yes** to continue with it, or **no** to go back."
+                )
+
+    YES_WORDS = {"yes", "yep", "yeah", "sure", "y", "ok", "okay", "correct", "right", "yup", "of course", "absolutely"}
+    NO_WORDS = {"no", "nope", "n", "nah", "not really", "la", "negative"}
+
+    # ── Handle: User confirms the generated project idea ──────────────────────
+    if state.get("waiting_for_project_idea_confirm"):
+        raw_lower = user_input.strip().lower()
+        is_yes = context == "confirmation_yes" or raw_lower in YES_WORDS
+        is_no = context == "confirmation_no" or raw_lower in NO_WORDS
+
+        state["waiting_for_project_idea_confirm"] = False
+
+        if is_yes:
+            title = state.get("project_title", "")
+            abstract = state.get("abstract", "")
+
+            save_user_memory(user_id, {"history": history, "state": state})
+
+            validation = validate_and_categorize_project(title, abstract)
+
+            if validation["is_valid"]:
+                domain = validation.get("domain")
+                if domain:
+                    state["domain"] = domain
+                    state["category"] = domain
+                domain_line = f"📂 Domain: **{domain}**" if domain else "📂 Domain: (could not classify — please specify)"
+                save_user_memory(user_id, {"history": history, "state": state})
+                return (
+                    f"✅ Great choice! Your project idea has been validated and categorized.\n\n"
+                    f"📌 Title: {title}\n"
+                    f"{domain_line}\n\n"
+                    f"What would you like to do next?\n"
+                    f"1️⃣ Generate features\n"
+                    f"2️⃣ Talk with chatbot about the idea\n\n"
+                    f"👉 You can also say:\n"
+                    f"- generate features\n"
+                    f"- discuss project"
+                )
+            else:
+                reason = validation.get("reason", "")
+                save_user_memory(user_id, {"history": history, "state": state})
+                return (
+                    f"❌ Hmm, this doesn't seem like a valid graduation project idea.\n\n"
+                    f"{'Reason: ' + reason + chr(10) + chr(10) if reason else ''}"
+                    f"💡 Try typing **idea** to browse real project ideas, or enter a proper project title."
+                )
+
+        elif is_no:
+            save_user_memory(user_id, {"history": history, "state": state})
+            return (
+                "No problem! 😊\n\n"
+                "Type **idea** to start fresh with new project ideas, or paste a different project title anytime."
+            )
+
+        else:
+            # Re-ask
+            state["waiting_for_project_idea_confirm"] = True
+            save_user_memory(user_id, {"history": history, "state": state})
+            return (
+                f"Just checking — would you like to use this as your graduation project idea?\n\n"
+                f"📌 \"{state.get('project_title')}\"\n\n"
+                "Reply **yes** to confirm and categorize it, or **no** to try something else."
+            )
+
+    if state.get("waiting_for_title_confirmation"):
+        raw_lower = user_input.strip().lower()
+
+        # Reliable raw-text check first — don't fully trust LLM classification for yes/no
+        is_yes = context == "confirmation_yes" or raw_lower in YES_WORDS
+        is_no = context == "confirmation_no" or raw_lower in NO_WORDS
+
+        if is_yes:
+            project_title = state.get("pending_title", "")
+            state["waiting_for_title_confirmation"] = False
+            state["pending_title"] = None
+
+            # Validate the title is actually a real graduation project idea
+            validation = validate_and_categorize_project(project_title)
+
+            if not validation["is_valid"]:
+                reason = validation.get("reason", "")
+                state["waiting_for_title_confirmation"] = False
+                save_user_memory(user_id, {
+                    "history": history,
+                    "state": state
+                })
+                return (
+                    f"❌ That doesn't look like a valid graduation project title.\n\n"
+                    f"{'Reason: ' + reason + chr(10) + chr(10) if reason else ''}"
+                    f"💡 Try typing **idea** to browse real project ideas, or enter a proper project title like:\n"
+                    f"  AI-powered smart library recommendation system"
+                )
+
+            domain = validation.get("domain")
+            state = default_state()
+            state["project_title"] = project_title
+            state["waiting_for_project_action"] = True
+            if domain:
+                state["domain"] = domain
+                state["category"] = domain
+
+            save_user_memory(user_id, {
+                "history": history,
+                "state": state
+            })
+
+            domain_line = f"\n📂 Categorized under: **{domain}**" if domain else ""
+            return (
+                f"📌 Project confirmed!{domain_line}\n\n"
+                f"{project_title}\n\n"
+                "Choose what you want next:\n"
+                "1️⃣ Generate features\n"
+                "2️⃣ Talk with chatbot about the idea\n"
+                "3️⃣ Generate full project\n\n"
+                "👉 You can also say:\n"
+                "- generate features\n"
+                "- discuss project\n"
+                "- generate full project"
+            )
+
+        elif is_no:
+            state["waiting_for_title_confirmation"] = False
+            state["pending_title"] = None
+            save_user_memory(user_id, {
+                "history": history,
+                "state": state
+            })
+            return (
+                "No problem! 😊\n\n"
+                "I'm here to help with graduation projects. Try:\n"
+                "- Type **idea** to get project ideas\n"
+                "- Paste your project title to get features\n"
+                "- Type **generate full project** for a complete spec"
+            )
+
+        elif context == "greeting":
+            state["waiting_for_title_confirmation"] = False
+            state["pending_title"] = None
+
+        else:
+            # Still waiting — re-ask clearly
+            pending = state.get("pending_title", "")
+            save_user_memory(user_id, {
+                "history": history,
+                "state": state
+            })
+            return (
+                f"Just to confirm — is this your graduation project title?\n\n"
+                f"📝 \"{pending}\"\n\n"
+                "Reply **yes** to continue with it, or **no** to go back."
+            )
+
     
     state.setdefault("menu_mode", False)
     state.setdefault("selected_option", None)
@@ -450,18 +879,12 @@ def chatbot(user_id: str, user_input: str):
         })
 
         return (
-            "👋 Welcome!\n\n"
-            "I can help you with:\n"
-            "• Graduation project ideas\n"
-            "• Smart feature generation\n"
-            "• Project improvement\n"
-            "• Technology suggestions\n"
-            "• Project descriptions\n\n"
-            "Try saying things like:\n"
-            "- give me AI project ideas\n"
-            "- generate features for smart hospital system\n"
-            "- improve my graduation project\n"
-            "- suggest technologies for fintech app"
+            "👋 Welcome! I'm your Graduation Project Assistant 🎓\n\n"
+            "Here's how to get started:\n"
+            "1️⃣ Type **idea** → I'll suggest graduation project ideas by domain\n"
+            "2️⃣ Type your project title → I'll generate smart features for it\n"
+            "3️⃣ Type **generate full project** → get a complete project specification\n\n"
+            "✨ Not sure? Just type **idea** and I'll guide you step by step!"
         )
     
     
@@ -520,39 +943,28 @@ def chatbot(user_id: str, user_input: str):
                 result,
                 mode="merge"
             )
+            if state.get("domain"):
+                state["category"] = state.get("domain")
+
+            state["waiting_for_project_idea_confirm"] = True
 
             response = f"""
 📦 Full Project Generated
 
-📌 Title:
+📌 Project Title:
 {state.get("project_title")}
 
-📄 Abstract:
-{state.get("abstract")}
-
-📄 Description:
-{state.get("description")}
-
-⚙️ Features:
-{chr(10).join("- " + x for x in state.get("features", []))}
+📂 Category:
+{state.get("category")}
 
 🛠 Technologies:
-{chr(10).join("- " + x for x in state.get("technologies", []))}
-
-🎯 Objectives:
-{chr(10).join("- " + x for x in state.get("objectives", []))}
-
-⚡ Methodology:
-{state.get("methodology")}
+{", ".join(state.get("technologies", []))}
 
-🚀 Future Work:
-{chr(10).join("- " + x for x in state.get("future_work", []))}
-
-📂 Category:
-{state.get("category")}
+📄 Abstract:
+{state.get("abstract")}
 
-🏷 Keywords:
-{", ".join(state.get("keywords", []))}
+📄 Detailed Description:
+{state.get("description")}
 
 ❗ Problem Statement:
 {state.get("problem_statement")}
@@ -560,9 +972,13 @@ def chatbot(user_id: str, user_input: str):
 💡 Proposed Solution:
 {state.get("proposed_solution")}
 
-🤖 AI Summary:
-{state.get("ai_summary")}
-    """
+🎯 Objectives:
+{chr(10).join("- " + x for x in state.get("objectives", []))}
+
+──────────────────────
+📍 Would you like to use this as your graduation project idea?
+Reply **yes** to validate & categorize it, or **no** to explore other ideas.
+"""
 
             return finalize_response(
                 user_input,
@@ -583,12 +999,13 @@ def chatbot(user_id: str, user_input: str):
         })
 
         return (
-            "🎯 What domain do you want?\n\n"
-            "Examples:\n"
+            "🎯 What domain should the full project be in?\n\n"
+            "Just type one, for example:\n"
             "- AI\n"
-            "- healthcare\n"
-            "- education\n"
-            "- fintech"
+            "- Healthcare\n"
+            "- Education\n"
+            "- Fintech\n"
+            "- Cybersecurity"
         )
     
     
@@ -611,9 +1028,10 @@ def chatbot(user_id: str, user_input: str):
 
                 domain_list = "\n".join(f"- {d}" for d in DOMAIN_KEYWORDS.keys() if d != "Others")
                 return (
-                    f"Here are the available domains:\n\n"
+                    f"Which domain is your project in? 📚\n\n"
                     f"{domain_list}\n\n"
-                    f"If your domain doesn't match any of these, you can choose 'Others'."
+                    f"💡 Just type one of the domains above (e.g. **AI** or **Healthcare**)\n"
+                    f"If your domain isn't listed, type **Others** to see more options."
                 )
 
             elif text == "2":
@@ -628,10 +1046,11 @@ def chatbot(user_id: str, user_input: str):
                     })
 
                     return (
-                        "⚠️ Please provide the project title first.\n\n"
+                        "I need a project title first! 📝\n\n"
+                        "Type your project title and I'll generate features for it.\n"
                         "Example:\n"
-                        "- AI-powered smart library recommendation system\n\n"
-                        "👉 You can also ask me to generate an idea first."
+                        "  AI-powered smart library recommendation system\n\n"
+                        "💡 Or type **idea** if you'd like me to suggest one!"
                     )
 
                 save_user_memory(user_id, {
@@ -726,9 +1145,10 @@ def chatbot(user_id: str, user_input: str):
             })
 
             return (
-                f"💬 Chat mode enabled for:\n"
-                f"{state.get('project_title')}\n\n"
-                "You can now discuss or improve the project."
+                f"💬 Let's talk about your project!\n\n"
+                f"📌 {state.get('project_title')}\n\n"
+                "Ask me anything — how to improve it, what technologies to use,\n"
+                "or any questions about the idea. I'm here to help! 🚀"
             )
 
         
@@ -760,9 +1180,10 @@ def chatbot(user_id: str, user_input: str):
             })
 
             return (
-                f"💬 Chat mode enabled for:\n"
-                f"{state.get('project_title')}\n\n"
-                "You can now discuss or improve the project."
+                f"💬 Let's talk about your project!\n\n"
+                f"📌 {state.get('project_title')}\n\n"
+                "Ask me anything — how to improve it, what technologies to use,\n"
+                "or any questions about the idea. I'm here to help! 🚀"
             )
 
         
@@ -810,39 +1231,28 @@ def chatbot(user_id: str, user_input: str):
                 result,
                 mode="merge"
             )
+            if state.get("domain"):
+                state["category"] = state.get("domain")
+
+            state["waiting_for_project_idea_confirm"] = True
 
             response = f"""
 📦 Full Project Generated
 
-📌 Title:
+📌 Project Title:
 {state.get("project_title")}
 
-📄 Abstract:
-{state.get("abstract")}
-
-📄 Description:
-{state.get("description")}
-
-⚙️ Features:
-{chr(10).join("- " + x for x in state.get("features", []))}
+📂 Category:
+{state.get("category")}
 
 🛠 Technologies:
-{chr(10).join("- " + x for x in state.get("technologies", []))}
-
-🎯 Objectives:
-{chr(10).join("- " + x for x in state.get("objectives", []))}
-
-⚡ Methodology:
-{state.get("methodology")}
+{", ".join(state.get("technologies", []))}
 
-🚀 Future Work:
-{chr(10).join("- " + x for x in state.get("future_work", []))}
-
-📂 Category:
-{state.get("category")}
+📄 Abstract:
+{state.get("abstract")}
 
-🏷 Keywords:
-{", ".join(state.get("keywords", []))}
+📄 Detailed Description:
+{state.get("description")}
 
 ❗ Problem Statement:
 {state.get("problem_statement")}
@@ -850,8 +1260,12 @@ def chatbot(user_id: str, user_input: str):
 💡 Proposed Solution:
 {state.get("proposed_solution")}
 
-🤖 AI Summary:
-{state.get("ai_summary")}
+🎯 Objectives:
+{chr(10).join("- " + x for x in state.get("objectives", []))}
+
+──────────────────────
+📍 Would you like to use this as your graduation project idea?
+Reply **yes** to validate & categorize it, or **no** to explore other ideas.
 """
 
             return finalize_response(
@@ -865,73 +1279,30 @@ def chatbot(user_id: str, user_input: str):
     
     
     
-    if state.get("weak_title_candidate"):
-
-        improve_words = [
-            "1",
-            "make it descriptive",
-            "improve title",
-            "rewrite title",
-            "make better"
-        ]
-
-        if any(w in text for w in improve_words):
+    # (Removed previous weak_title_candidate selection block as option 1 / improve flow was removed)
 
-            weak_title = state.get("weak_title_candidate")
-
-            prompt = f"""
-                    You are a senior software architect.
-
-                    Convert this weak graduation project title
-                    into a professional and descriptive title.
-
-                    Weak title:
-                    {weak_title}
-
-                    Rules:
-                    - Keep original meaning
-                    - Make it specific
-                    - Make it professional
-                    - Keep it concise
-                    - Return ONLY the improved title
-                    """
+    
+    
+    
+    if state.get("waiting_for_feature_title"):
 
-            improved_title = generate_text(
-                prompt,
-                task="chat"
-            ).strip()
+        state["waiting_for_feature_title"] = False
 
-            state["weak_title_candidate"] = None
-            state["project_title"] = improved_title
-            state["waiting_for_project_action"] = True
+        possible_title = user_input.strip()
 
+        if not looks_like_real_project_title(possible_title):
+            state["waiting_for_title_confirmation"] = True
+            state["pending_title"] = possible_title
             save_user_memory(user_id, {
                 "history": history,
                 "state": state
             })
-
             return (
-                f"📌 Improved Project Title:\n"
-                f"{improved_title}\n\n"
-                "Choose what you want next:\n"
-                "1️⃣ Generate features\n"
-                "2️⃣ Talk with chatbot about the idea\n\n"
-                "👉 You can also say:\n"
-                "- generate features\n"
-                "- discuss project"
+                f"Just to confirm — is this your graduation project title?\n\n"
+                f"📝 \"{possible_title}\"\n\n"
+                "Reply **yes** to continue with it, or **no** to type a different title."
             )
-        
 
-    
-    
-    
-    if state.get("waiting_for_feature_title"):
-
-        state["waiting_for_feature_title"] = False
-
-        possible_title = user_input.strip()
-
-        
         if is_weak_project_title(possible_title):
 
             state["weak_title_candidate"] = possible_title
@@ -946,9 +1317,7 @@ def chatbot(user_id: str, user_input: str):
                 "Examples:\n"
                 "- AI-powered smart library recommendation system\n"
                 "- Smart hospital emergency response platform\n\n"
-                "Choose:\n"
-                "1️⃣ Make the title more descriptive\n"
-                "2️⃣ Enter another title"
+                "Please enter a more descriptive title."
             )
 
         
@@ -1014,8 +1383,9 @@ def chatbot(user_id: str, user_input: str):
 
         if text.startswith(pattern + " "):
 
-            pattern_idx = user_input.lower().find(pattern)
-            extracted_title = user_input[pattern_idx + len(pattern):].strip() if pattern_idx != -1 else ""
+            extracted_title = user_input.split(
+                pattern, 1
+            )[1].strip()
 
             if (
                 extracted_title
@@ -1233,62 +1603,87 @@ Choose what you want:
     
     if state.get("waiting_for_niche_domain"):
         text_lower = user_input.strip().lower()
-        more_words = ["more", "other", "another", "different", "none", "generate more"]
+        general_keywords = {"general", "general domain", "other", "others", "random", "anything", "whatever", "surprise me", "any", "mixed"}
         
-        if any(w in text_lower for w in more_words) and len(text_lower.split()) < 5:
-            previous_domains = state.get("suggested_domains", [])
-            niche_domains = generate_list(build_niche_domains_prompt(previous_domains), task="idea")
-            
-            state["suggested_domains"] = previous_domains + niche_domains
-            
-            domain_list_str = "\n".join(f"- {d}" for d in niche_domains)
-            response = (
-                f"Here are some MORE niche and cutting-edge domain ideas:\n\n"
-                f"{domain_list_str}\n\n"
-                f"Which one would you like to explore? (Or type your own!)"
-            )
-            save_user_memory(user_id, {"history": history, "state": state})
-            return finalize_response(user_input, response, history, state, user_id)
-        else:
-            domain = user_input.strip()
+        if text_lower in general_keywords:
+            state["waiting_for_domain"] = False
             state["waiting_for_niche_domain"] = False
             state["suggested_domains"] = []
-            analysis["domain"] = domain
+            analysis["domain"] = "general"
             analysis["intent"] = "idea"
             if "project_title" in analysis:
                 del analysis["project_title"]
+        else:
+            more_words = ["more", "another", "different", "none", "generate more"]
+            if any(w in text_lower for w in more_words) and len(text_lower.split()) < 5:
+                previous_domains = state.get("suggested_domains", [])
+                niche_domains = generate_list(build_niche_domains_prompt(previous_domains), task="idea")
+                
+                state["suggested_domains"] = previous_domains + niche_domains
+                
+                domain_list_str = "\n".join(f"- {d}" for d in niche_domains)
+                response = (
+                    f"Here are some MORE niche and cutting-edge domain ideas:\n\n"
+                    f"{domain_list_str}\n\n"
+                    f"Which one would you like to explore? (Or type your own!)"
+                )
+                save_user_memory(user_id, {"history": history, "state": state})
+                return finalize_response(user_input, response, history, state, user_id)
+            else:
+                domain = user_input.strip()
+                if not is_valid_graduation_project_domain(domain):
+                    return (
+                        "⚠️ That does not seem to be a valid technology or academic domain.\n\n"
+                        "Please enter a valid domain (e.g. AI, Healthcare, Fintech, or 'Others')."
+                    )
+                state["waiting_for_niche_domain"] = False
+                state["suggested_domains"] = []
+                analysis["domain"] = domain
+                analysis["intent"] = "idea"
+                if "project_title" in analysis:
+                    del analysis["project_title"]
         
     elif state.get("waiting_for_domain"):
-
-        detected = extract_domain(user_input)
-
-        if detected == "Others":
-            state["waiting_for_domain"] = False
-            state["waiting_for_niche_domain"] = True
-            
-            niche_domains = generate_list(build_niche_domains_prompt([]), task="idea")
-            state["suggested_domains"] = niche_domains
-            
-            domain_list_str = "\n".join(f"- {d}" for d in niche_domains)
-            response = (
-                f"You selected 'Others'. Here are some highly niche and cutting-edge domain ideas generated just for you:\n\n"
-                f"{domain_list_str}\n\n"
-                f"Which one would you like to explore? (Or type your own!)"
-            )
-            save_user_memory(user_id, {"history": history, "state": state})
-            return finalize_response(user_input, response, history, state, user_id)
-            
-        elif detected:
+        text_lower = user_input.strip().lower()
+        general_keywords = {"general", "general domain", "random", "anything", "whatever", "surprise me", "any", "mixed"}
+        
+        if text_lower in general_keywords:
             state["waiting_for_domain"] = False
-            analysis["domain"] = detected
+            state["waiting_for_niche_domain"] = False
+            analysis["domain"] = "general"
             analysis["intent"] = "idea"
             if "project_title" in analysis:
                 del analysis["project_title"]
         else:
-            return (
-                "⚠️ Please enter a valid domain "
-                "(AI, healthcare, fintech...)"
-            )
+            detected = extract_domain(user_input)
+
+            if detected.lower() == "others":
+                state["waiting_for_domain"] = False
+                state["waiting_for_niche_domain"] = True
+                
+                niche_domains = generate_list(build_niche_domains_prompt([]), task="idea")
+                state["suggested_domains"] = niche_domains
+                
+                domain_list_str = "\n".join(f"- {d}" for d in niche_domains)
+                response = (
+                    f"Great choice! Here are some cutting-edge niche domains to explore 🚀\n\n"
+                    f"{domain_list_str}\n\n"
+                    f"💡 Pick one from the list above, or type any domain you have in mind!"
+                )
+                save_user_memory(user_id, {"history": history, "state": state})
+                return finalize_response(user_input, response, history, state, user_id)
+                
+            elif detected:
+                state["waiting_for_domain"] = False
+                analysis["domain"] = detected
+                analysis["intent"] = "idea"
+                if "project_title" in analysis:
+                    del analysis["project_title"]
+            else:
+                return (
+                    "⚠️ Please enter a valid domain "
+                    "(AI, healthcare, fintech...)"
+                )
 
     intent = analysis.get("intent", "chat")
 
@@ -1296,6 +1691,16 @@ Choose what you want:
 
     user_project = analysis.get("project_title")
 
+    # Override intent using the LLM-derived semantic context when no project is active yet
+    if not state.get("project_title") and not is_in_domain_or_selection_state:
+        if context == "idea_request":
+            intent = "idea"
+        elif context == "feature_request":
+            intent = "feature"
+        elif context in ["general_chat", "project_title"]:
+            intent = "chat"
+            user_project = user_input.strip()
+
     
     
     
@@ -1363,6 +1768,7 @@ Choose what you want:
 
     if (
         domain
+        and domain.lower() != "others"
         and intent == "chat"
         and len(text.split()) <= 3
         and not any(cmd in text for cmd in full_project_commands)
@@ -1446,9 +1852,15 @@ Choose what you want:
     
     if user_project:
 
-        
-        
-        
+        if not looks_like_real_project_title(user_project):
+            state["waiting_for_title_confirmation"] = True
+            state["pending_title"] = user_project
+            save_user_memory(user_id, {
+                "history": history,
+                "state": state
+            })
+            return "Is that a project title?"
+
         if is_weak_project_title(user_project):
 
             state["weak_title_candidate"] = user_project
@@ -1464,11 +1876,7 @@ Choose what you want:
                 "- AI-powered smart library recommendation system\n"
                 "- Smart hospital emergency response platform\n"
                 "- Blockchain-secured academic certificate verification system\n\n"
-                "Choose:\n"
-                "1️⃣ Make the title more descriptive\n"
-                "2️⃣ Enter another title\n\n"
-                "👉 You can also say:\n"
-                "- make it descriptive"
+                "Please enter a more descriptive title."
             )
 
         state = default_state()
@@ -1521,10 +1929,11 @@ Choose what you want:
     ):
 
         return (
-            "Please give me the project title first.\n\n"
+            "I need a project title to generate features! 📝\n\n"
+            "Type your project title and I'll handle the rest.\n"
             "Example:\n"
-            "- AI-powered smart library recommendation system\n"
-            "- Smart hospital emergency response platform"
+            "  AI-powered smart library recommendation system\n\n"
+            "💡 Don't have a title yet? Type **idea** to browse project ideas first!"
         )
     
     
@@ -1542,9 +1951,10 @@ Choose what you want:
 
             domain_list = "\n".join(f"- {d}" for d in DOMAIN_KEYWORDS.keys() if d != "Others")
             return (
-                f"Here are the available domains:\n\n"
+                f"Which domain is your project in? 📚\n\n"
                 f"{domain_list}\n\n"
-                f"If your domain doesn't match any of these, you can choose 'Others'."
+                f"💡 Just type one of the domains above (e.g. **AI** or **Healthcare**)\n"
+                f"If your domain isn't listed, type **Others** to see more options."
             )
 
         top_k = analysis.get("number") or extract_number(
@@ -1564,6 +1974,20 @@ Choose what you want:
         state["domain"] = domain
         state["last_action"] = "idea"
 
+        # Clear project-specific keys to switch back to ideas stage
+        state["project_title"] = ""
+        state["features"] = []
+        state["description"] = ""
+        state["abstract"] = ""
+        state["technologies"] = []
+        state["originality_score"] = None
+        state["context_strength"] = None
+        state["problem_statement"] = ""
+        state["proposed_solution"] = ""
+        state["keywords"] = []
+        state["ai_summary"] = ""
+        state["category"] = ""
+
         response = format_response("idea", "", state)
         
         return finalize_response(
@@ -1591,8 +2015,10 @@ Choose what you want:
         if not state.get("project_title"):
 
             return (
-                "Please give me the project title first."
-            )
+            "I need a project title to generate features! 📝\n\n"
+            "Just type your project title and I'll generate smart features for it.\n"
+            "💡 No title yet? Type **idea** to get suggestions first!"
+        )
 
         top_k = analysis.get("number") or extract_number(
             user_input,
@@ -1650,13 +2076,14 @@ Choose what you want:
         if not state.get("project_title"):
 
             return (
-                "Please generate project idea first."
+                "Let's get started! Please provide a project title or type **idea** to pick one first. 💡"
             )
 
         if not state.get("features"):
 
             return (
-                "Please generate features first."
+                "Before generating the full project, I need to know what features it has. 📋\n\n"
+                "Type **generate features** to create them quickly!"
             )
 
         result = generate_full_project(
@@ -1675,12 +2102,18 @@ Choose what you want:
             result,
             mode="merge"
         )
+        if state.get("domain"):
+            state["category"] = state.get("domain")
+
+        state["waiting_for_project_idea_confirm"] = True
 
         response = f"""
-📦 Full Project Generated
+📦 Project Specification Ready!
 
-📌 Title:
-{state.get("project_title")}
+📌 Title: {state.get("project_title")}
+📂 Category: {state.get("category")}
+
+🛠 Technologies: {", ".join(state.get("technologies", []))}
 
 📄 Abstract:
 {state.get("abstract")}
@@ -1688,32 +2121,18 @@ Choose what you want:
 📄 Description:
 {state.get("description")}
 
-🛠 Technologies:
-{chr(10).join("- " + x for x in state.get("technologies", []))}
-
-🎯 Objectives:
-{chr(10).join("- " + x for x in state.get("objectives", []))}
-
-⚡ Methodology:
-{state.get("methodology")}
-
-🚀 Future Work:
-{chr(10).join("- " + x for x in state.get("future_work", []))}
-
-📂 Category:
-{state.get("category")}
-
-🏷 Keywords:
-{", ".join(state.get("keywords", []))}
-
 ❗ Problem Statement:
 {state.get("problem_statement")}
 
 💡 Proposed Solution:
 {state.get("proposed_solution")}
 
-🤖 AI Summary:
-{state.get("ai_summary")}
+🎯 Objectives:
+{chr(10).join("- " + x for x in state.get("objectives", []))}
+
+──────────────────────
+📍 Would you like to use this as your graduation project idea?
+Reply **yes** to validate & categorize it, or **no** to explore other ideas.
 """
 
         return finalize_response(
@@ -1755,20 +2174,7 @@ Choose what you want:
         ):
 
             return (
-                "⚠️ This seems unrelated to the current project.\n\n"
-                f"Current project:\n"
-                f"{state.get('project_title')}\n\n"
-                "Do you want to:\n"
-                "1️⃣ Start a new project\n"
-                "2️⃣ Continue discussing the current project"
-            )
-
-        system_prompt = build_chat_prompt(state)
-
-        formatted_history = "\n".join([
-            f"{m['role']}: {m['content']}"
-            for m in history[-6:]
-        ])
+        )
 
         full_prompt = f"""
 {system_prompt}
@@ -1803,12 +2209,12 @@ User:
     if not is_project_related(text):
 
         return (
-            "⚠️ This chatbot is specialized for graduation projects only.\n\n"
-            "Try things like:\n"
-            "- generate AI project ideas\n"
-            "- generate features for smart hospital system\n"
-            "- suggest technologies for fintech app\n"
-            "- improve my graduation project"
+            "I'm designed specifically for graduation projects 🎓\n\n"
+            "Here's what I can help with:\n"
+            "- Type **idea** → browse project ideas by domain\n"
+            "- Type your project title → get smart features\n"
+            "- Type **generate full project** → complete project specification\n\n"
+            "💡 Start by typing **idea** — it's quick and easy!"
         )
     
     

src/recommendation_engine/config.py

@@ -13,13 +13,11 @@ DEBUG_MODE = os.getenv("DEBUG_MODE", "true").lower() == "true"
 
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
 
-# Primary model — reads GEMINI_MODEL_NAME from .env first, then PRIMARY_MODEL,
-# then falls back to gemini-2.5-pro (smart: advanced reasoning, high quality output).
 MODEL_CANDIDATES = [
-    os.getenv("GEMINI_MODEL_NAME") or os.getenv("PRIMARY_MODEL", "gemini-2.5-pro"),
-    os.getenv("FAST_MODEL",     "gemini-2.5-flash"),   # fast fallback
-    os.getenv("BALANCED_MODEL", "gemini-2.5-flash"),   # same tier fallback
-    os.getenv("QUALITY_MODEL",  "gemini-3.1-flash-lite"), # lightweight last resort
+    os.getenv("PRIMARY_MODEL", "gemini-3.1-flash-lite-preview"),
+    os.getenv("FAST_MODEL", "gemini-2.5-flash-lite"),
+    os.getenv("BALANCED_MODEL", "gemini-2.5-flash"),
+    os.getenv("QUALITY_MODEL", "gemini-2.5-pro"),
 ]
 
 _seen = set()
@@ -50,7 +48,7 @@ DEFAULT_IDEA_COUNT = int(os.getenv("DEFAULT_IDEA_COUNT", 5))
 GENERATION_BATCH_SIZE = int(os.getenv("GENERATION_BATCH_SIZE", 10))
 
 IDEA_DUPLICATE_THRESHOLD = float(
-    os.getenv("IDEA_DUPLICATE_THRESHOLD", 0.15)
+    os.getenv("IDEA_DUPLICATE_THRESHOLD", 0.45)
 )
 
 FEATURE_DUPLICATE_THRESHOLD = float(

src/recommendation_engine/context_builder.py

@@ -142,6 +142,21 @@ def extract_domain(text: str) -> str:
         return "artificial intelligence"
 
     
+    # Map normalized domain names to their original keys
+    normalized_domains = {normalize(d): d for d in DOMAIN_KEYWORDS.keys()}
+    if text in normalized_domains:
+        return normalized_domains[text]
+
+    # Check close matches against normalized domain names
+    match_domain = get_close_matches(
+        text,
+        list(normalized_domains.keys()),
+        n=1,
+        cutoff=0.85
+    )
+    if match_domain:
+        return normalized_domains[match_domain[0]]
+
     if text in DOMAIN_KEYWORDS:
         return text
 
@@ -190,7 +205,11 @@ def extract_domain(text: str) -> str:
 
                 return domain
 
-    return "Others"
+    others_keywords = DOMAIN_KEYWORDS.get("Others", [])
+    if any(ow in text for ow in others_keywords):
+        return "Others"
+
+    return ""
 
 @lru_cache(maxsize=100)
 def cached_similarity(
@@ -368,7 +387,7 @@ def build_project_context(
             "common_features": [],
             "unique_features": user_features,
             "architecture_hints": build_architecture_hints(domains),
-            "originality_score": 1.0,
+            "originality_score": 99.0,
             "context_strength": 0.0
         }
 
@@ -387,13 +406,6 @@ def build_project_context(
         if f not in common_features
     ]
 
-    originality = float(
-        results.get(
-            "originality_score",
-            pd.Series([1])
-        ).mean()
-    )
-
     hybrid_scores = results.get(
         "hybrid_score",
         pd.Series([0])
@@ -412,17 +424,33 @@ def build_project_context(
         "common_features": common_features,
         "unique_features": unique_features,
         "architecture_hints": build_architecture_hints(domains),
-        "originality_score": round(originality, 4),
+        "originality_score": calibrate_originality(context_strength),
         "context_strength": round(context_strength, 4)
     }
 
+def calibrate_originality(similarity: float) -> float:
+    """
+    Piecewise linear calibration curve mapping database similarity to originality percentage.
+    - S <= 0.45: maps linearly to O in [85.0%, 99.0%]
+    - S > 0.45: maps linearly to O in [5.0%, 85.0%]
+    """
+    s = max(0.0, min(1.0, float(similarity)))
+    if s <= 0.45:
+        originality = 99.0 - (s / 0.45) * 14.0
+    else:
+        originality = 85.0 - ((s - 0.45) / 0.55) * 80.0
+    return round(originality, 2)
+
+
+
+
 def build_domain_context(
     domain: str
 ) -> Dict[str, Any]:
 
     extracted = extract_domain(domain)
 
-    if extracted and extracted != "Others":
+    if extracted and extracted.lower() != "others":
         domain_clean = extracted
     else:
         logger.info(

src/recommendation_engine/idea_generator.py

@@ -28,6 +28,7 @@ def is_duplicate_local(idea: str, existing: Set[str]) -> bool:
     return False
 
 def fallback_by_domain(domain: str) -> List[str]:
+    import random
 
     domain = (domain or "general").lower()
 
@@ -37,31 +38,91 @@ def fallback_by_domain(domain: str) -> List[str]:
             "Student performance prediction platform",
             "Gamified learning mobile application",
             "Automated grading system",
-            "Virtual classroom engagement analyzer"
+            "Virtual classroom engagement analyzer",
+            "AI-powered language tutor for kids",
+            "Adaptive curriculum recommendation engine",
+            "Dyslexia assistant mobile application"
         ],
         "healthcare": [
             "AI disease prediction system",
             "Smart patient monitoring system",
             "Medical diagnosis assistant",
             "IoT health tracking device",
-            "Hospital resource optimization system"
+            "Hospital resource optimization system",
+            "Wearable fall detection for elderly",
+            "Computer vision surgery tools tracker",
+            "Smart appointment booking and triage chat"
         ],
         "fintech": [
             "Fraud detection AI system",
             "Smart expense tracking app",
             "Blockchain payment system",
             "Credit risk prediction model",
-            "AI investment advisor"
+            "AI investment advisor",
+            "Automated personal budgeting assistant",
+            "Cryptocurrency portfolio analyzer",
+            "AI invoice processing portal"
+        ],
+        "general": [
+            "AI-powered agricultural crop disease detection mobile app",
+            "Blockchain-secured digital academic certificate verification portal",
+            "AR-based indoor navigation assistant for visually impaired students",
+            "Smart waste sorting bin using computer vision and mechanical sorting",
+            "Decentralized federated learning for collaborative medical image classification",
+            "Automated license plate recognition and parking management system",
+            "AI-driven smart library book recommendation portal",
+            "Smart home energy management and load prediction system",
+            "Real-time object detection for warehouse inventory tracking",
+            "Autonomous delivery robot path planning simulation"
         ]
     }
 
-    return fallback_map.get(domain, [
-        "AI recommendation system",
-        "Smart automation platform",
-        "Data analytics dashboard",
-        "Intelligent decision support system",
-        "Predictive analytics engine"
-    ])
+    ideas = fallback_map.get(domain) or fallback_map.get("general")
+    shuffled_ideas = list(ideas)
+    random.shuffle(shuffled_ideas)
+    return shuffled_ideas
+
+def dynamic_fallback_ideas(
+    domain: str,
+    count: int,
+    exclude_set: Set[str],
+    previous_ideas: List[str]
+) -> List[str]:
+    logger.info(f"Generating dynamic fallback ideas for domain={domain}")
+    prompt = f"""
+You are an advanced AI research and innovation consultant.
+The standard project generator has failed to find unique ideas for the selected domain because of strict originality rules.
+
+DOMAIN:
+{domain}
+
+EXISTING CONTEXT:
+Please suggest {count} highly creative, unique, yet practical graduation project ideas that do not exist in standard databases.
+Avoid any standard topics (like simple prediction dashboards, basic chatbots, or generic automation).
+Think of combining different domains to create implementable software/hardware systems (e.g., mobile health tracking + edge-inference, edge computing + precision agriculture, secure e-commerce + decentralized identity).
+Ensure the ideas are completely feasible, realistic, and implementable within 6–9 months by a team of undergraduate students. Do NOT suggest highly theoretical, PhD-level, or impossible/sci-fi research topics (no quantum computing algorithms, non-existent sensors, etc.).
+
+PREVIOUS IDEAS TO AVOID:
+{", ".join(exclude_set | set(previous_ideas))}
+
+FORMAT:
+- One idea per line
+- No numbering
+- No explanations
+- Keep them concise (4-12 words)
+"""
+    raw_text = generate_text(prompt, task="idea", temperature=0.95)
+    if not raw_text:
+        return []
+    generated = validate_generated_list(text=raw_text, top_k=count)
+    generated = clean_ideas(generated)
+    
+    valid_fallbacks = []
+    for idea in generated:
+        if not is_idea_novel(idea):
+            continue
+        valid_fallbacks.append(idea)
+    return valid_fallbacks
 
 def generate_ideas(
     domain: str,
@@ -172,7 +233,26 @@ def generate_ideas(
     
     if len(final_ideas) < top_k:
 
-        logger.warning("Using fallback ideas")
+        logger.warning("Using dynamic fallback ideas")
+        needed = top_k - len(final_ideas)
+        dynamic_fallback = dynamic_fallback_ideas(
+            domain=domain,
+            count=needed * 2,
+            exclude_set=final_set,
+            previous_ideas=previous_generated_ideas
+        )
+
+        for f in dynamic_fallback:
+            normalized = normalize_idea(f)
+            if normalized not in final_set:
+                final_ideas.append(f)
+                final_set.add(normalized)
+            if len(final_ideas) >= top_k:
+                break
+
+    if len(final_ideas) < top_k:
+
+        logger.warning("Using static fallback ideas")
 
         fallback = fallback_by_domain(domain)
 

src/recommendation_engine/llm_client.py

@@ -180,6 +180,11 @@ def generate_text(
 
                 provider_error = classify_provider_error(e)
                 if provider_error:
+                    if provider_error.status_code == 429 and attempt < MAX_RETRIES - 1:
+                        sleep_time = (RETRY_DELAY_SECONDS * 5) * (attempt + 1)
+                        logger.info(f"[LLM 429] Rate limited. Retrying in {sleep_time}s...")
+                        time.sleep(sleep_time)
+                        continue
                     raise provider_error
 
                 

src/recommendation_engine/memory_store.py

@@ -22,7 +22,22 @@ def default_state():
         "proposed_solution": "",
         "keywords": [],
         "ai_summary": "",
-        "category": ""
+        "category": "",
+        "domain": None,
+        "last_action": None,
+        "waiting_for_domain": False,
+        "waiting_for_niche_domain": False,
+        "waiting_for_full_project_domain": False,
+        "waiting_for_full_project_selection": False,
+        "waiting_for_feature_title": False,
+        "waiting_for_title_confirmation": False,
+        "waiting_for_project_action": False,
+        "suggested_domains": [],
+        "pending_title": None,
+        "weak_title_candidate": None,
+        "project_chat_mode": False,
+        "menu_mode": False,
+        "selected_option": None
     }
 
 def create_chat(user_id: str):
@@ -79,9 +94,6 @@ def merge_state(old: dict, new: dict):
 
     for key, value in new.items():
 
-        if value is None:
-            continue
-
         
         if key in ["project_title", "description"]:
             merged[key] = value

src/recommendation_engine/prompt_builder.py

@@ -126,32 +126,36 @@ def build_idea_prompt(
     previous_ideas = previous_ideas or []
 
     domain = context.get("domain", "general")
+    existing_titles = context.get("existing_titles", [])
 
     return f"""
 You are a senior AI innovation consultant.
 
 TASK:
-Generate {count} HIGHLY ORIGINAL (85%+ Novelty) and unique graduation project ideas.
-The ideas MUST NOT be variants of existing common student projects.
+Generate {count} HIGHLY ORIGINAL (85% to 99% Originality) and unique graduation project ideas.
+The ideas MUST NOT duplicate or be variants of existing database projects or typical student projects.
 
 DOMAIN:
 {domain}
 
-PREVIOUS IDEAS:
+EXISTING PROJECTS IN THE DATABASE (DO NOT REPEAT OR DUPLICATE THESE):
+{list_to_text(existing_titles, 15)}
+
+PREVIOUS IDEAS SUGGESTED IN THIS SESSION (DO NOT REPEAT THESE):
 {list_to_text(previous_ideas, 20)}
 
 IMPORTANT REQUIREMENTS:
-- Ideas must possess HIGH ORIGINALITY. Do not suggest anything that resembles typical final-year student projects.
-- Ideas must solve REAL problems using cutting-edge, novel approaches.
-- Avoid generic software projects or standard web/mobile applications.
-- Ideas must be practical and implementable.
-- Prefer deep AI integrations (LLMs, Computer Vision, specialized ML models), advanced automation, or intelligent systems.
+- Originality & Feasibility Balance: Ideas must possess HIGH ORIGINALITY, but must be highly feasible and implementable. They should be realistic software or software-hardware projects that undergraduate students can build within 6–9 months.
+- Avoid PhD-level, highly theoretical, or "impossible" sci-fi research topics (e.g. do NOT require quantum computing, non-existent sensors, or highly experimental brain-computer interfaces).
+- Ideas must solve REAL problems using cutting-edge, yet practical and available technologies (such as standard web/mobile frameworks, existing ML models, APIs, and affordable IoT hardware).
+- Avoid generic software projects or standard web/mobile applications that lack intelligence.
+- Prefer smart AI integrations (LLMs, Computer Vision, specialized ML models), advanced automation, or intelligent systems.
 - Each idea must represent a COMPLETELY DIFFERENT concept.
 
 STRICT RULES:
-- No repeated concepts or slight rewording.
+- No repeated concepts or slight rewording of existing projects.
 - Avoid overused ideas like: standard prediction models, generic recommendation engines, basic management dashboards, IoT plant watering, face recognition attendance, or smart traffic lights.
-- Push the boundaries of the selected domain to ensure maximum uniqueness.
+- Push the boundaries of the selected domain to ensure maximum uniqueness without losing feasibility.
 
 FORMAT RULES:
 - One idea per line
@@ -161,10 +165,11 @@ FORMAT RULES:
 - Prefer 4–12 words
 
 GOOD IDEA EXAMPLES:
-- Smart traffic congestion prediction using drone-swarm analytics
-- AI-powered emergency sign language translator with continuous learning
-- Blockchain-secured federated learning for medical image sharing
-- Adaptive AI-driven learning assistant for dyslexic students
+- AI-powered agricultural crop disease detection via mobile app and offline edge-inference
+- Blockchain-secured digital academic certificate issuance and verification portal
+- AR-based indoor navigation assistant for visually impaired university students
+- Smart waste sorting bin using computer vision and mechanical sorting
+- Decentralized federated learning for collaborative medical image classification
 
 BAD IDEA EXAMPLES:
 - AI management system

src/recommendation_engine/test.py

@@ -0,0 +1,25 @@
+
+from src.recommendation_engine.chatbot_engine import chatbot
+
+USER_ID = "test_user"
+
+
+
+def interactive():
+    print("\n===== INTERACTIVE MODE =====\n")
+
+    while True:
+        user_input = input("YOU: ")
+
+        if user_input.lower() in ["exit", "quit"]:
+            break
+
+        response = chatbot(USER_ID, user_input)
+
+        print("\nBOT:")
+        print(response)
+        print("\n----------------------\n")
+
+
+
+interactive()