Update chatbot.py

chatbot.py

@@ -4,31 +4,45 @@ import random
 import time
 import logging
 from dotenv import load_dotenv
-from messages import krishna_blessings, ayush_teasing, keyword_groups
+from messages import krishna_blessings, ayush_teasing, keyword_groups, get_contextual_response, generate_follow_up, handle_vague_input
 from ayush_messages import ayush_surprises
 from sentence_transformers import SentenceTransformer, util
 import joblib
 import numpy as np
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
 # Load environment variables
 load_dotenv()
 HUGGINGFACE_API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
 if not HUGGINGFACE_API_TOKEN:
-    logger.error("HUGGINGFACE_API_TOKEN not found in environment variables.")
-    raise ValueError("HUGGINGFACE_API_TOKEN is required.")
+    logger.error("HUGGINGFACE_API_TOKEN not found in environment variables")
+    raise ValueError("HUGGINGFACE_API_TOKEN is required")
 
 # Lazy load sentence transformer model and embeddings
 semantic_model = None
-keyword_embeddings_cache = joblib.load('embeddings_cache.joblib')
+keyword_embeddings_cache = None
 
 def init_semantic_model():
-    global semantic_model
+    global semantic_model, keyword_embeddings_cache
     if semantic_model is None:
-        semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+        try:
+            semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+            keyword_embeddings_cache = joblib.load('embeddings_cache.joblib')
+            logger.debug("Successfully loaded semantic model and embeddings cache")
+        except Exception as e:
+            logger.error(f"Failed to load semantic model or embeddings: {str(e)}")
+            # Retry once
+            try:
+                semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+                keyword_embeddings_cache = joblib.load('embeddings_cache.joblib')
+                logger.debug("Retry successful")
+            except Exception as e:
+                logger.error(f"Retry failed: {str(e)}")
+                semantic_model = None
+                keyword_embeddings_cache = {}
 
 # AI model for fallback responses
 AI_MODELS = [
@@ -64,7 +78,7 @@ conversation_context = {
     "message_count": 0,
     "last_response": None,
     "last_yes_response": None,
-    "history": []  # Store up to 5 recent (input, response) pairs
+    "history": []  # Store up to 10 recent (input, response) pairs
 }
 
 def analyze_sentiment(user_input):
@@ -85,10 +99,17 @@ def analyze_sentiment(user_input):
             if isinstance(result, list) and result:
                 emotions = result[0]
                 top_emotion = max(emotions, key=lambda x: x["score"])["label"]
+                logger.debug(f"Sentiment detected: {top_emotion}")
                 return top_emotion
+        logger.warning("Sentiment analysis failed")
         return "neutral"
     except Exception as e:
         logger.error(f"Error in analyze_sentiment: {str(e)}")
+        # Local sentiment fallback
+        if any(word in user_input.lower() for word in ['sad', 'down', 'upset']):
+            return "sadness"
+        if any(word in user_input.lower() for word in ['happy', 'great', 'awesome']):
+            return "joy"
         return "neutral"
 
 def make_api_request(url, headers, payload, retries=2, delay=3):
@@ -103,37 +124,56 @@ def make_api_request(url, headers, payload, retries=2, delay=3):
                 time.sleep(delay)
                 continue
             else:
-                logger.error(f"API error: {response.text}")
+                logger.error(f"API error: {response.status_code} - {response.text}")
                 return None
         except Exception as e:
             logger.error(f"API request failed on attempt {attempt + 1}: {str(e)}")
             if attempt < retries - 1:
                 time.sleep(delay)
             continue
-    logger.error(f"API request failed after {retries} retries.")
+    logger.error(f"API request failed after {retries} retries")
     return None
 
 def get_keyword_match(user_input_lower):
-    """Find the best matching keyword group using semantic similarity."""
-    init_semantic_model()
-    user_embedding = semantic_model.encode(user_input_lower, convert_to_tensor=True)
-    best_score = -1
-    best_group = None
-
-    for group in keyword_embeddings_cache:
-        similarities = util.cos_sim(user_embedding, keyword_embeddings_cache[group])
-        max_similarity = similarities.max().item()
-        if max_similarity > best_score and max_similarity > 0.6:
-            best_score = max_similarity
-            best_group = group
-    logger.info(f"Best group: {best_group}, Similarity score: {best_score}")
-    return best_group
+    """Find the best matching keyword group using semantic similarity or substring fallback."""
+    # Try semantic matching
+    if semantic_model and keyword_embeddings_cache:
+        try:
+            user_embedding = semantic_model.encode(user_input_lower, convert_to_tensor=True)
+            best_score = -1
+            best_group = None
+
+            for group in keyword_embeddings_cache:
+                similarities = util.cos_sim(user_embedding, keyword_embeddings_cache[group])
+                max_similarity = similarities.max().item()
+                if max_similarity > best_score and max_similarity > 0.5:
+                    best_score = max_similarity
+                    best_group = group
+            if best_group:
+                logger.debug(f"Semantic match: {best_group}, score: {best_score}")
+                return best_group
+        except Exception as e:
+            logger.error(f"Semantic matching failed: {str(e)}")
+
+    # Fallback to substring matching
+    for group, keywords in keyword_groups.items():
+        if any(keyword in user_input_lower for keyword in keywords):
+            logger.debug(f"Substring match: {group}")
+            return group
+    logger.debug("No keyword match found")
+    return None
 
 def get_krishna_response(user_input):
-    """Generate a response from Little Krishna."""
+    """Generate a robust and relevant response from Little Krishna."""
     try:
         user_input_lower = user_input.lower().strip()
         logger.info(f"Processing user input: {user_input_lower}")
+        if not user_input_lower:
+            logger.warning("Empty input received")
+            return "Hare Manavi! Don’t be shy like a gopi—say something! What’s on your mind?"
+
+        # Initialize semantic model if needed
+        init_semantic_model()
 
         # Reset context
         if "start over" in user_input_lower or "reset" in user_input_lower:
@@ -142,17 +182,16 @@ def get_krishna_response(user_input):
 
         # Analyze sentiment
         sentiment = analyze_sentiment(user_input)
-        logger.info(f"Sentiment detected: {sentiment}")
         conversation_context["message_count"] += 1
 
         # Update history
-        if len(conversation_context["history"]) >= 5:
+        if len(conversation_context["history"]) >= 10:
             conversation_context["history"].pop(0)
         conversation_context["history"].append({"input": user_input_lower, "response": None})
 
         # Semantic keyword matching
         matched_group = get_keyword_match(user_input_lower)
-        use_model = random.random() < 0.3
+        use_model = random.random() < 0.1
         logger.info(f"Matched group: {matched_group}, Use model: {use_model}")
 
         # Follow-up based on history
@@ -173,45 +212,12 @@ def get_krishna_response(user_input):
                     return response
 
         # Handle predefined responses
-        follow_ups = {
-            "greeting": "What’s sparking your joy today?",
-            "joke": "Want another silly tale?",
-            "riddle": "Ready for another puzzle?",
-            "playful": "What fun shall we have next?",
-            "calm": "What’s soothing your heart today?",
-            "wisdom": "What wisdom are you seeking now?",
-            "nature": "Which part of Vrindavan calls to you?",
-            "encourage": "What’s your next brave step?",
-            "friend": "What’s a special moment you’d like to share?",
-            "chat": "What’s on your mind, Manavi?",
-            "birthday": "What’s your birthday wish?"
-        }
-
-        if matched_group and not use_model:
-            conversation_context["last_topic"] = matched_group
-            if matched_group == "birthday":
-                response = ayush_surprises.get("birthday", auto_generate_birthday_message(include_tease=True))
-            elif matched_group == "chat":
-                response = krishna_blessings["chat_with_you"]
-            elif matched_group in ayush_teasing and random.choice([True, False]):
-                response = random.choice(ayush_teasing[matched_group])
-            elif matched_group in krishna_blessings:
-                response = krishna_blessings[matched_group]
-            else:
-                response = krishna_blessings.get(matched_group, "Hare Manavi! Let’s explore Vrindavan’s magic!")
-            follow_up = follow_ups.get(matched_group, "What else is on your mind, Manavi?")
-            response = f"{response} {follow_up}"
-            conversation_context["history"][-1]["response"] = response
-            return response
-
-        # Sentiment-based fallback
-        if sentiment in ["sadness", "anger"] and not matched_group and not use_model:
-            response = f"Hare Manavi! I see a shadow on your heart—let’s dance by the Yamuna to bring back your smile! What’s on your mind?"
-            conversation_context["history"][-1]["response"] = response
-            return response
-        elif sentiment == "joy" and not matched_group and not use_model:
-            response = f"Hare Manavi! Your joy lights up Vrindavan—let’s celebrate with a flute melody! What’s making you so happy?"
-            conversation_context["history"][-1]["response"] = response
+        response = get_contextual_response(matched_group, sentiment, conversation_context["history"])
+        follow_up = generate_follow_up(matched_group) if matched_group else "What else is on your mind, Manavi?"
+        response = f"{response} {follow_up}"
+        conversation_context["last_topic"] = matched_group
+        conversation_context["history"][-1]["response"] = response
+        if not use_model:
             return response
 
         # Fallback to AI model
@@ -242,13 +248,13 @@ def get_krishna_response(user_input):
                 logger.error(f"Error with {model['name']}: {str(e)}")
                 continue
 
-        # Default fallback
-        response = "Hare Manavi! I’m lost in Vrindavan’s magic—let’s try a new tune! What’s on your mind?"
+        # Static fallback if API fails
+        response = handle_vague_input(conversation_context["history"])
         conversation_context["history"][-1]["response"] = response
         return response
 
     except Exception as e:
         logger.error(f"Unhandled exception in get_krishna_response: {str(e)}")
-        response = "Hare Manavi! Something went wrong—let’s try again! What’s up?"
+        response = "Hare Manavi! The Yamuna’s waves got choppy—let’s try again! What’s on your mind?"
         conversation_context["history"][-1]["response"] = response
         return response