correct pr for the added MongoDB support

README.md

@@ -20,7 +20,7 @@ A sophisticated system for detecting hallucinations in AI responses using a para
 - **Paraphrase Generation**: Automatically generates semantically equivalent variations of user queries
 - **Multi-Model Architecture**: Uses Mistral Large for responses and OpenAI's o3-mini as a judge
 - **Real-time Progress Tracking**: Visual feedback during the analysis process
-- **Persistent Feedback Storage**: User feedback and results are stored in a persistent SQLite database
+- **Permanent Cloud Storage**: User feedback and results are stored in MongoDB Atlas for persistent storage across restarts
 - **Interactive Web Interface**: Clean, responsive Gradio interface with example queries
 - **Detailed Analysis**: Provides confidence scores, reasoning, and specific conflicting facts
 - **Statistics Dashboard**: Real-time tracking of hallucination detection statistics
@@ -41,11 +41,23 @@ A sophisticated system for detecting hallucinations in AI responses using a para
 1. Create a new Space on Hugging Face
 2. Select "Gradio" as the SDK
 3. Add your repository
-4. Set the following secrets in your Space's settings:
+4. Set up a MongoDB Atlas database (see below)
+5. Set the following secrets in your Space's settings:
    - `HF_MISTRAL_API_KEY`
    - `HF_OPENAI_API_KEY`
+   - `MONGODB_URI`
 
-The application uses Hugging Face Spaces' persistent storage (`/data` directory) to maintain feedback data between restarts.
+### MongoDB Atlas Setup
+
+For permanent data storage that persists across HuggingFace Space restarts:
+
+1. Create a free [MongoDB Atlas account](https://www.mongodb.com/cloud/atlas/register)
+2. Create a new cluster (the free tier is sufficient)
+3. In the "Database Access" menu, create a database user with read/write permissions
+4. In the "Network Access" menu, add IP `0.0.0.0/0` to allow access from anywhere (required for HuggingFace Spaces)
+5. In the "Databases" section, click "Connect" and choose "Connect your application"
+6. Copy the connection string and replace `<password>` with your database user's password
+7. Set this as your `MONGODB_URI` secret in HuggingFace Spaces settings
 
 ## Usage
 
@@ -71,16 +83,19 @@ The application uses Hugging Face Spaces' persistent storage (`/data` directory)
    - Provides confidence scores and reasoning
 
 3. **Feedback Collection**:
-   - User feedback is stored in SQLite database
-   - Persistent storage ensures data survival
+   - User feedback is stored in MongoDB Atlas
+   - Cloud-based persistent storage ensures data survival
    - Statistics are updated in real-time
+   - Data can be exported for further analysis
 
 ## Data Persistence
 
-The application uses SQLite for data storage in Hugging Face Spaces' persistent `/data` directory. This ensures:
-- Feedback data survives Space restarts
-- Statistics are preserved long-term
-- No data loss during inactivity periods
+The application uses MongoDB Atlas for data storage, providing several benefits:
+- **Permanent Storage**: Data persists even when Hugging Face Spaces restart
+- **Scalability**: MongoDB scales as your data grows
+- **Cloud-based**: No reliance on Space-specific storage that can be lost
+- **Query Capabilities**: Powerful query functionality for data analysis
+- **Export Options**: Built-in methods to export data to CSV
 
 ## Contributing
 

app.py

@@ -14,7 +14,13 @@ import time
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 import threading
-import sqlite3
+import pymongo
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
 
 # Configure logging
 logging.basicConfig(
@@ -380,78 +386,44 @@ Your response should be a JSON with the following fields:
 class HallucinationDetectorApp:
     def __init__(self):
         self.pas2 = None
-        # Use the default HF Spaces persistent storage location
-        self.data_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
-        self.db_path = os.path.join(self.data_dir, "feedback.db")
         logger.info("Initializing HallucinationDetectorApp")
         self._initialize_database()
         self.progress_callback = None
     
     def _initialize_database(self):
-        """Initialize SQLite database for feedback storage in persistent directory"""
+        """Initialize MongoDB connection for persistent feedback storage"""
         try:
-            # Create data directory if it doesn't exist
-            os.makedirs(self.data_dir, exist_ok=True)
-            logger.info(f"Ensuring data directory exists at {self.data_dir}")
-            
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            # Create table if it doesn't exist
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS feedback (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    timestamp TEXT,
-                    original_query TEXT,
-                    original_response TEXT,
-                    paraphrased_queries TEXT,
-                    paraphrased_responses TEXT,
-                    hallucination_detected INTEGER,
-                    confidence_score REAL,
-                    conflicting_facts TEXT,
-                    reasoning TEXT,
-                    summary TEXT,
-                    user_feedback TEXT
-                )
-            ''')
+            # Get MongoDB connection string from environment variable
+            mongo_uri = os.environ.get("MONGODB_URI")
+            
+            if not mongo_uri:
+                logger.warning("MONGODB_URI not found in environment variables. Please set it in HuggingFace Spaces secrets.")
+                logger.warning("Using a placeholder URI for now - connection will fail until proper URI is provided.")
+                # Use a placeholder - this will fail but allows the app to initialize
+                mongo_uri = "mongodb+srv://username:[email protected]/?retryWrites=true&w=majority"
+            
+            # Connect to MongoDB
+            self.mongo_client = MongoClient(mongo_uri)
+            
+            # Access or create database
+            self.db = self.mongo_client["hallucination_detector"]
+            
+            # Access or create collection
+            self.feedback_collection = self.db["feedback"]
+            
+            # Create index on timestamp for faster querying
+            self.feedback_collection.create_index("timestamp")
+            
+            # Test connection
+            self.mongo_client.admin.command('ping')
+            logger.info("MongoDB connection successful")
             
-            conn.commit()
-            conn.close()
-            logger.info(f"Database initialized successfully at {self.db_path}")
         except Exception as e:
-            logger.error(f"Error initializing database: {str(e)}", exc_info=True)
-            # Fallback to temporary directory if /data is not accessible
-            temp_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "temp_data")
-            os.makedirs(temp_dir, exist_ok=True)
-            self.db_path = os.path.join(temp_dir, "feedback.db")
-            logger.warning(f"Using fallback database location: {self.db_path}")
-            
-            # Try creating database in fallback location
-            try:
-                conn = sqlite3.connect(self.db_path)
-                cursor = conn.cursor()
-                cursor.execute('''
-                    CREATE TABLE IF NOT EXISTS feedback (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        timestamp TEXT,
-                        original_query TEXT,
-                        original_response TEXT,
-                        paraphrased_queries TEXT,
-                        paraphrased_responses TEXT,
-                        hallucination_detected INTEGER,
-                        confidence_score REAL,
-                        conflicting_facts TEXT,
-                        reasoning TEXT,
-                        summary TEXT,
-                        user_feedback TEXT
-                    )
-                ''')
-                conn.commit()
-                conn.close()
-                logger.info(f"Database initialized in fallback location")
-            except Exception as fallback_error:
-                logger.error(f"Critical error: Could not initialize database in fallback location: {str(fallback_error)}", exc_info=True)
-                raise
+            logger.error(f"Error initializing MongoDB: {str(e)}", exc_info=True)
+            logger.warning("Proceeding without database connection. Data will not be saved persistently.")
+            self.mongo_client = None
+            self.db = None
+            self.feedback_collection = None
     
     def set_progress_callback(self, callback):
         """Set the progress callback function"""
@@ -503,80 +475,182 @@ class HallucinationDetectorApp:
             }
     
     def save_feedback(self, results, feedback):
-        """Save results and user feedback to SQLite database"""
+        """Save results and user feedback to MongoDB"""
         try:
             logger.info("Saving user feedback: %s", feedback)
             
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            # Prepare data
-            data = (
-                datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                results.get('original_query', ''),
-                results.get('original_response', ''),
-                str(results.get('paraphrased_queries', [])),
-                str(results.get('paraphrased_responses', [])),
-                1 if results.get('hallucination_detected', False) else 0,
-                results.get('confidence_score', 0.0),
-                str(results.get('conflicting_facts', [])),
-                results.get('reasoning', ''),
-                results.get('summary', ''),
-                feedback
-            )
-            
-            # Insert data
-            cursor.execute('''
-                INSERT INTO feedback (
-                    timestamp, original_query, original_response,
-                    paraphrased_queries, paraphrased_responses,
-                    hallucination_detected, confidence_score,
-                    conflicting_facts, reasoning, summary, user_feedback
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', data)
+            if self.feedback_collection is None:
+                logger.error("MongoDB connection not available. Cannot save feedback.")
+                return "Database connection not available. Feedback not saved."
+            
+            # Prepare document for MongoDB
+            document = {
+                "timestamp": datetime.now(),
+                "original_query": results.get('original_query', ''),
+                "original_response": results.get('original_response', ''),
+                "paraphrased_queries": results.get('paraphrased_queries', []),
+                "paraphrased_responses": results.get('paraphrased_responses', []),
+                "hallucination_detected": results.get('hallucination_detected', False),
+                "confidence_score": results.get('confidence_score', 0.0),
+                "conflicting_facts": results.get('conflicting_facts', []),
+                "reasoning": results.get('reasoning', ''),
+                "summary": results.get('summary', ''),
+                "user_feedback": feedback
+            }
             
-            conn.commit()
-            conn.close()
+            # Insert document into collection
+            self.feedback_collection.insert_one(document)
             
-            logger.info("Feedback saved successfully to database")
+            logger.info("Feedback saved successfully to MongoDB")
             return "Feedback saved successfully!"
         except Exception as e:
             logger.error("Error saving feedback: %s", str(e), exc_info=True)
             return f"Error saving feedback: {str(e)}"
             
     def get_feedback_stats(self):
-        """Get statistics about collected feedback"""
+        """Get statistics about collected feedback from MongoDB"""
         try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
+            if self.feedback_collection is None:
+                logger.error("MongoDB connection not available. Cannot get feedback stats.")
+                return None
             
             # Get total feedback count
-            cursor.execute("SELECT COUNT(*) FROM feedback")
-            total_count = cursor.fetchone()[0]
-            
-            # Get hallucination detection stats
-            cursor.execute("""
-                SELECT hallucination_detected, COUNT(*) 
-                FROM feedback 
-                GROUP BY hallucination_detected
-            """)
-            detection_stats = dict(cursor.fetchall())
+            total_count = self.feedback_collection.count_documents({})
+            
+            # Get hallucination detection stats using aggregation
+            hallucination_pipeline = [
+                {"$group": {
+                    "_id": "$hallucination_detected", 
+                    "count": {"$sum": 1}
+                }}
+            ]
+            detection_stats = {doc["_id"]: doc["count"] 
+                              for doc in self.feedback_collection.aggregate(hallucination_pipeline)}
             
             # Get average confidence score
-            cursor.execute("SELECT AVG(confidence_score) FROM feedback")
-            avg_confidence = cursor.fetchone()[0] or 0
-            
-            conn.close()
+            avg_pipeline = [
+                {"$group": {
+                    "_id": None,
+                    "average": {"$avg": "$confidence_score"}
+                }}
+            ]
+            avg_result = list(self.feedback_collection.aggregate(avg_pipeline))
+            avg_confidence = avg_result[0]["average"] if avg_result else 0
             
             return {
                 "total_feedback": total_count,
-                "hallucinations_detected": detection_stats.get(1, 0),
-                "no_hallucinations": detection_stats.get(0, 0),
+                "hallucinations_detected": detection_stats.get(True, 0),
+                "no_hallucinations": detection_stats.get(False, 0),
                 "average_confidence": round(avg_confidence, 2)
             }
         except Exception as e:
             logger.error("Error getting feedback stats: %s", str(e), exc_info=True)
             return None
+    
+    def export_data_to_csv(self, filepath=None):
+        """Export all feedback data to a CSV file for analysis"""
+        try:
+            if self.feedback_collection is None:
+                logger.error("MongoDB connection not available. Cannot export data.")
+                return "Database connection not available. Cannot export data."
+            
+            # Query all feedback data
+            cursor = self.feedback_collection.find({})
+            
+            # Convert cursor to list of dictionaries
+            records = list(cursor)
+            
+            # Convert MongoDB documents to pandas DataFrame
+            # Handle nested arrays and complex objects
+            for record in records:
+                # Convert ObjectId to string
+                record['_id'] = str(record['_id'])
+                
+                # Convert datetime objects to string
+                if 'timestamp' in record:
+                    record['timestamp'] = record['timestamp'].strftime("%Y-%m-%d %H:%M:%S")
+                
+                # Convert lists to strings for CSV storage
+                if 'paraphrased_queries' in record:
+                    record['paraphrased_queries'] = json.dumps(record['paraphrased_queries'])
+                if 'paraphrased_responses' in record:
+                    record['paraphrased_responses'] = json.dumps(record['paraphrased_responses'])
+                if 'conflicting_facts' in record:
+                    record['conflicting_facts'] = json.dumps(record['conflicting_facts'])
+            
+            # Create DataFrame
+            df = pd.DataFrame(records)
+            
+            # Define default filepath if not provided
+            if not filepath:
+                filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 
+                                       f"hallucination_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")
+            
+            # Export to CSV
+            df.to_csv(filepath, index=False)
+            logger.info(f"Data successfully exported to {filepath}")
+            
+            return filepath
+        except Exception as e:
+            logger.error(f"Error exporting data: {str(e)}", exc_info=True)
+            return f"Error exporting data: {str(e)}"
+    
+    def get_recent_queries(self, limit=10):
+        """Get most recent queries for display in the UI"""
+        try:
+            if self.feedback_collection is None:
+                logger.error("MongoDB connection not available. Cannot get recent queries.")
+                return []
+            
+            # Get most recent queries
+            cursor = self.feedback_collection.find(
+                {}, 
+                {"original_query": 1, "hallucination_detected": 1, "timestamp": 1}
+            ).sort("timestamp", pymongo.DESCENDING).limit(limit)
+            
+            # Convert to list of dictionaries
+            recent_queries = []
+            for doc in cursor:
+                recent_queries.append({
+                    "id": str(doc["_id"]),
+                    "query": doc["original_query"],
+                    "hallucination_detected": doc.get("hallucination_detected", False),
+                    "timestamp": doc["timestamp"].strftime("%Y-%m-%d %H:%M:%S") if isinstance(doc["timestamp"], datetime) else doc["timestamp"]
+                })
+            
+            return recent_queries
+        except Exception as e:
+            logger.error(f"Error getting recent queries: {str(e)}", exc_info=True)
+            return []
+    
+    def get_query_details(self, query_id):
+        """Get full details for a specific query by ID"""
+        try:
+            if self.feedback_collection is None:
+                logger.error("MongoDB connection not available. Cannot get query details.")
+                return None
+            
+            # Convert string ID to ObjectId
+            obj_id = ObjectId(query_id)
+            
+            # Find the query by ID
+            doc = self.feedback_collection.find_one({"_id": obj_id})
+            
+            if doc is None:
+                logger.warning(f"No query found with ID {query_id}")
+                return None
+            
+            # Convert ObjectId to string for JSON serialization
+            doc["_id"] = str(doc["_id"])
+            
+            # Convert timestamp to string
+            if "timestamp" in doc and isinstance(doc["timestamp"], datetime):
+                doc["timestamp"] = doc["timestamp"].strftime("%Y-%m-%d %H:%M:%S")
+            
+            return doc
+        except Exception as e:
+            logger.error(f"Error getting query details: {str(e)}", exc_info=True)
+            return None
 
 
 # Progress tracking for UI updates
@@ -1480,4 +1554,4 @@ if __name__ == "__main__":
     
 # Uncomment this line to run the test function instead of the main interface
 # if __name__ == "__main__":
-#     test_progress()
+#     test_progress()

requirements.txt

@@ -4,4 +4,6 @@ numpy
 mistralai
 openai
 pydantic
-python-dotenv
+python-dotenv
+pymongo
+dnspython