Upload 12 files

RAG_SETUP_GUIDE.md

@@ -0,0 +1,267 @@
+# 🚀 Enhanced RAG System Setup Guide
+
+This guide will help you set up the Enhanced RAG (Retrieval-Augmented Generation) system for saving high-confidence news to Google Drive.
+
+## 📋 Overview
+
+The Enhanced RAG system automatically saves news with **95%+ confidence** from Gemini analysis to Google Drive, allowing you to:
+- View all high-confidence news entries
+- Use them for better RAG analysis
+- Track user input patterns
+- Build a comprehensive knowledge base
+
+## 🔧 Setup Steps
+
+### Step 1: Google Cloud Console Setup
+
+1. **Go to Google Cloud Console**
+   - Visit: https://console.cloud.google.com/
+
+2. **Create or Select Project**
+   - Create a new project or select existing one
+   - Note your project ID
+
+3. **Enable Google Drive API**
+   - Go to "APIs & Services" → "Library"
+   - Search for "Google Drive API"
+   - Click "Enable"
+
+4. **Create OAuth 2.0 Credentials**
+   - Go to "APIs & Services" → "Credentials"
+   - Click "Create Credentials" → "OAuth 2.0 Client IDs"
+   - Choose "Desktop application"
+   - Download the JSON file
+   - Rename it to `credentials.json`
+   - Place it in your project directory
+
+### Step 2: Local Setup
+
+1. **Run the Setup Script**
+   ```bash
+   python setup_google_drive_rag.py
+   ```
+
+2. **Follow the Authentication Process**
+   - A browser window will open
+   - Log in with your Google account
+   - Grant permissions for Google Drive access
+   - The script will save your credentials
+
+3. **Verify Setup**
+   - The script will test Google Drive access
+   - It will create the RAG folder and file
+   - You'll see confirmation messages
+
+### Step 3: Hugging Face Spaces Setup (Optional)
+
+If you want to use this on Hugging Face Spaces:
+
+1. **Add Secrets to Hugging Face**
+   - Go to your Space settings
+   - Add these secrets:
+     - `GOOGLE_CLIENT_ID`: Your OAuth client ID
+     - `GOOGLE_CLIENT_SECRET`: Your OAuth client secret
+     - `GOOGLE_REFRESH_TOKEN`: Get this from your local token.json
+
+2. **Get Refresh Token**
+   - Run the setup script locally first
+   - Check the `token.json` file
+   - Copy the `refresh_token` value
+
+## 📁 File Structure
+
+After setup, you'll have:
+
+```
+your-project/
+├── credentials.json          # Google OAuth credentials
+├── token.json               # Saved authentication token
+├── rag_news_manager.py      # Main RAG system
+├── setup_google_drive_rag.py # Setup script
+├── view_rag_news.py         # News viewer
+└── app.py                   # Your main app (updated)
+```
+
+## 🔍 Google Drive Structure
+
+The system creates:
+
+```
+Google Drive/
+└── Vietnamese_Fake_News_RAG/
+    └── high_confidence_news.json
+```
+
+## 📊 How It Works
+
+### Automatic Saving
+- When users input news, the system analyzes it
+- If Gemini confidence > 95%, it's automatically saved to Google Drive
+- Each entry includes:
+  - News text
+  - Prediction (REAL/FAKE)
+  - Confidence score
+  - Gemini analysis
+  - Search results
+  - Timestamp
+
+### Data Format
+```json
+{
+  "metadata": {
+    "created_at": "2024-01-01T00:00:00",
+    "description": "High-confidence Vietnamese fake news for RAG",
+    "threshold": 0.95,
+    "total_entries": 10,
+    "last_updated": "2024-01-01T12:00:00"
+  },
+  "news_entries": [
+    {
+      "id": 1,
+      "content_hash": "abc123...",
+      "news_text": "Argentina vô địch World Cup 2022...",
+      "prediction": "REAL",
+      "gemini_confidence": 0.98,
+      "gemini_analysis": "1. KẾT LUẬN: THẬT...",
+      "distilbert_confidence": 0.85,
+      "search_results": [...],
+      "created_at": "2024-01-01T10:00:00",
+      "source": "user_input",
+      "verified": true
+    }
+  ]
+}
+```
+
+## 🖥️ Viewing Saved News
+
+### Option 1: Command Line Viewer
+```bash
+python view_rag_news.py
+```
+
+Features:
+- View all saved news
+- Filter by prediction (REAL/FAKE)
+- Search through entries
+- View statistics
+- Open Google Drive directly
+
+### Option 2: Google Drive Web Interface
+- Go to your Google Drive
+- Find the "Vietnamese_Fake_News_RAG" folder
+- Open "high_confidence_news.json"
+- View the raw JSON data
+
+### Option 3: Direct Google Drive Links
+The system provides direct links:
+- Folder: `https://drive.google.com/drive/folders/{folder_id}`
+- File: `https://drive.google.com/file/d/{file_id}/view`
+
+## 🔧 Configuration
+
+### In app.py
+```python
+# Enhanced RAG System Configuration
+ENABLE_ENHANCED_RAG = True  # Enable/disable the system
+RAG_CONFIDENCE_THRESHOLD = 0.95  # 95% threshold for saving
+```
+
+### Thresholds
+- **95%**: Only very high-confidence predictions are saved
+- **90%**: More entries saved, but still high quality
+- **85%**: More entries, but some uncertainty
+
+## 📈 Statistics
+
+The system tracks:
+- Total entries saved
+- Real vs Fake news count
+- Average confidence score
+- Latest entry timestamp
+- Google Drive folder/file IDs
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+1. **"credentials.json not found"**
+   - Make sure you downloaded the OAuth credentials
+   - Rename the file to exactly `credentials.json`
+   - Place it in the project directory
+
+2. **"Authentication failed"**
+   - Check your internet connection
+   - Make sure Google Drive API is enabled
+   - Try running the setup script again
+
+3. **"Permission denied"**
+   - Make sure you granted all required permissions
+   - Check if your Google account has Drive access
+
+4. **"RAG system not available"**
+   - Check if all dependencies are installed
+   - Make sure `rag_news_manager.py` is in the same directory
+
+### Debug Mode
+Add this to see detailed logs:
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## 🔄 Integration with Existing System
+
+The Enhanced RAG system works alongside your existing knowledge base:
+- **Local Knowledge Base**: Still works as before
+- **Enhanced RAG**: Additional Google Drive storage
+- **Both systems**: Can be used together for comprehensive RAG
+
+## 📱 Usage Examples
+
+### View Recent News
+```bash
+python view_rag_news.py
+# Select option 2: View Recent News
+```
+
+### Search for Specific Topics
+```bash
+python view_rag_news.py
+# Select option 6: Search News
+# Enter: "COVID-19"
+```
+
+### Check Statistics
+```bash
+python view_rag_news.py
+# Select option 1: View Statistics
+```
+
+## 🎯 Benefits
+
+1. **Automatic Collection**: No manual intervention needed
+2. **High Quality**: Only 95%+ confidence entries saved
+3. **Easy Access**: View through multiple interfaces
+4. **Scalable**: Google Drive handles large datasets
+5. **Searchable**: Find specific news entries quickly
+6. **Analytics**: Track patterns and statistics
+
+## 🔐 Security
+
+- OAuth 2.0 authentication
+- Credentials stored securely
+- Only your Google account can access
+- No sensitive data exposed
+
+## 📞 Support
+
+If you encounter issues:
+1. Check the troubleshooting section
+2. Verify all setup steps completed
+3. Check Google Cloud Console for API quotas
+4. Ensure proper file permissions
+
+---
+
+**🎉 Congratulations!** You now have a comprehensive RAG system that automatically saves high-confidence news to Google Drive for analysis and viewing!

app.py

@@ -31,6 +31,10 @@ KNOWLEDGE_BASE_DB = "knowledge_base.db"
 CONFIDENCE_THRESHOLD = 0.95  # 95% Gemini confidence threshold for RAG knowledge base
 ENABLE_KNOWLEDGE_BASE_SEARCH = True  # Enable knowledge base search with training data
 
+# Enhanced RAG System Configuration
+ENABLE_ENHANCED_RAG = True  # Enable enhanced RAG system for Google Drive
+RAG_CONFIDENCE_THRESHOLD = 0.95  # 95% threshold for saving to RAG
+
 # Cloud Storage Configuration
 USE_CLOUD_STORAGE = True  # Set to True to use cloud storage instead of local DB
 CLOUD_STORAGE_TYPE = "google_drive"  # Options: "google_drive", "google_cloud", "local"
@@ -440,6 +444,23 @@ def get_knowledge_base_stats():
 # Initialize knowledge base on startup
 init_knowledge_base()
 
+# Initialize Enhanced RAG System
+if ENABLE_ENHANCED_RAG:
+    try:
+        from rag_news_manager import initialize_rag_system
+        print("🚀 Initializing Enhanced RAG System...")
+        if initialize_rag_system():
+            print("✅ Enhanced RAG System initialized successfully!")
+        else:
+            print("⚠️ Enhanced RAG System initialization failed - continuing without it")
+            ENABLE_ENHANCED_RAG = False
+    except ImportError as e:
+        print(f"⚠️ Enhanced RAG System not available: {e}")
+        ENABLE_ENHANCED_RAG = False
+    except Exception as e:
+        print(f"⚠️ Enhanced RAG System initialization error: {e}")
+        ENABLE_ENHANCED_RAG = False
+
 def populate_knowledge_base_from_training_data():
     """Populate knowledge base with existing training data"""
     try:
@@ -1366,6 +1387,31 @@ def analyze_news(news_text):
                 print("✅ Successfully added to knowledge base for future RAG retrieval!")
             else:
                 print("⚠️ Failed to add to knowledge base (duplicate or error)")
+        
+        # Step 8: Enhanced RAG System - Save to Google Drive if confidence is high enough
+        if ENABLE_ENHANCED_RAG and gemini_max_confidence > RAG_CONFIDENCE_THRESHOLD:
+            try:
+                from rag_news_manager import add_news_to_rag
+                
+                print(f"🚀 High confidence detected ({gemini_max_confidence:.1%}) - saving to Enhanced RAG system...")
+                final_prediction = "REAL" if gemini_real_confidence > gemini_fake_confidence else "FAKE"
+                
+                rag_success = add_news_to_rag(
+                    news_text=news_text,
+                    gemini_analysis=gemini_analysis,
+                    gemini_confidence=gemini_max_confidence,
+                    prediction=final_prediction,
+                    search_results=search_results,
+                    distilbert_confidence=distilbert_confidence
+                )
+                
+                if rag_success:
+                    print("✅ Successfully saved to Enhanced RAG system (Google Drive)!")
+                else:
+                    print("⚠️ Failed to save to Enhanced RAG system (duplicate or error)")
+                    
+            except Exception as e:
+                print(f"⚠️ Enhanced RAG system error: {e}")
     
         # Build the detailed report with better formatting
         # Use combined_confidence to determine the final classification (not just DistilBERT)

debug_rag_setup.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Debug RAG system setup
+"""
+
+def debug_rag_setup():
+    """Debug the RAG system setup step by step"""
+    print("🔧 Debugging RAG System Setup")
+    print("=" * 40)
+    
+    try:
+        # Step 1: Test imports
+        print("1. Testing imports...")
+        from rag_news_manager import RAGNewsManager
+        print("✅ RAGNewsManager imported successfully")
+        
+        # Step 2: Create manager instance
+        print("2. Creating RAG manager...")
+        manager = RAGNewsManager()
+        print("✅ RAG manager created")
+        
+        # Step 3: Test authentication
+        print("3. Testing authentication...")
+        if manager.authenticate():
+            print("✅ Authentication successful")
+        else:
+            print("❌ Authentication failed")
+            return False
+        
+        # Step 4: Test folder setup
+        print("4. Testing folder setup...")
+        if manager.setup_rag_folder():
+            print("✅ Folder setup successful")
+            print(f"   Folder ID: {manager.rag_folder_id}")
+        else:
+            print("❌ Folder setup failed")
+            return False
+        
+        # Step 5: Test file setup
+        print("5. Testing file setup...")
+        if manager.setup_rag_file():
+            print("✅ File setup successful")
+            print(f"   File ID: {manager.rag_file_id}")
+        else:
+            print("❌ File setup failed")
+            return False
+        
+        # Step 6: Test data loading
+        print("6. Testing data loading...")
+        data = manager.load_rag_data()
+        if data:
+            print("✅ Data loading successful")
+            print(f"   Total entries: {data.get('metadata', {}).get('total_entries', 0)}")
+        else:
+            print("❌ Data loading failed")
+            return False
+        
+        # Step 7: Test statistics
+        print("7. Testing statistics...")
+        stats = manager.get_rag_statistics()
+        if stats:
+            print("✅ Statistics successful")
+            print(f"   Total entries: {stats['total_entries']}")
+            print(f"   Folder ID: {stats.get('folder_id', 'None')}")
+            print(f"   File ID: {stats.get('file_id', 'None')}")
+        else:
+            print("❌ Statistics failed")
+            return False
+        
+        print("\n🎉 All tests passed! RAG system is working correctly.")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error during debugging: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    debug_rag_setup()

fix_oauth_setup.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Fix OAuth setup for Google Drive RAG system
+"""
+
+import os
+import json
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+# Configuration
+SCOPES = ['https://www.googleapis.com/auth/drive.file']
+CREDENTIALS_FILE = 'credentials.json'
+TOKEN_FILE = 'token.json'
+
+def fix_oauth_setup():
+    """Fix OAuth setup with proper redirect URIs"""
+    print("🔧 Fixing OAuth Setup for Google Drive RAG")
+    print("=" * 50)
+    
+    # Check if credentials file exists
+    if not os.path.exists(CREDENTIALS_FILE):
+        print(f"❌ {CREDENTIALS_FILE} not found!")
+        print("\n📋 Please follow these steps:")
+        print("1. Go to: https://console.cloud.google.com/")
+        print("2. APIs & Services → Credentials")
+        print("3. Create Credentials → OAuth 2.0 Client IDs")
+        print("4. Application type: Desktop application")
+        print("5. Download as 'credentials.json'")
+        return False
+    
+    # Delete old token file if it exists
+    if os.path.exists(TOKEN_FILE):
+        print(f"🗑️ Removing old token file: {TOKEN_FILE}")
+        os.remove(TOKEN_FILE)
+    
+    print(f"✅ Found {CREDENTIALS_FILE}")
+    
+    try:
+        # Load and validate credentials
+        with open(CREDENTIALS_FILE, 'r') as f:
+            creds_data = json.load(f)
+        
+        print("✅ Credentials file is valid")
+        print(f"   Client ID: {creds_data.get('client_id', 'N/A')[:20]}...")
+        
+        # Check if it's a desktop application
+        if creds_data.get('installed'):
+            print("✅ Desktop application credentials detected")
+        else:
+            print("⚠️ Warning: This doesn't look like desktop application credentials")
+            print("   Make sure you selected 'Desktop application' when creating credentials")
+        
+    except json.JSONDecodeError:
+        print("❌ Invalid JSON in credentials file")
+        return False
+    except Exception as e:
+        print(f"❌ Error reading credentials: {e}")
+        return False
+    
+    # Try authentication with different ports
+    ports_to_try = [8080, 8081, 8082, 0]  # 0 means let the system choose
+    
+    for port in ports_to_try:
+        try:
+            print(f"\n🔐 Trying authentication on port {port if port > 0 else 'auto'}...")
+            
+            # Create flow
+            flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_FILE, SCOPES)
+            
+            if port == 0:
+                # Let the system choose the port
+                creds = flow.run_local_server(port=0)
+            else:
+                # Try specific port
+                creds = flow.run_local_server(port=port)
+            
+            print("✅ Authentication successful!")
+            
+            # Save credentials
+            with open(TOKEN_FILE, 'w') as token:
+                token.write(creds.to_json())
+            print(f"✅ Credentials saved to {TOKEN_FILE}")
+            
+            # Test the credentials
+            print("\n🧪 Testing Google Drive access...")
+            from googleapiclient.discovery import build
+            service = build('drive', 'v3', credentials=creds)
+            
+            results = service.files().list(pageSize=1, fields="files(id, name)").execute()
+            files = results.get('files', [])
+            
+            print("✅ Google Drive access successful!")
+            print(f"   Found {len(files)} file(s) in your Drive")
+            
+            return True
+            
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "redirect_uri_mismatch" in error_msg:
+                print(f"❌ Port {port} failed: redirect_uri_mismatch")
+                if port < 8082:  # Don't show this message for the last attempt
+                    print("   Trying next port...")
+                continue
+            else:
+                print(f"❌ Port {port} failed: {e}")
+                if port < 8082:
+                    print("   Trying next port...")
+                continue
+    
+    print("\n❌ All authentication attempts failed!")
+    print("\n🔧 Manual Fix Required:")
+    print("1. Go to: https://console.cloud.google.com/")
+    print("2. APIs & Services → Credentials")
+    print("3. Edit your OAuth 2.0 Client ID")
+    print("4. Add these to 'Authorized redirect URIs':")
+    print("   - http://localhost:8080/")
+    print("   - http://localhost:8081/")
+    print("   - http://localhost:8082/")
+    print("   - http://127.0.0.1:8080/")
+    print("   - http://127.0.0.1:8081/")
+    print("   - http://127.0.0.1:8082/")
+    print("5. Save and try again")
+    
+    return False
+
+def main():
+    """Main function"""
+    print("🚀 OAuth Fix for Google Drive RAG System")
+    print("=" * 50)
+    
+    if fix_oauth_setup():
+        print("\n🎉 OAuth setup fixed successfully!")
+        print("✅ You can now run: python setup_google_drive_rag.py")
+    else:
+        print("\n❌ OAuth setup failed")
+        print("💡 Please follow the manual fix instructions above")
+
+if __name__ == "__main__":
+    main()

fix_verification_issue.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Fix Google verification issue for OAuth
+"""
+
+import os
+import json
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+# Configuration
+SCOPES = ['https://www.googleapis.com/auth/drive.file']
+CREDENTIALS_FILE = 'credentials.json'
+TOKEN_FILE = 'token.json'
+
+def fix_verification_issue():
+    """Fix Google verification issue"""
+    print("🔧 Fixing Google Verification Issue")
+    print("=" * 50)
+    
+    print("📋 The issue is that your app needs to be in 'Testing' mode")
+    print("   and you need to be added as a test user.")
+    print()
+    
+    print("🔧 Manual Fix Required:")
+    print("1. Go to: https://console.cloud.google.com/")
+    print("2. APIs & Services → OAuth consent screen")
+    print("3. Make sure 'Publishing status' is set to 'Testing'")
+    print("4. Scroll down to 'Test users' section")
+    print("5. Click 'Add Users'")
+    print("6. Add your email: [email protected]")
+    print("7. Save the changes")
+    print()
+    
+    print("🔄 Alternative: Change User Type to Internal")
+    print("   (If you have a Google Workspace account)")
+    print()
+    
+    # Check if credentials exist
+    if not os.path.exists(CREDENTIALS_FILE):
+        print(f"❌ {CREDENTIALS_FILE} not found!")
+        return False
+    
+    # Delete old token file
+    if os.path.exists(TOKEN_FILE):
+        print(f"🗑️ Removing old token file: {TOKEN_FILE}")
+        os.remove(TOKEN_FILE)
+    
+    print("✅ Ready to test after you add yourself as a test user")
+    print()
+    
+    # Ask user if they've completed the steps
+    response = input("Have you added yourself as a test user? (y/n): ").strip().lower()
+    
+    if response == 'y':
+        print("\n🧪 Testing authentication...")
+        
+        try:
+            # Try authentication
+            flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_FILE, SCOPES)
+            creds = flow.run_local_server(port=0)
+            
+            print("✅ Authentication successful!")
+            
+            # Save credentials
+            with open(TOKEN_FILE, 'w') as token:
+                token.write(creds.to_json())
+            print(f"✅ Credentials saved to {TOKEN_FILE}")
+            
+            # Test Google Drive access
+            print("\n🧪 Testing Google Drive access...")
+            from googleapiclient.discovery import build
+            service = build('drive', 'v3', credentials=creds)
+            
+            results = service.files().list(pageSize=1, fields="files(id, name)").execute()
+            files = results.get('files', [])
+            
+            print("✅ Google Drive access successful!")
+            print(f"   Found {len(files)} file(s) in your Drive")
+            
+            return True
+            
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "access_denied" in error_msg or "verification" in error_msg:
+                print("❌ Still getting verification error")
+                print("💡 Make sure you:")
+                print("   1. Added yourself as a test user")
+                print("   2. Set publishing status to 'Testing'")
+                print("   3. Saved all changes")
+                return False
+            else:
+                print(f"❌ Authentication failed: {e}")
+                return False
+    else:
+        print("💡 Please complete the steps above and run this script again")
+        return False
+
+def main():
+    """Main function"""
+    print("🚀 Google Verification Fix for RAG System")
+    print("=" * 50)
+    
+    if fix_verification_issue():
+        print("\n🎉 Verification issue fixed!")
+        print("✅ You can now run: python setup_google_drive_rag.py")
+    else:
+        print("\n❌ Please complete the manual steps above")
+
+if __name__ == "__main__":
+    main()

get_drive_links.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Quick script to get Google Drive links for your RAG files
+"""
+
+from rag_news_manager import initialize_rag_system, get_rag_stats
+
+def get_drive_links():
+    """Get direct Google Drive links"""
+    print("🔗 Getting Google Drive Links...")
+    
+    # Initialize RAG system
+    if not initialize_rag_system():
+        print("❌ Failed to initialize RAG system")
+        return
+    
+    # Get statistics (includes folder and file IDs)
+    stats = get_rag_stats()
+    
+    if not stats:
+        print("❌ Could not get RAG statistics")
+        return
+    
+    print(f"\n📊 RAG System Statistics:")
+    print(f"   Total entries: {stats['total_entries']}")
+    print(f"   Real news: {stats['real_count']}")
+    print(f"   Fake news: {stats['fake_count']}")
+    print(f"   Average confidence: {stats['avg_confidence']:.1%}")
+    
+    print(f"\n🔗 Google Drive Links:")
+    
+    if stats['folder_id']:
+        folder_url = f"https://drive.google.com/drive/folders/{stats['folder_id']}"
+        print(f"📁 RAG Folder: {folder_url}")
+        print(f"   (Click to open in browser)")
+    
+    if stats['file_id']:
+        file_url = f"https://drive.google.com/file/d/{stats['file_id']}/view"
+        print(f"📄 RAG File: {file_url}")
+        print(f"   (Click to view the JSON data)")
+    
+    print(f"\n💡 Tips:")
+    print(f"   - Use the folder link to browse all RAG files")
+    print(f"   - Use the file link to view the raw JSON data")
+    print(f"   - Run 'python view_rag_news.py' for a better interface")
+
+if __name__ == "__main__":
+    get_drive_links()

quick_check.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Quick check to see if you have any saved RAG news
+"""
+
+from rag_news_manager import initialize_rag_system, get_rag_stats
+
+def quick_check():
+    """Quick check for saved news"""
+    print("🔍 Quick RAG System Check")
+    print("=" * 30)
+    
+    # Initialize RAG system
+    if not initialize_rag_system():
+        print("❌ RAG system not initialized")
+        print("💡 Run: python setup_google_drive_rag.py")
+        return
+    
+    # Get statistics
+    stats = get_rag_stats()
+    
+    if not stats:
+        print("❌ Could not get statistics")
+        return
+    
+    print(f"📊 Current Status:")
+    print(f"   Total entries: {stats['total_entries']}")
+    
+    if stats['total_entries'] == 0:
+        print("📭 No news entries saved yet")
+        print("💡 Try analyzing some news with your app first!")
+        print("💡 News with 95%+ confidence will be automatically saved")
+    else:
+        print(f"✅ You have {stats['total_entries']} saved news entries!")
+        print(f"   Real news: {stats['real_count']}")
+        print(f"   Fake news: {stats['fake_count']}")
+        print(f"   Average confidence: {stats['avg_confidence']:.1%}")
+        
+        if stats['latest_entry']:
+            latest = stats['latest_entry']
+            print(f"\n📰 Latest entry:")
+            print(f"   {latest['news_text'][:80]}...")
+            print(f"   {latest['prediction']} ({latest['gemini_confidence']:.1%})")
+    
+    # Show Google Drive links
+    if stats['folder_id']:
+        folder_url = f"https://drive.google.com/drive/folders/{stats['folder_id']}"
+        print(f"\n🔗 Google Drive Folder: {folder_url}")
+    
+    if stats['file_id']:
+        file_url = f"https://drive.google.com/file/d/{stats['file_id']}/view"
+        print(f"🔗 Google Drive File: {file_url}")
+
+if __name__ == "__main__":
+    quick_check()

rag_news_manager.py

@@ -0,0 +1,432 @@
+#!/usr/bin/env python3
+"""
+Enhanced RAG News Manager for Google Drive
+Saves high-confidence news (95%+ from Gemini) to Google Drive for RAG purposes
+"""
+
+import json
+import os
+import hashlib
+from datetime import datetime
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseDownload, MediaIoBaseUpload
+import io
+
+# Configuration
+SCOPES = ['https://www.googleapis.com/auth/drive.file']
+RAG_FOLDER_NAME = "Vietnamese_Fake_News_RAG"
+RAG_FILE_NAME = "high_confidence_news.json"
+CONFIDENCE_THRESHOLD = 0.95  # 95% threshold
+
+class RAGNewsManager:
+    def __init__(self):
+        self.service = None
+        self.rag_folder_id = None
+        self.rag_file_id = None
+        self.credentials_file = 'credentials.json'
+        self.token_file = 'token.json'
+        
+    def authenticate(self):
+        """Authenticate with Google Drive API"""
+        try:
+            creds = None
+            
+            # Check if running on Hugging Face Spaces
+            is_hf_space = os.getenv('SPACE_ID') is not None
+            
+            if is_hf_space:
+                # For Hugging Face Spaces, use environment variables
+                client_id = os.getenv('GOOGLE_CLIENT_ID')
+                client_secret = os.getenv('GOOGLE_CLIENT_SECRET')
+                refresh_token = os.getenv('GOOGLE_REFRESH_TOKEN')
+                
+                if client_id and client_secret and refresh_token:
+                    creds = Credentials.from_authorized_user_info({
+                        'client_id': client_id,
+                        'client_secret': client_secret,
+                        'refresh_token': refresh_token,
+                        'token_uri': 'https://oauth2.googleapis.com/token'
+                    }, SCOPES)
+                else:
+                    print("⚠️ Google Drive credentials not found in Hugging Face secrets")
+                    return False
+            else:
+                # For local development, use files
+                if os.path.exists(self.token_file):
+                    creds = Credentials.from_authorized_user_file(self.token_file, SCOPES)
+                
+                # If no valid credentials, request authorization
+                if not creds or not creds.valid:
+                    if creds and creds.expired and creds.refresh_token:
+                        creds.refresh(Request())
+                    else:
+                        if os.path.exists(self.credentials_file):
+                            flow = InstalledAppFlow.from_client_secrets_file(
+                                self.credentials_file, SCOPES)
+                            creds = flow.run_local_server(port=0)
+                        else:
+                            print("⚠️ credentials.json not found for local development")
+                            return False
+                    
+                    # Save credentials for next run
+                    with open(self.token_file, 'w') as token:
+                        token.write(creds.to_json())
+            
+            self.service = build('drive', 'v3', credentials=creds)
+            print("✅ Google Drive authentication successful!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Google Drive authentication failed: {e}")
+            return False
+    
+    def setup_rag_folder(self):
+        """Create or find the RAG folder in Google Drive"""
+        try:
+            # Check if folder already exists
+            results = self.service.files().list(
+                q=f"name='{RAG_FOLDER_NAME}' and mimeType='application/vnd.google-apps.folder'",
+                fields="files(id, name)"
+            ).execute()
+            
+            folders = results.get('files', [])
+            
+            if folders:
+                self.rag_folder_id = folders[0]['id']
+                print(f"✅ Found existing RAG folder: {RAG_FOLDER_NAME}")
+            else:
+                # Create new folder
+                folder_metadata = {
+                    'name': RAG_FOLDER_NAME,
+                    'mimeType': 'application/vnd.google-apps.folder'
+                }
+                
+                folder = self.service.files().create(
+                    body=folder_metadata,
+                    fields='id'
+                ).execute()
+                
+                self.rag_folder_id = folder.get('id')
+                print(f"✅ Created new RAG folder: {RAG_FOLDER_NAME}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error setting up RAG folder: {e}")
+            return False
+    
+    def setup_rag_file(self):
+        """Create or find the RAG data file"""
+        try:
+            # Check if file already exists
+            results = self.service.files().list(
+                q=f"name='{RAG_FILE_NAME}' and parents in '{self.rag_folder_id}'",
+                fields="files(id, name)"
+            ).execute()
+            
+            files = results.get('files', [])
+            
+            if files:
+                self.rag_file_id = files[0]['id']
+                print(f"✅ Found existing RAG file: {RAG_FILE_NAME}")
+            else:
+                # Create new file with empty data
+                initial_data = {
+                    "metadata": {
+                        "created_at": datetime.now().isoformat(),
+                        "description": "High-confidence Vietnamese fake news for RAG",
+                        "threshold": CONFIDENCE_THRESHOLD,
+                        "total_entries": 0
+                    },
+                    "news_entries": []
+                }
+                
+                file_metadata = {
+                    'name': RAG_FILE_NAME,
+                    'parents': [self.rag_folder_id]
+                }
+                
+                media = MediaIoBaseUpload(
+                    io.BytesIO(json.dumps(initial_data, ensure_ascii=False, indent=2).encode('utf-8')),
+                    mimetype='application/json'
+                )
+                
+                file = self.service.files().create(
+                    body=file_metadata,
+                    media_body=media,
+                    fields='id'
+                ).execute()
+                
+                self.rag_file_id = file.get('id')
+                print(f"✅ Created new RAG file: {RAG_FILE_NAME}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error setting up RAG file: {e}")
+            return False
+    
+    def load_rag_data(self):
+        """Load existing RAG data from Google Drive"""
+        try:
+            if not self.rag_file_id:
+                return {"metadata": {"total_entries": 0}, "news_entries": []}
+            
+            request = self.service.files().get_media(fileId=self.rag_file_id)
+            file_content = io.BytesIO()
+            downloader = MediaIoBaseDownload(file_content, request)
+            
+            done = False
+            while done is False:
+                status, done = downloader.next_chunk()
+            
+            file_content.seek(0)
+            data = json.loads(file_content.read().decode('utf-8'))
+            
+            print(f"📚 Loaded {data.get('metadata', {}).get('total_entries', 0)} entries from RAG file")
+            return data
+            
+        except Exception as e:
+            print(f"❌ Error loading RAG data: {e}")
+            return {"metadata": {"total_entries": 0}, "news_entries": []}
+    
+    def save_rag_data(self, data):
+        """Save RAG data to Google Drive"""
+        try:
+            if not self.rag_file_id:
+                return False
+            
+            # Update metadata
+            data['metadata']['last_updated'] = datetime.now().isoformat()
+            data['metadata']['total_entries'] = len(data['news_entries'])
+            
+            # Convert to JSON
+            json_data = json.dumps(data, ensure_ascii=False, indent=2)
+            
+            media = MediaIoBaseUpload(
+                io.BytesIO(json_data.encode('utf-8')),
+                mimetype='application/json'
+            )
+            
+            # Update the file
+            self.service.files().update(
+                fileId=self.rag_file_id,
+                media_body=media
+            ).execute()
+            
+            print(f"✅ Saved {len(data['news_entries'])} entries to RAG file")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error saving RAG data: {e}")
+            return False
+    
+    def add_high_confidence_news(self, news_text, gemini_analysis, gemini_confidence, 
+                                prediction, search_results=None, distilbert_confidence=None):
+        """Add high-confidence news to RAG system"""
+        try:
+            # Check confidence threshold
+            if gemini_confidence < CONFIDENCE_THRESHOLD:
+                print(f"⚠️ Confidence {gemini_confidence:.1%} below threshold {CONFIDENCE_THRESHOLD:.1%}")
+                return False
+            
+            # Create content hash for deduplication
+            content_hash = hashlib.md5(news_text.encode('utf-8')).hexdigest()
+            
+            # Load existing data
+            data = self.load_rag_data()
+            
+            # Check if entry already exists
+            for entry in data['news_entries']:
+                if entry.get('content_hash') == content_hash:
+                    print(f"⚠️ News already exists in RAG (hash: {content_hash[:8]}...)")
+                    return False
+            
+            # Create new entry
+            new_entry = {
+                'id': len(data['news_entries']) + 1,
+                'content_hash': content_hash,
+                'news_text': news_text,
+                'prediction': prediction,
+                'gemini_confidence': gemini_confidence,
+                'gemini_analysis': gemini_analysis,
+                'distilbert_confidence': distilbert_confidence,
+                'search_results': search_results or [],
+                'created_at': datetime.now().isoformat(),
+                'source': 'user_input',
+                'verified': True  # High confidence means verified
+            }
+            
+            # Add to data
+            data['news_entries'].append(new_entry)
+            
+            # Save to Google Drive
+            success = self.save_rag_data(data)
+            
+            if success:
+                print(f"✅ Added high-confidence news to RAG:")
+                print(f"   📰 News: {news_text[:100]}...")
+                print(f"   🎯 Prediction: {prediction}")
+                print(f"   📊 Confidence: {gemini_confidence:.1%}")
+                print(f"   🔗 Hash: {content_hash[:8]}...")
+                return True
+            else:
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error adding news to RAG: {e}")
+            return False
+    
+    def search_rag_news(self, query_text, limit=5):
+        """Search RAG news for similar entries"""
+        try:
+            data = self.load_rag_data()
+            if not data['news_entries']:
+                return []
+            
+            results = []
+            query_lower = query_text.lower()
+            
+            for entry in data['news_entries']:
+                # Simple text similarity search
+                if (query_lower in entry.get('news_text', '').lower() or 
+                    query_lower in entry.get('gemini_analysis', '').lower()):
+                    
+                    results.append({
+                        'news_text': entry['news_text'],
+                        'prediction': entry['prediction'],
+                        'confidence': entry['gemini_confidence'],
+                        'analysis': entry['gemini_analysis'],
+                        'created_at': entry['created_at'],
+                        'id': entry['id']
+                    })
+            
+            # Sort by confidence and creation date
+            results.sort(key=lambda x: (x['confidence'], x['created_at']), reverse=True)
+            results = results[:limit]
+            
+            if results:
+                print(f"🔍 Found {len(results)} similar entries in RAG")
+            
+            return results
+            
+        except Exception as e:
+            print(f"❌ Error searching RAG news: {e}")
+            return []
+    
+    def get_rag_statistics(self):
+        """Get statistics about RAG data"""
+        try:
+            data = self.load_rag_data()
+            entries = data['news_entries']
+            
+            if not entries:
+                return {
+                    'total_entries': 0,
+                    'real_count': 0,
+                    'fake_count': 0,
+                    'avg_confidence': 0,
+                    'latest_entry': None,
+                    'folder_id': self.rag_folder_id,
+                    'file_id': self.rag_file_id
+                }
+            
+            real_count = sum(1 for entry in entries if entry['prediction'] == 'REAL')
+            fake_count = sum(1 for entry in entries if entry['prediction'] == 'FAKE')
+            avg_confidence = sum(entry['gemini_confidence'] for entry in entries) / len(entries)
+            
+            # Get latest entry
+            latest_entry = max(entries, key=lambda x: x['created_at']) if entries else None
+            
+            stats = {
+                'total_entries': len(entries),
+                'real_count': real_count,
+                'fake_count': fake_count,
+                'avg_confidence': avg_confidence,
+                'latest_entry': latest_entry,
+                'folder_id': self.rag_folder_id,
+                'file_id': self.rag_file_id
+            }
+            
+            return stats
+            
+        except Exception as e:
+            print(f"❌ Error getting RAG statistics: {e}")
+            return None
+    
+    def initialize(self):
+        """Initialize the RAG system"""
+        print("🚀 Initializing RAG News Manager...")
+        
+        if not self.authenticate():
+            return False
+        
+        if not self.setup_rag_folder():
+            return False
+        
+        if not self.setup_rag_file():
+            return False
+        
+        print("✅ RAG News Manager initialized successfully!")
+        return True
+
+# Global instance
+rag_manager = RAGNewsManager()
+
+def initialize_rag_system():
+    """Initialize the RAG system"""
+    return rag_manager.initialize()
+
+def add_news_to_rag(news_text, gemini_analysis, gemini_confidence, prediction, 
+                   search_results=None, distilbert_confidence=None):
+    """Add news to RAG system if confidence is high enough"""
+    return rag_manager.add_high_confidence_news(
+        news_text, gemini_analysis, gemini_confidence, prediction, 
+        search_results, distilbert_confidence
+    )
+
+def search_rag_for_context(query_text, limit=3):
+    """Search RAG for context to use in analysis"""
+    return rag_manager.search_rag_news(query_text, limit)
+
+def get_rag_stats():
+    """Get RAG system statistics"""
+    return rag_manager.get_rag_statistics()
+
+if __name__ == "__main__":
+    # Test the RAG system
+    print("Testing RAG News Manager...")
+    
+    if initialize_rag_system():
+        # Test adding a news entry
+        test_news = "Argentina vô địch World Cup 2022 là sự thật"
+        test_analysis = "1. KẾT LUẬN: THẬT\n2. ĐỘ TIN CẬY: THẬT: 98% / GIẢ: 2%"
+        test_confidence = 0.98
+        
+        success = add_news_to_rag(
+            news_text=test_news,
+            gemini_analysis=test_analysis,
+            gemini_confidence=test_confidence,
+            prediction="REAL"
+        )
+        
+        if success:
+            print("✅ Test news added successfully!")
+            
+            # Get statistics
+            stats = get_rag_stats()
+            if stats:
+                print(f"📊 RAG Statistics:")
+                print(f"   Total entries: {stats['total_entries']}")
+                print(f"   Real news: {stats['real_count']}")
+                print(f"   Fake news: {stats['fake_count']}")
+                print(f"   Average confidence: {stats['avg_confidence']:.1%}")
+                print(f"   Google Drive folder ID: {stats['folder_id']}")
+                print(f"   Google Drive file ID: {stats['file_id']}")
+        else:
+            print("❌ Failed to add test news")
+    else:
+        print("❌ Failed to initialize RAG system")

setup_google_drive_rag.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+Setup script for Google Drive RAG system
+This script helps you set up Google Drive authentication for the RAG news manager
+"""
+
+import os
+import json
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+# Configuration
+SCOPES = ['https://www.googleapis.com/auth/drive.file']
+CREDENTIALS_FILE = 'credentials.json'
+TOKEN_FILE = 'token.json'
+
+def setup_google_drive_credentials():
+    """Set up Google Drive credentials for local development"""
+    print("🔧 Setting up Google Drive credentials for RAG system...")
+    print("=" * 60)
+    
+    # Check if credentials file exists
+    if not os.path.exists(CREDENTIALS_FILE):
+        print(f"❌ {CREDENTIALS_FILE} not found!")
+        print("\n📋 To get Google Drive credentials:")
+        print("1. Go to Google Cloud Console: https://console.cloud.google.com/")
+        print("2. Create a new project or select existing one")
+        print("3. Enable Google Drive API")
+        print("4. Go to 'Credentials' → 'Create Credentials' → 'OAuth 2.0 Client IDs'")
+        print("5. Choose 'Desktop application'")
+        print("6. Download the JSON file and rename it to 'credentials.json'")
+        print("7. Place it in this directory")
+        return False
+    
+    print(f"✅ Found {CREDENTIALS_FILE}")
+    
+    # Load credentials
+    try:
+        with open(CREDENTIALS_FILE, 'r') as f:
+            creds_data = json.load(f)
+        
+        print("✅ Credentials file is valid JSON")
+        print(f"   Client ID: {creds_data.get('client_id', 'N/A')[:20]}...")
+        print(f"   Project ID: {creds_data.get('project_id', 'N/A')}")
+        
+    except json.JSONDecodeError:
+        print("❌ Invalid JSON in credentials file")
+        return False
+    except Exception as e:
+        print(f"❌ Error reading credentials: {e}")
+        return False
+    
+    # Authenticate
+    creds = None
+    
+    # Check if token file exists
+    if os.path.exists(TOKEN_FILE):
+        print(f"✅ Found existing {TOKEN_FILE}")
+        try:
+            creds = Credentials.from_authorized_user_file(TOKEN_FILE, SCOPES)
+            print("✅ Loaded existing credentials")
+        except Exception as e:
+            print(f"⚠️ Error loading existing credentials: {e}")
+            creds = None
+    
+    # If no valid credentials, get new ones
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            print("🔄 Refreshing expired credentials...")
+            try:
+                creds.refresh(Request())
+                print("✅ Credentials refreshed successfully")
+            except Exception as e:
+                print(f"❌ Error refreshing credentials: {e}")
+                creds = None
+        
+        if not creds:
+            print("🔐 Starting OAuth flow...")
+            print("   A browser window will open for authentication")
+            print("   Please log in with your Google account and grant permissions")
+            
+            try:
+                flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_FILE, SCOPES)
+                creds = flow.run_local_server(port=0)
+                print("✅ Authentication successful!")
+            except Exception as e:
+                print(f"❌ Authentication failed: {e}")
+                return False
+        
+        # Save credentials for next time
+        try:
+            with open(TOKEN_FILE, 'w') as token:
+                token.write(creds.to_json())
+            print(f"✅ Credentials saved to {TOKEN_FILE}")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not save credentials: {e}")
+    
+    # Test the credentials
+    print("\n🧪 Testing Google Drive access...")
+    try:
+        from googleapiclient.discovery import build
+        service = build('drive', 'v3', credentials=creds)
+        
+        # List files to test access
+        results = service.files().list(pageSize=1, fields="files(id, name)").execute()
+        files = results.get('files', [])
+        
+        print("✅ Google Drive access successful!")
+        print(f"   Found {len(files)} file(s) in your Drive")
+        
+        if files:
+            print(f"   Sample file: {files[0]['name']}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Google Drive access test failed: {e}")
+        return False
+
+def test_rag_system():
+    """Test the RAG system"""
+    print("\n🧪 Testing RAG News Manager...")
+    print("=" * 40)
+    
+    try:
+        from rag_news_manager import initialize_rag_system, get_rag_stats
+        
+        if initialize_rag_system():
+            print("✅ RAG system initialized successfully!")
+            
+            # Get statistics
+            stats = get_rag_stats()
+            if stats:
+                print(f"📊 Current RAG Statistics:")
+                print(f"   Total entries: {stats['total_entries']}")
+                print(f"   Real news: {stats['real_count']}")
+                print(f"   Fake news: {stats['fake_count']}")
+                print(f"   Average confidence: {stats['avg_confidence']:.1%}")
+                print(f"   Google Drive folder: {stats['folder_id']}")
+                print(f"   Google Drive file: {stats['file_id']}")
+                
+                # Provide Google Drive links
+                if stats['folder_id']:
+                    folder_url = f"https://drive.google.com/drive/folders/{stats['folder_id']}"
+                    print(f"\n🔗 Google Drive RAG Folder: {folder_url}")
+                
+                if stats['file_id']:
+                    file_url = f"https://drive.google.com/file/d/{stats['file_id']}/view"
+                    print(f"🔗 Google Drive RAG File: {file_url}")
+            else:
+                print("⚠️ Could not get RAG statistics")
+        else:
+            print("❌ RAG system initialization failed")
+            return False
+            
+    except ImportError as e:
+        print(f"❌ Could not import RAG system: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ RAG system test failed: {e}")
+        return False
+    
+    return True
+
+def main():
+    """Main setup function"""
+    print("🚀 Google Drive RAG System Setup")
+    print("=" * 50)
+    print("This script will help you set up Google Drive integration")
+    print("for saving high-confidence news for RAG purposes.")
+    print()
+    
+    # Step 1: Setup credentials
+    if not setup_google_drive_credentials():
+        print("\n❌ Setup failed at credentials step")
+        return False
+    
+    # Step 2: Test RAG system
+    if not test_rag_system():
+        print("\n❌ Setup failed at RAG system test")
+        return False
+    
+    print("\n🎉 Setup completed successfully!")
+    print("=" * 50)
+    print("✅ Google Drive credentials configured")
+    print("✅ RAG system initialized")
+    print("✅ Ready to save high-confidence news!")
+    print()
+    print("📋 Next steps:")
+    print("1. Your app will now automatically save news with 95%+ confidence")
+    print("2. Check your Google Drive for the 'Vietnamese_Fake_News_RAG' folder")
+    print("3. View saved news in the 'high_confidence_news.json' file")
+    print("4. The system will use this data for better RAG analysis")
+    
+    return True
+
+if __name__ == "__main__":
+    main()

view_rag_news.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+RAG News Viewer
+View and manage high-confidence news saved in Google Drive
+"""
+
+import json
+import os
+from datetime import datetime
+from rag_news_manager import initialize_rag_system, get_rag_stats, rag_manager
+
+def format_news_entry(entry, index):
+    """Format a news entry for display"""
+    created_date = datetime.fromisoformat(entry['created_at'].replace('Z', '+00:00'))
+    formatted_date = created_date.strftime("%Y-%m-%d %H:%M:%S")
+    
+    prediction_emoji = "✅" if entry['prediction'] == 'REAL' else "❌"
+    confidence_color = "🟢" if entry['gemini_confidence'] > 0.95 else "🟡"
+    
+    print(f"\n{'='*80}")
+    print(f"📰 ENTRY #{index} - {prediction_emoji} {entry['prediction']} {confidence_color}")
+    print(f"{'='*80}")
+    print(f"🆔 ID: {entry['id']}")
+    print(f"📅 Created: {formatted_date}")
+    print(f"📊 Confidence: {entry['gemini_confidence']:.1%}")
+    print(f"🔗 Hash: {entry['content_hash'][:12]}...")
+    print(f"📝 Source: {entry.get('source', 'Unknown')}")
+    print(f"✅ Verified: {entry.get('verified', False)}")
+    
+    if entry.get('distilbert_confidence'):
+        print(f"🤖 DistilBERT: {entry['distilbert_confidence']:.1%}")
+    
+    print(f"\n📰 NEWS TEXT:")
+    print(f"{'-'*40}")
+    print(entry['news_text'])
+    
+    print(f"\n🧠 GEMINI ANALYSIS:")
+    print(f"{'-'*40}")
+    print(entry['gemini_analysis'])
+    
+    if entry.get('search_results'):
+        print(f"\n🔍 SEARCH RESULTS ({len(entry['search_results'])} sources):")
+        print(f"{'-'*40}")
+        for i, result in enumerate(entry['search_results'][:3], 1):
+            print(f"{i}. {result.get('title', 'No title')}")
+            print(f"   {result.get('snippet', 'No snippet')[:100]}...")
+            print(f"   🔗 {result.get('link', 'No link')}")
+    
+    return True
+
+def view_all_news():
+    """View all saved news entries"""
+    print("📚 VIEWING ALL RAG NEWS ENTRIES")
+    print("=" * 60)
+    
+    try:
+        data = rag_manager.load_rag_data()
+        entries = data.get('news_entries', [])
+        
+        if not entries:
+            print("📭 No news entries found in RAG system")
+            return
+        
+        print(f"📊 Found {len(entries)} news entries")
+        print(f"📅 Last updated: {data.get('metadata', {}).get('last_updated', 'Unknown')}")
+        
+        # Sort by creation date (newest first)
+        entries.sort(key=lambda x: x['created_at'], reverse=True)
+        
+        for i, entry in enumerate(entries, 1):
+            format_news_entry(entry, i)
+            
+            if i < len(entries):
+                input("\n⏸️  Press Enter to view next entry (or Ctrl+C to exit)...")
+        
+        print(f"\n✅ Displayed all {len(entries)} entries")
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Viewing interrupted by user")
+    except Exception as e:
+        print(f"❌ Error viewing news: {e}")
+
+def view_recent_news(limit=5):
+    """View recent news entries"""
+    print(f"📰 VIEWING {limit} MOST RECENT NEWS ENTRIES")
+    print("=" * 50)
+    
+    try:
+        data = rag_manager.load_rag_data()
+        entries = data.get('news_entries', [])
+        
+        if not entries:
+            print("📭 No news entries found in RAG system")
+            return
+        
+        # Sort by creation date (newest first)
+        entries.sort(key=lambda x: x['created_at'], reverse=True)
+        recent_entries = entries[:limit]
+        
+        print(f"📊 Showing {len(recent_entries)} most recent entries")
+        
+        for i, entry in enumerate(recent_entries, 1):
+            format_news_entry(entry, i)
+            
+            if i < len(recent_entries):
+                input("\n⏸️  Press Enter to view next entry (or Ctrl+C to exit)...")
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Viewing interrupted by user")
+    except Exception as e:
+        print(f"❌ Error viewing recent news: {e}")
+
+def view_by_prediction(prediction):
+    """View news entries by prediction type"""
+    print(f"🔍 VIEWING {prediction} NEWS ENTRIES")
+    print("=" * 50)
+    
+    try:
+        data = rag_manager.load_rag_data()
+        entries = data.get('news_entries', [])
+        
+        # Filter by prediction
+        filtered_entries = [entry for entry in entries if entry['prediction'] == prediction]
+        
+        if not filtered_entries:
+            print(f"📭 No {prediction} news entries found")
+            return
+        
+        print(f"📊 Found {len(filtered_entries)} {prediction} entries")
+        
+        # Sort by confidence (highest first)
+        filtered_entries.sort(key=lambda x: x['gemini_confidence'], reverse=True)
+        
+        for i, entry in enumerate(filtered_entries, 1):
+            format_news_entry(entry, i)
+            
+            if i < len(filtered_entries):
+                input("\n⏸️  Press Enter to view next entry (or Ctrl+C to exit)...")
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Viewing interrupted by user")
+    except Exception as e:
+        print(f"❌ Error viewing {prediction} news: {e}")
+
+def search_news(query):
+    """Search news entries"""
+    print(f"🔍 SEARCHING FOR: '{query}'")
+    print("=" * 50)
+    
+    try:
+        results = rag_manager.search_rag_news(query, limit=10)
+        
+        if not results:
+            print("📭 No matching news entries found")
+            return
+        
+        print(f"📊 Found {len(results)} matching entries")
+        
+        for i, entry in enumerate(results, 1):
+            format_news_entry(entry, i)
+            
+            if i < len(results):
+                input("\n⏸️  Press Enter to view next entry (or Ctrl+C to exit)...")
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Search interrupted by user")
+    except Exception as e:
+        print(f"❌ Error searching news: {e}")
+
+def show_statistics():
+    """Show RAG system statistics"""
+    print("📊 RAG SYSTEM STATISTICS")
+    print("=" * 40)
+    
+    try:
+        stats = get_rag_stats()
+        
+        if not stats:
+            print("❌ Could not retrieve statistics")
+            return
+        
+        print(f"📈 Total Entries: {stats['total_entries']}")
+        print(f"✅ Real News: {stats['real_count']}")
+        print(f"❌ Fake News: {stats['fake_count']}")
+        print(f"📊 Average Confidence: {stats['avg_confidence']:.1%}")
+        
+        if stats['latest_entry']:
+            latest = stats['latest_entry']
+            latest_date = datetime.fromisoformat(latest['created_at'].replace('Z', '+00:00'))
+            print(f"🕒 Latest Entry: {latest_date.strftime('%Y-%m-%d %H:%M:%S')}")
+            print(f"   📰 {latest['news_text'][:80]}...")
+            print(f"   🎯 {latest['prediction']} ({latest['gemini_confidence']:.1%})")
+        
+        print(f"\n🔗 Google Drive Links:")
+        if stats['folder_id']:
+            folder_url = f"https://drive.google.com/drive/folders/{stats['folder_id']}"
+            print(f"   📁 RAG Folder: {folder_url}")
+        
+        if stats['file_id']:
+            file_url = f"https://drive.google.com/file/d/{stats['file_id']}/view"
+            print(f"   📄 RAG File: {file_url}")
+        
+    except Exception as e:
+        print(f"❌ Error getting statistics: {e}")
+
+def main_menu():
+    """Main menu for the viewer"""
+    while True:
+        print("\n" + "="*60)
+        print("🔍 RAG NEWS VIEWER - Vietnamese Fake News Detection")
+        print("="*60)
+        print("1. 📊 View Statistics")
+        print("2. 📰 View Recent News (5 entries)")
+        print("3. 📚 View All News")
+        print("4. ✅ View Real News Only")
+        print("5. ❌ View Fake News Only")
+        print("6. 🔍 Search News")
+        print("7. 🔗 Open Google Drive")
+        print("8. ❌ Exit")
+        print("="*60)
+        
+        try:
+            choice = input("👉 Select option (1-8): ").strip()
+            
+            if choice == '1':
+                show_statistics()
+            elif choice == '2':
+                view_recent_news(5)
+            elif choice == '3':
+                view_all_news()
+            elif choice == '4':
+                view_by_prediction('REAL')
+            elif choice == '5':
+                view_by_prediction('FAKE')
+            elif choice == '6':
+                query = input("🔍 Enter search query: ").strip()
+                if query:
+                    search_news(query)
+                else:
+                    print("❌ Please enter a search query")
+            elif choice == '7':
+                stats = get_rag_stats()
+                if stats and stats['folder_id']:
+                    folder_url = f"https://drive.google.com/drive/folders/{stats['folder_id']}"
+                    print(f"🔗 Opening Google Drive: {folder_url}")
+                    import webbrowser
+                    webbrowser.open(folder_url)
+                else:
+                    print("❌ Google Drive folder not found")
+            elif choice == '8':
+                print("👋 Goodbye!")
+                break
+            else:
+                print("❌ Invalid choice. Please select 1-8.")
+                
+        except KeyboardInterrupt:
+            print("\n\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+def main():
+    """Main function"""
+    print("🚀 RAG News Viewer")
+    print("=" * 30)
+    
+    # Initialize RAG system
+    print("🔧 Initializing RAG system...")
+    if not initialize_rag_system():
+        print("❌ Failed to initialize RAG system")
+        print("Please run setup_google_drive_rag.py first")
+        return
+    
+    print("✅ RAG system initialized successfully!")
+    
+    # Show initial statistics
+    show_statistics()
+    
+    # Start main menu
+    main_menu()
+
+if __name__ == "__main__":
+    main()