Upload 7 files

.gitignore

@@ -0,0 +1,76 @@
+venv*/
+__pycache__/
+*.pyc
+.env
+# Keep uploads and model files in the repo per user request
+# (removed uploads/ and h5 ignores to include all files)
+*.sqlite3
+*.db
+.vscode/
+venv_old_*/
+*.log
+node_modules/
+*.DS_Store
+env/
+/.pytest_cache/
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+.venv
+
+# Flask
+instance/
+.webassets-cache
+
+# Uploads
+uploads/
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.webm
+*.mp3
+*.wav
+*.flac
+*.ogg
+*.m4a
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.bmp
+*.webp
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Models (if you add trained models)
+models/
+*.h5
+*.pkl
+*.pth
+*.pt
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+*.log
+
+

README.md

@@ -1,13 +1,203 @@
----
-title: Deepfake Detection
-emoji: 📈
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.9.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Detection System
+
+An intelligent AI-based detection system that identifies AI-generated media and fraudulent activity across multiple content types including videos, images, audio files, text content, and emails.
+
+## Features
+
+- **User Authentication**: Secure login and signup system with session management
+- **Video Deepfake Detection**: Analyze videos to detect deepfake manipulation using advanced frame analysis, temporal consistency checks, and frequency domain analysis
+- **Image AI Detection**: Detect AI-generated or synthesized images using Error Level Analysis (ELA), frequency domain analysis, and texture pattern detection
+- **Audio Voice Cloning Detection**: Identify voice cloning and AI-generated audio using signal processing
+- **Text AI Detection**: Verify if text content is AI-generated using natural language processing
+- **Email Phishing Detection**: Detect phishing attempts and fraudulent emails using pattern recognition and NLP
+- **Detection History**: Track all detection results with user-specific history
+- **Clear Results Display**: Visual indicators showing REAL or FAKE with authenticity scores
+
+## Technology Stack
+
+- **Backend**: Flask (Python) with SQLAlchemy for database
+- **Frontend**: HTML, CSS, JavaScript
+- **Database**: SQLite (can be upgraded to PostgreSQL/MySQL)
+- **Authentication**: Flask sessions with password hashing
+- **Machine Learning**: 
+  - OpenCV for image/video processing
+  - Librosa for audio analysis
+  - NumPy for numerical computations
+  - Custom detection modules for each content type
+
+## Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd clone
+   ```
+
+2. **Create a virtual environment** (recommended)
+   ```bash
+   python -m venv venv
+   
+   # On Windows
+   venv\Scripts\activate
+   
+   # On macOS/Linux
+   source venv/bin/activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+1. **Initialize the database** (first time only)
+   ```bash
+   python init_db.py
+   ```
+   This will create the database file (`ai_detection.db`) and all necessary tables.
+
+2. **Test database connection** (optional)
+   ```bash
+   python test_db.py
+   ```
+   This will verify that the database is working correctly.
+
+3. **Start the Flask server**
+   ```bash
+   python app.py
+   ```
+
+4. **Open your browser**
+   Navigate to `http://localhost:5000`
+
+5. **Create an account**
+   - Click "Sign Up" to create a new account
+   - Or login if you already have an account
+
+6. **Upload and analyze content**
+   - Select the appropriate tab (Video, Image, Audio, Text, or Email)
+   - Upload your file or paste content
+   - Click the analyze button
+   - View the results with clear REAL/FAKE indicators and authenticity scores
+   - Check your detection history in the History tab
+
+## Database
+
+The application uses SQLite database (`ai_detection.db`) which is automatically created when you run the application. The database stores:
+- User accounts (username, email, hashed passwords)
+- Detection history (all detection results for each user)
+
+If you encounter database connection issues:
+1. Make sure you have write permissions in the project directory
+2. Delete `ai_detection.db` and run `python init_db.py` to recreate it
+3. Check the console output for any error messages
+
+## API Endpoints
+
+### Video Detection
+- **POST** `/api/detect/video`
+- **Body**: multipart/form-data with `file` field
+- **Response**: JSON with detection results
+
+### Image Detection
+- **POST** `/api/detect/image`
+- **Body**: multipart/form-data with `file` field
+- **Response**: JSON with detection results
+
+### Audio Detection
+- **POST** `/api/detect/audio`
+- **Body**: multipart/form-data with `file` field
+- **Response**: JSON with detection results
+
+### Text Detection
+- **POST** `/api/detect/text`
+- **Body**: JSON with `text` field
+- **Response**: JSON with detection results
+
+### Email Detection
+- **POST** `/api/detect/email`
+- **Body**: JSON with `email` field
+- **Response**: JSON with detection results
+
+## Project Structure
+
+```
+.
+├── app.py                  # Main Flask application
+├── modules/                # Detection modules
+│   ├── __init__.py
+│   ├── video_detector.py   # Video deepfake detection
+│   ├── image_detector.py   # Image AI detection
+│   ├── audio_detector.py   # Audio voice cloning detection
+│   ├── text_detector.py    # Text AI generation detection
+│   └── email_detector.py   # Email phishing detection
+├── templates/              # HTML templates
+│   └── index.html
+├── static/                 # Static files
+│   ├── css/
+│   │   └── style.css
+│   └── js/
+│       └── main.js
+├── uploads/                # Temporary file storage (auto-created)
+├── requirements.txt        # Python dependencies
+└── README.md              # This file
+```
+
+## Model Implementation Notes
+
+The current implementation uses heuristic-based detection algorithms as placeholders. For production use, you should:
+
+1. **Train or acquire pre-trained models** for each detection type
+2. **Replace the placeholder detection methods** in each module with actual model inference
+3. **Fine-tune models** on your specific datasets
+4. **Integrate state-of-the-art models** such as:
+   - **Deepfake Detection**: FaceForensics++, DeepFake Detection Challenge models
+   - **Image AI Detection**: CLIP-based detectors, GAN detection models
+   - **Voice Cloning**: ASVspoof models, anti-spoofing systems
+   - **Text AI Detection**: RoBERTa/BERT-based classifiers, GPTZero-style detectors
+   - **Email Phishing**: NLP-based classifiers, rule-based systems
+
+## Development
+
+### Adding New Detection Methods
+
+1. Create a new detector class in `modules/`
+2. Implement the `detect()` method
+3. Add a corresponding API endpoint in `app.py`
+4. Update the frontend to include the new detection type
+
+### Customizing Detection Models
+
+Each detector module has a `_load_model()` method where you can integrate your trained models. The modules are designed to be easily extensible.
+
+## Limitations
+
+- Current implementation uses heuristic-based detection (placeholders)
+- File size limit: 500MB per upload
+- Processing time depends on file size and system resources
+- Models need to be trained/acquired for production use
+
+## Security Considerations
+
+- All uploaded files are automatically deleted after processing
+- File type validation is enforced
+- Maximum file size limits are set
+- Consider implementing rate limiting for production use
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+[Specify your license here]
+
+## Acknowledgments
+
+- OpenCV for image/video processing
+- Librosa for audio analysis
+- Flask for web framework
+- All contributors and the open-source community
+
+

app.py

@@ -0,0 +1,348 @@
+from flask import Flask, render_template, request, jsonify, session, redirect, url_for
+from flask_cors import CORS
+from flask_sqlalchemy import SQLAlchemy
+import os
+import uuid
+from datetime import datetime
+from werkzeug.utils import secure_filename
+from dotenv import load_dotenv
+
+# Import detectors
+from modules.video_detector import VideoDeepfakeDetector
+from modules.image_detector import ImageAIDetector
+from modules.audio_detector import AudioVoiceCloneDetector
+from modules.text_detector import TextAIGeneratorDetector
+from modules.plagiarism_checker import PlagiarismChecker
+
+# Import database and models
+from models import db, User, DetectionHistory
+
+load_dotenv()
+
+app = Flask(__name__)
+app.secret_key = os.getenv("SECRET_KEY", "super-secret-key-123")
+
+# Database Configuration - Default to SQLite but use MySQL if .env is populated
+def get_db_uri():
+    db_user = os.getenv("DB_USER")
+    db_pass = os.getenv("DB_PASSWORD")
+    db_host = os.getenv("DB_HOST", "localhost")
+    db_port = os.getenv("DB_PORT", "3306")
+    db_name = os.getenv("DB_NAME", "ai_detection_db")
+    
+    if db_user and db_pass:
+        return f"mysql+mysqlconnector://{db_user}:{db_pass}@{db_host}:{db_port}/{db_name}"
+    return 'sqlite:///ai_detection.db'
+
+app.config['SQLALCHEMY_DATABASE_URI'] = get_db_uri()
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+app.config['UPLOAD_FOLDER'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'uploads')
+app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500MB
+
+# Initialize Database
+db.init_app(app)
+
+with app.app_context():
+    db_uri = app.config['SQLALCHEMY_DATABASE_URI']
+    print(f"\n==========================================")
+    print(f"DATABASE CONNECTION: {db_uri}")
+    print(f"==========================================\n")
+
+# Enable CORS
+CORS(app)
+
+# Ensure folders exist
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Initialize Detectors (Lazy loading would be better but let's do it here for now)
+# We handle errors in case models fail to load
+try:
+    video_detector = VideoDeepfakeDetector()
+except Exception as e:
+    print(f"[ERROR] Failed to load video detector: {e}")
+    video_detector = None
+
+try:
+    image_detector = ImageAIDetector()
+except Exception as e:
+    print(f"[ERROR] Failed to load image detector: {e}")
+    image_detector = None
+
+try:
+    audio_detector = AudioVoiceCloneDetector()
+except Exception as e:
+    print(f"[ERROR] Failed to load audio detector: {e}")
+    audio_detector = None
+
+try:
+    text_detector = TextAIGeneratorDetector()
+except Exception as e:
+    print(f"[ERROR] Failed to load text detector: {e}")
+    text_detector = None
+
+try:
+    plagiarism_checker = PlagiarismChecker()
+except Exception as e:
+    print(f"[ERROR] Failed to load plagiarism checker: {e}")
+    plagiarism_checker = None
+
+
+# --- ROUTES ---
+
+@app.route('/')
+def index():
+    if 'user_id' not in session:
+        return redirect(url_for('login'))
+    return render_template('index.html')
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        if request.is_json:
+            data = request.json
+        else:
+            data = request.form
+            
+        username = data.get('username')
+        password = data.get('password')
+        
+        user = User.query.filter_by(username=username).first()
+        if not user:
+            # Also try email if username field was used for email
+            user = User.query.filter_by(email=username).first()
+
+        if user and user.check_password(password):
+            session['user_id'] = user.id
+            session['username'] = user.username
+            if request.is_json:
+                return jsonify({"success": True, "redirect": "/"})
+            return redirect(url_for('index'))
+        
+        if request.is_json:
+            return jsonify({"success": False, "error": "Invalid credentials"}), 401
+        return "Invalid username or password", 401
+    
+    return render_template('login.html')
+
+@app.route('/signup', methods=['GET', 'POST'])
+def signup():
+    if request.method == 'POST':
+        if request.is_json:
+            data = request.json
+        else:
+            data = request.form
+            
+        username = data.get('username')
+        email = data.get('email')
+        password = data.get('password')
+        
+        if User.query.filter_by(username=username).first():
+            if request.is_json: return jsonify({"success": False, "error": "Username exists"}), 400
+            return "Username already exists", 400
+        
+        if User.query.filter_by(email=email).first():
+            if request.is_json: return jsonify({"success": False, "error": "Email exists"}), 400
+            return "Email already exists", 400
+        
+        new_user = User(username=username, email=email)
+        new_user.set_password(password)
+        db.session.add(new_user)
+        db.session.commit()
+        
+        session['user_id'] = new_user.id
+        session['username'] = new_user.username
+        
+        if request.is_json:
+            return jsonify({"success": True, "redirect": "/"})
+        return redirect(url_for('index'))
+    
+    return render_template('signup.html')
+
+@app.route('/logout', methods=['POST'])
+def logout():
+    session.clear()
+    return jsonify({"success": True})
+
+@app.route('/api/user/profile')
+def user_profile():
+    if 'user_id' not in session:
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    user = db.session.get(User, session['user_id'])
+    if not user:
+        return jsonify({"error": "User not found"}), 404
+        
+    return jsonify(user.to_dict())
+
+@app.route('/api/user/history', methods=['GET'])
+def user_history():
+    if 'user_id' not in session:
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    history = DetectionHistory.query.filter_by(user_id=session['user_id']).order_by(DetectionHistory.created_at.desc()).all()
+    return jsonify([item.to_dict() for item in history])
+
+@app.route('/api/user/history', methods=['DELETE'])
+def clear_history():
+    if 'user_id' not in session:
+        return jsonify({"error": "Unauthorized"}), 401
+    
+    DetectionHistory.query.filter_by(user_id=session['user_id']).delete()
+    db.session.commit()
+    return jsonify({"success": True})
+
+# --- ANALYSIS ENDPOINTS ---
+
+def save_history(detection_type, result, filename=None):
+    if 'user_id' in session:
+        try:
+            # Handle different result keys from different modules
+            is_fake = result.get('is_fake') or result.get('is_ai_generated') or result.get('is_voice_cloned') or result.get('is_plagiarized', False)
+            auth_score = result.get('authenticity_score', 0.0)
+            conf = result.get('confidence', 0.0)
+            label = result.get('label', 'Unknown')
+            
+            history = DetectionHistory(
+                user_id=session['user_id'],
+                detection_type=detection_type,
+                model_used=result.get('model_name', result.get('source', 'Default')),
+                filename=filename,
+                is_fake=bool(is_fake),
+                authenticity_score=float(auth_score),
+                confidence=float(conf),
+                result_label=label,
+                full_result=str(result),
+                request_ip=request.remote_addr
+            )
+            db.session.add(history)
+            db.session.commit()
+            print(f"[OK] Saved detection history for user {session['user_id']}")
+        except Exception as e:
+            print(f"[ERROR] Failed to save history: {e}")
+            db.session.rollback()
+
+@app.route('/api/detect/video', methods=['POST'])
+def detect_video():
+    if 'user_id' not in session: return jsonify({"error": "Unauthorized"}), 401
+    if not video_detector: return jsonify({"error": "Video detector not loaded"}), 500
+    
+    if 'file' not in request.files:
+        return jsonify({"error": "No file uploaded"}), 400
+    
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({"error": "No file selected"}), 400
+    
+    filename = secure_filename(f"{uuid.uuid4()}_{file.filename}")
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+    file.save(filepath)
+    
+    try:
+        result = video_detector.detect(filepath)
+        save_history('video', result, file.filename)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        if os.path.exists(filepath):
+            os.remove(filepath)
+
+@app.route('/api/detect/image', methods=['POST'])
+def detect_image():
+    if 'user_id' not in session: return jsonify({"error": "Unauthorized"}), 401
+    if not image_detector: return jsonify({"error": "Image detector not loaded"}), 500
+    
+    file = request.files.get('file')
+    url = request.form.get('url')
+    
+    if not file and not url:
+        return jsonify({"error": "No image provided"}), 400
+    
+    filepath = None
+    if file:
+        filename = secure_filename(f"{uuid.uuid4()}_{file.filename}")
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+    else:
+        # Handling URL would require a downloader, let's just return error for now if not implemented
+        return jsonify({"error": "URL detection not implemented yet"}), 400
+    
+    try:
+        result = image_detector.detect(filepath)
+        save_history('image', result, file.filename if file else 'url')
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        if filepath and os.path.exists(filepath):
+            os.remove(filepath)
+
+@app.route('/api/detect/audio', methods=['POST'])
+def detect_audio():
+    if 'user_id' not in session: return jsonify({"error": "Unauthorized"}), 401
+    if not audio_detector: return jsonify({"error": "Audio detector not loaded"}), 500
+    
+    if 'file' not in request.files:
+        return jsonify({"error": "No file uploaded"}), 400
+    
+    file = request.files['file']
+    filename = secure_filename(f"{uuid.uuid4()}_{file.filename}")
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+    file.save(filepath)
+    
+    try:
+        result = audio_detector.detect(filepath)
+        save_history('audio', result, file.filename)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        if os.path.exists(filepath):
+            os.remove(filepath)
+
+@app.route('/api/detect/text', methods=['POST'])
+def detect_text():
+    if 'user_id' not in session: return jsonify({"error": "Unauthorized"}), 401
+    if not text_detector: return jsonify({"error": "Text detector not loaded"}), 500
+    
+    data = request.json
+    text = data.get('text', '')
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+    
+    try:
+        result = text_detector.detect(text)
+        save_history('text', result, 'text_snippet')
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/detect/plagiarism', methods=['POST'])
+def detect_plagiarism():
+    if 'user_id' not in session: return jsonify({"error": "Unauthorized"}), 401
+    if not plagiarism_checker: return jsonify({"error": "Plagiarism checker not loaded"}), 500
+    
+    source_file = request.files.get('source_file')
+    check_file = request.files.get('check_file')
+    
+    if not source_file or not check_file:
+        return jsonify({"error": "Two files are required for plagiarism check"}), 400
+    
+    source_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f"src_{uuid.uuid4()}_{source_file.filename}"))
+    check_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f"chk_{uuid.uuid4()}_{check_file.filename}"))
+    
+    source_file.save(source_path)
+    check_file.save(check_path)
+    
+    try:
+        result = plagiarism_checker.check_two_files(source_path, check_path)
+        save_history('plagiarism', result, f"{source_file.filename} vs {check_file.filename}")
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        if os.path.exists(source_path): os.remove(source_path)
+        if os.path.exists(check_path): os.remove(check_path)
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)

init_db.py

@@ -0,0 +1,34 @@
+"""
+Database initialization script
+Run this script to initialize the database
+"""
+from app import app, db
+from models import User, DetectionHistory
+
+def init_database():
+    """Initialize database and create all tables"""
+    with app.app_context():
+        try:
+            # Create all tables
+            db.create_all()
+            print("[OK] Database tables created successfully")
+            
+            # Check if tables exist
+            from sqlalchemy import inspect
+            inspector = inspect(db.engine)
+            tables = inspector.get_table_names()
+            print(f"[OK] Found {len(tables)} tables: {', '.join(tables)}")
+            
+            # Test database connection
+            user_count = User.query.count()
+            print(f"[OK] Database connection successful")
+            print(f"[OK] Current users in database: {user_count}")
+            
+        except Exception as e:
+            print(f"[ERROR] Error initializing database: {e}")
+            raise
+
+if __name__ == '__main__':
+    print("Initializing database...")
+    init_database()
+

models.py

@@ -0,0 +1,64 @@
+from flask_sqlalchemy import SQLAlchemy
+from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime
+
+db = SQLAlchemy()
+
+class User(db.Model):
+    __tablename__ = 'users'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False, index=True)
+    email = db.Column(db.String(120), unique=True, nullable=False, index=True)
+    password_hash = db.Column(db.String(255), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    # Relationship to detection history
+    detections = db.relationship('DetectionHistory', backref='user', lazy=True, cascade='all, delete-orphan')
+    
+    def set_password(self, password):
+        """Hash and set password"""
+        self.password_hash = generate_password_hash(password)
+    
+    def check_password(self, password):
+        """Check if provided password matches hash"""
+        return check_password_hash(self.password_hash, password)
+    
+    def to_dict(self):
+        """Convert user to dictionary"""
+        return {
+            'id': self.id,
+            'username': self.username,
+            'email': self.email,
+            'created_at': self.created_at.isoformat()
+        }
+
+class DetectionHistory(db.Model):
+    __tablename__ = 'detection_history'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    detection_type = db.Column(db.String(20), nullable=False)  # video, image, audio, text, plagiarism
+    model_used = db.Column(db.String(150))
+    filename = db.Column(db.String(255))
+    is_fake = db.Column(db.Boolean, nullable=False)
+    authenticity_score = db.Column(db.Float, nullable=False)
+    confidence = db.Column(db.Float)
+    result_label = db.Column(db.String(100))
+    full_result = db.Column(db.Text)
+    request_ip = db.Column(db.String(50))
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    def to_dict(self):
+        """Convert detection to dictionary"""
+        return {
+            'id': self.id,
+            'detection_type': self.detection_type,
+            'model_used': self.model_used,
+            'filename': self.filename,
+            'is_fake': self.is_fake,
+            'authenticity_score': self.authenticity_score,
+            'confidence': self.confidence,
+            'result_label': self.result_label,
+            'created_at': self.created_at.isoformat()
+        }

requirements.txt

@@ -0,0 +1,19 @@
+Flask==3.0.0
+flask-cors==4.0.0
+Flask-SQLAlchemy==3.1.1
+opencv-python==4.8.1.78
+numpy==1.24.3
+librosa==0.10.1
+Werkzeug==3.0.1
+scipy==1.11.4
+pypdf==3.17.1
+python-docx==1.1.0
+scikit-learn==1.3.2
+transformers
+torch
+torchvision
+Pillow
+python-dotenv
+mysql-connector-python
+facenet-pytorch
+tensorflow

schema.sql

@@ -0,0 +1,49 @@
+CREATE DATABASE IF NOT EXISTS ai_detection_db;
+USE ai_detection_db;
+
+-- =============================================
+-- AI DEEPFAKE DETECTION SYSTEM DATABASE (MySQL)
+-- =============================================
+
+-- USERS TABLE
+CREATE TABLE IF NOT EXISTS users (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    username VARCHAR(80) NOT NULL UNIQUE,
+    email VARCHAR(120) NOT NULL UNIQUE,
+    password_hash VARCHAR(255) NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- DETECTION HISTORY TABLE
+CREATE TABLE IF NOT EXISTS detection_history (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    user_id INT NOT NULL,
+
+    detection_type VARCHAR(20) NOT NULL,  
+    model_used VARCHAR(150),
+
+    filename VARCHAR(255),
+
+    is_fake BOOLEAN NOT NULL,
+    authenticity_score FLOAT NOT NULL,
+    confidence FLOAT,
+    result_label VARCHAR(100),
+
+    full_result LONGTEXT,
+    request_ip VARCHAR(50),
+
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT FK_UserDetection 
+        FOREIGN KEY (user_id) REFERENCES users(id) 
+        ON DELETE CASCADE
+);
+
+-- INDEXES
+CREATE INDEX IX_Users_Username ON users(username);
+CREATE INDEX IX_Users_Email ON users(email);
+CREATE INDEX IX_DetectionHistory_User ON detection_history(user_id);
+CREATE INDEX IX_DetectionHistory_Type ON detection_history(detection_type);
+CREATE INDEX IX_DetectionHistory_Date ON detection_history(created_at);
+
+-- SELECT * FROM users; -- Sample query for verification