changes in the logic

app.py

@@ -1,16 +1,16 @@
 import streamlit as st
+import pandas as pd
 from db import insert_data_if_empty, get_mongo_client
 from chatbot import chatbot_response
 
-# Ensure the historical data is inserted into MongoDB if not already present.
+# Insert the dataset into MongoDB if not already present.
 insert_data_if_empty()
 
-# (Optional) Connect to MongoDB for further visualization if needed.
+# Connect to MongoDB (useful for potential visualizations)
 collection = get_mongo_client()
 
-st.subheader("💬 Chatbot with Analysis for Specific MongoDB Entries")
-st.write("Ask me something (e.g., 'Provide analysis for the data entry 1 in the dataset'): ")
-user_prompt = st.text_area("Your Query:")
+st.subheader("💬 Chatbot: Analyze MongoDB Entries")
+user_prompt = st.text_area("Ask me something (e.g., 'Provide analysis for the data entry 1 in the dataset'):")
 
 if st.button("Get AI Response"):
     ai_response, sentiment_label, sentiment_confidence, topic_label, topic_confidence = chatbot_response(user_prompt)
@@ -22,4 +22,4 @@ if st.button("Get AI Response"):
         st.write("### Category Extraction:")
         st.write(f"**Detected Category:** {topic_label} ({topic_confidence:.2f} confidence)")
     else:
-        st.warning("⚠️ Please enter a valid query for analysis.")
+        st.warning("⚠️ Please enter a question or text for analysis.")

chatbot.py

@@ -3,7 +3,7 @@ import re
 import streamlit as st
 import google.generativeai as genai
 from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
-from db import get_entry_by_index  # Helper to fetch a document by index
+from db import get_entry_by_index
 
 # Configure Gemini API key
 GEMINI_API_KEY = os.getenv("gemini_api")
@@ -33,94 +33,57 @@ TOPIC_LABELS = [
     "Health", "Science", "Education", "Finance", "Travel", "Food"
 ]
 
-# Function to analyze sentiment using the pre-trained model
 def analyze_sentiment(text):
     try:
-        sentiment_result = sentiment_pipeline(text)[0]
-        label = sentiment_result['label']
-        score = sentiment_result['score']
-        sentiment_mapping = {
-            "LABEL_0": "Negative",
-            "LABEL_1": "Neutral",
-            "LABEL_2": "Positive"
-        }
-        return sentiment_mapping.get(label, "Unknown"), score
+        result = sentiment_pipeline(text)[0]
+        label = result['label']
+        score = result['score']
+        mapping = {"LABEL_0": "Negative", "LABEL_1": "Neutral", "LABEL_2": "Positive"}
+        return mapping.get(label, "Unknown"), score
     except Exception as e:
         return f"Error analyzing sentiment: {e}", None
 
-# Function to extract topic using zero-shot classification
 def extract_topic(text):
     try:
-        topic_result = topic_pipeline(text, TOPIC_LABELS)
-        top_topic = topic_result["labels"][0]
-        confidence = topic_result["scores"][0]
+        result = topic_pipeline(text, TOPIC_LABELS)
+        top_topic = result["labels"][0]
+        confidence = result["scores"][0]
         return top_topic, confidence
     except Exception as e:
         return f"Error extracting topic: {e}", None
 
-# Helper to detect if the user asks for a specific entry.
-# Searches for patterns like "data entry 1" or "entry 2" (case-insensitive).
-def get_entry_index(prompt):
-    match = re.search(r'(?:data entry|entry)\s*(\d+)', prompt.lower())
+# Detect queries like "data entry 1" or "entry 3" (case-insensitive)
+def is_entry_query(prompt):
+    pattern = r"(?:data entry|entry)\s*(\d+)"
+    match = re.search(pattern, prompt, re.IGNORECASE)
     if match:
-        # Convert to 0-indexed value.
-        return int(match.group(1)) - 1
-    return None
+        # Convert to index (assuming user numbering starts at 1)
+        index = int(match.group(1)) - 1
+        return True, index
+    return False, None
 
-# Helper to filter the generative response.
-# We expect the response to contain:
-#   "Let's break down this tweet-like MongoDB entry:" followed by text,
-#   then "Conclusion:" followed by text.
-# We remove any extra parts and remove the header "Conclusion:".
-def filter_ai_response(ai_text):
-    breakdown_marker = "Let's break down this tweet-like MongoDB entry:"
-    conclusion_marker = "Conclusion:"
-    if breakdown_marker in ai_text and conclusion_marker in ai_text:
-        # Split into two parts.
-        parts = ai_text.split(breakdown_marker, 1)[1]
-        breakdown_part, conclusion_part = parts.split(conclusion_marker, 1)
-        # Rebuild output with the breakdown section and the conclusion content (without the header)
-        filtered = breakdown_marker + "\n" + breakdown_part.strip() + "\n" + conclusion_part.strip()
-        return filtered
-    else:
-        # If the markers aren't found, return the original text.
-        return ai_text
-
-# Main function to generate AI response along with sentiment and category analysis.
-# If the prompt asks for a specific entry, fetch its "text" from MongoDB and build a custom prompt.
 def chatbot_response(user_prompt):
     if not user_prompt:
         return None, None, None, None, None
-
     try:
-        entry_index = get_entry_index(user_prompt)
-        if entry_index is not None:
-            entry = get_entry_by_index(entry_index)
+        entry_query, index = is_entry_query(user_prompt)
+        if entry_query:
+            entry = get_entry_by_index(index)
             if entry is None:
                 return "❌ No entry found for the requested index.", None, None, None, None
             entry_text = entry.get("text", "No text available.")
-            # Build a prompt instructing the Gemini model to provide analysis in a structured format.
-            combined_prompt = (
-                f"Provide analysis for the following MongoDB entry:\n\n"
-                f"{entry_text}\n\n"
-                "Please respond in the following format:\n"
-                "Let's break down this tweet-like MongoDB entry:\n[Your detailed analysis here]\n"
-                "Conclusion:\n[Your conclusion here]"
-            )
-            # Run sentiment and topic analysis on the entry's text.
+            # Fixed AI response for entry queries (as per instructions)
+            ai_response_text = "Let's break down this tweet-like MongoDB entry:"
+            # Analyze the entry's text
             sentiment_label, sentiment_confidence = analyze_sentiment(entry_text)
             topic_label, topic_confidence = extract_topic(entry_text)
+            return ai_response_text, sentiment_label, sentiment_confidence, topic_label, topic_confidence
         else:
-            # If not an entry query, use the user prompt directly.
-            combined_prompt = user_prompt
+            # For non-entry queries, fallback to the generative model as usual.
+            model_gen = genai.GenerativeModel("gemini-1.5-pro")
+            ai_response = model_gen.generate_content(user_prompt)
             sentiment_label, sentiment_confidence = analyze_sentiment(user_prompt)
             topic_label, topic_confidence = extract_topic(user_prompt)
-
-        # Generate AI response using Gemini.
-        model_gen = genai.GenerativeModel("gemini-1.5-pro")
-        ai_response = model_gen.generate_content(combined_prompt)
-        # Filter the generative response to show only the required sections.
-        filtered_response = filter_ai_response(ai_response.text)
-        return filtered_response, sentiment_label, sentiment_confidence, topic_label, topic_confidence
+            return ai_response.text, sentiment_label, sentiment_confidence, topic_label, topic_confidence
     except Exception as e:
         return f"❌ Error: {e}", None, None, None, None

db.py

@@ -3,13 +3,11 @@ import requests
 import io
 from pymongo import MongoClient
 
-# Function to connect to MongoDB.
 def get_mongo_client():
     client = MongoClient("mongodb+srv://groupA:[email protected]/?retryWrites=true&w=majority&appName=SentimentCluster")
     db = client["sentiment_db"]
     return db["tweets"]
 
-# Function to insert data if the collection is empty.
 def insert_data_if_empty():
     collection = get_mongo_client()
     if collection.count_documents({}) == 0:
@@ -24,10 +22,8 @@ def insert_data_if_empty():
         except Exception as e:
             print(f"❌ Error loading dataset: {e}")
 
-# Function to fetch a specific entry (by index) from the dataset.
 def get_entry_by_index(index=0):
     collection = get_mongo_client()
-    # Skip 'index' documents and return one document.
     doc_cursor = collection.find({}, {"_id": 0}).skip(index).limit(1)
     docs = list(doc_cursor)
     if docs: