uploaded the all the dependencies

Backend/Dockerfile

@@ -0,0 +1,52 @@
+# Dockerfile for Hugging Face Spaces deployment
+# HF Spaces requires the app to listen on port 7860
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libgl1 \
+    libglib2.0-0 \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY pyproject.toml ./
+RUN pip install --upgrade pip \
+    && pip install --no-cache-dir \
+        fastapi \
+        "uvicorn[standard]" \
+        torch \
+        transformers \
+        pillow \
+        requests \
+        pydantic \
+        "python-multipart" \
+        "google-genai" \
+        python-dotenv \
+        newsapi-python \
+        beautifulsoup4 \
+        serpapi \
+        motor \
+        pymongo \
+        "python-jose[cryptography]" \
+        "passlib[bcrypt]" \
+        email-validator \
+        mistralai \
+        slowapi
+
+COPY app/ ./app/
+COPY enhanced_bert_liar_model/ ./enhanced_bert_liar_model/
+COPY enhanced_bert_welfake_model/ ./enhanced_bert_welfake_model/
+COPY run_api.py ./
+
+RUN mkdir -p logs
+
+# HF Spaces requires port 7860
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run on port 7860 for HF Spaces
+CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Backend/app/__init__.py

@@ -0,0 +1 @@
+# FastAPI application package

Backend/app/api/__init__.py

@@ -0,0 +1 @@
+# API package

Backend/app/api/auth_routes.py

@@ -0,0 +1,221 @@
+from fastapi import APIRouter, HTTPException, status, Depends, Request
+from datetime import datetime, timedelta
+from bson import ObjectId
+from app.database import get_users_collection, get_predictions_collection
+from app.schemas.auth import UserCreate, UserLogin, UserResponse, Token
+from app.auth import (
+    get_password_hash, 
+    verify_password, 
+    create_access_token, 
+    get_current_user,
+    ACCESS_TOKEN_EXPIRE_MINUTES
+)
+from app.limiter import limiter
+from app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/auth", tags=["authentication"])
+
+
+@router.post("/register", response_model=Token, status_code=status.HTTP_201_CREATED)
+@limiter.limit("3/minute")
+async def register(request: Request, user_data: UserCreate):
+    """
+    Register a new user account.
+    
+    - **email**: Valid email address (must be unique)
+    - **username**: Username (3-50 characters, must be unique)
+    - **password**: Password (min 6 characters)
+    - **full_name**: Optional full name
+    """
+    users_collection = get_users_collection()
+    
+    # Check if email already exists
+    existing_user = await users_collection.find_one({"email": user_data.email})
+    if existing_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered"
+        )
+    
+    # Check if username already exists
+    existing_username = await users_collection.find_one({"username": user_data.username})
+    if existing_username:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Username already taken"
+        )
+    
+    # Create new user
+    new_user = {
+        "email": user_data.email,
+        "username": user_data.username,
+        "full_name": user_data.full_name,
+        "hashed_password": get_password_hash(user_data.password),
+        "is_active": True,
+        "created_at": datetime.utcnow(),
+        "updated_at": datetime.utcnow()
+    }
+    
+    result = await users_collection.insert_one(new_user)
+    user_id = str(result.inserted_id)
+    logger.info("[register] New user: id=%s | username=%s | email=%s", user_id, user_data.username, user_data.email)
+    
+    # Create access token
+    access_token = create_access_token(
+        data={"sub": user_id, "email": user_data.email},
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    
+    return Token(
+        access_token=access_token,
+        token_type="bearer",
+        user=UserResponse(
+            id=user_id,
+            email=new_user["email"],
+            username=new_user["username"],
+            full_name=new_user["full_name"],
+            created_at=new_user["created_at"],
+            is_active=new_user["is_active"]
+        )
+    )
+
+
+@router.post("/login", response_model=Token)
+@limiter.limit("5/minute")
+async def login(request: Request, credentials: UserLogin):
+    """
+    Login with email and password to get access token.
+    
+    - **email**: Registered email address
+    - **password**: Account password
+    """
+    users_collection = get_users_collection()
+    
+    # Find user by email
+    user = await users_collection.find_one({"email": credentials.email})
+    
+    if not user:
+        logger.warning("[login] FAILED (unknown email) | email=%s", credentials.email)
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Verify password
+    if not verify_password(credentials.password, user["hashed_password"]):
+        logger.warning("[login] FAILED (wrong password) | email=%s", credentials.email)
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Check if user is active
+    if not user.get("is_active", True):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Account is disabled"
+        )
+    
+    # Create access token
+    user_id = str(user["_id"])
+    logger.info("[login] SUCCESS | id=%s | username=%s | email=%s", user_id, user["username"], user["email"])
+    access_token = create_access_token(
+        data={"sub": user_id, "email": user["email"]},
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    
+    return Token(
+        access_token=access_token,
+        token_type="bearer",
+        user=UserResponse(
+            id=user_id,
+            email=user["email"],
+            username=user["username"],
+            full_name=user.get("full_name"),
+            created_at=user["created_at"],
+            is_active=user.get("is_active", True)
+        )
+    )
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user_info(current_user: dict = Depends(get_current_user)):
+    """
+    Get current authenticated user's information.
+    Requires valid JWT token in Authorization header.
+    """
+    return UserResponse(
+        id=str(current_user["_id"]),
+        email=current_user["email"],
+        username=current_user["username"],
+        full_name=current_user.get("full_name"),
+        created_at=current_user["created_at"],
+        is_active=current_user.get("is_active", True)
+    )
+
+
+@router.get("/history")
+async def get_prediction_history(
+    limit: int = 20,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Get user's prediction history.
+    Returns the last N predictions made by the user.
+    """
+    predictions_collection = get_predictions_collection()
+    user_id = str(current_user["_id"])
+    
+    cursor = predictions_collection.find(
+        {"user_id": user_id}
+    ).sort("created_at", -1).limit(limit)
+    
+    predictions = []
+    async for prediction in cursor:
+        prediction["_id"] = str(prediction["_id"])
+        predictions.append(prediction)
+    
+    return {"predictions": predictions, "count": len(predictions)}
+
+
+@router.get("/stats")
+async def get_user_stats(current_user: dict = Depends(get_current_user)):
+    """
+    Get user's prediction statistics.
+    Returns total checks, real count, and fake count.
+    """
+    predictions_collection = get_predictions_collection()
+    user_id = str(current_user["_id"])
+    
+    # Count total predictions
+    total_checks = await predictions_collection.count_documents({"user_id": user_id})
+    
+    # Count real predictions
+    real_count = await predictions_collection.count_documents({
+        "user_id": user_id,
+        "is_fake": False
+    })
+    
+    # Count fake predictions
+    fake_count = await predictions_collection.count_documents({
+        "user_id": user_id,
+        "is_fake": True
+    })
+    
+    return {
+        "total_checks": total_checks,
+        "real_count": real_count,
+        "fake_count": fake_count
+    }
+
+
+@router.post("/logout")
+async def logout(current_user: dict = Depends(get_current_user)):
+    """
+    Logout current user (client should discard the token).
+    """
+    logger.info("[logout] user=%s | username=%s", str(current_user["_id"]), current_user.get("username"))
+    return {"message": "Successfully logged out"}

Backend/app/api/routes.py

@@ -0,0 +1,372 @@
+from fastapi import APIRouter, HTTPException, Depends, Request
+from datetime import datetime
+from app.schemas.prediction import PredictionRequest, PredictionResponse, ImagePredictionRequest, ImageExtractionResponse
+from app.models.bert_model import get_model, predict_fake_news
+from app.utils.ai_verification import ai_checker
+from app.utils.news_validator import news_validator
+from app.utils.image_ocr import image_ocr
+from app.auth import get_current_user
+from app.database import get_predictions_collection
+from app.limiter import limiter
+from app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter()
+
+@router.post("/predict", response_model=PredictionResponse)
+@limiter.limit("30/minute")
+async def predict(
+    request: Request,
+    body: PredictionRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Predict whether a news article is fake or real.
+    Flow: NewsAPI (real-world evidence) → Gemini AI (primary) → BERT (fallback only)
+    Requires authentication.
+
+    Args:
+        request: PredictionRequest containing the news title and optional text
+
+    Returns:
+        PredictionResponse with prediction label, confidence, and probabilities
+    """
+    try:
+        user_id = str(current_user["_id"])
+        logger.info("[predict] user=%s | title='%.80s'", user_id, body.title)
+
+        # ── STEP 1: NewsAPI / Google News search (real-world evidence) ────────
+        news_validation = news_validator.validate_claim(body.title)
+        logger.info(
+            "[predict] news_validation status=%s relevant=%d",
+            news_validation.get("verification_status", "n/a") if news_validation else "n/a",
+            news_validation.get("relevant_articles", 0) if news_validation else 0,
+        )
+
+        # ── STEP 2: Gemini AI — PRIMARY predictor (with news context) ─────────
+        # Pass the fetched articles so Gemini reads actual content, not just headlines
+        news_articles = news_validation.get("articles", []) if news_validation else []
+        ai_result = ai_checker.predict_with_context(body.title, news_articles=news_articles)
+
+        if ai_result:
+            # Gemini succeeded → use it as the primary result
+            final_result = {
+                "text": body.title,
+                "prediction": ai_result["prediction"],
+                "confidence": ai_result["confidence"],
+                "probabilities": ai_result["probabilities"],
+                "is_fake": ai_result["is_fake"],
+                "prediction_source": "gemini_ai",
+                "classification_type": "binary",
+                "reasoning": ai_result.get("reasoning", "No reasoning available."),
+                "context_articles_used": ai_result.get("context_articles_used", 0),
+            }
+            logger.info(
+                "[predict] Gemini primary answer=%s conf=%.2f context_articles=%d",
+                ai_result["prediction"].upper(),
+                ai_result["confidence"],
+                ai_result.get("context_articles_used", 0),
+            )
+
+        else:
+            # ── STEP 3: BERT — FALLBACK (only when Gemini is unavailable) ────
+            logger.info("[predict] Gemini unavailable — falling back to BERT")
+
+            if body.text:
+                formatted_input = f"{body.title} [SEP] {body.text}"
+            else:
+                formatted_input = f"{body.title} [SEP] {body.title}"
+
+            model, tokenizer, checkpoint = get_model()
+            bert_result = predict_fake_news(formatted_input, model, tokenizer, checkpoint)
+            bert_result["text"] = body.title
+
+            final_result = {
+                **bert_result,
+                "is_fake": bert_result["prediction"] == "fake",
+                "prediction_source": "bert_model_fallback",
+                "reasoning": f"BERT model classified this as {bert_result['prediction']} with {bert_result['confidence']*100:.1f}% confidence based on linguistic pattern analysis.",
+            }
+            logger.info(
+                "[predict] BERT fallback answer=%s conf=%.2f",
+                bert_result["prediction"].upper(),
+                bert_result["confidence"],
+            )
+
+        # ── Apply news validation insights to final result ────────────────────
+        final_result = news_validator.enhance_prediction(final_result, ai_result, news_validation)
+        
+        # Save prediction to history
+        predictions_collection = get_predictions_collection()
+        prediction_record = {
+            "user_id": str(current_user["_id"]),
+            "text": body.title[:500],  # Store title
+            "prediction": final_result["prediction"],
+            "confidence": final_result["confidence"],
+            "is_fake": final_result["is_fake"],
+            "created_at": datetime.utcnow()
+        }
+        await predictions_collection.insert_one(prediction_record)
+
+        logger.info(
+            "[predict] DONE user=%s | result=%s | confidence=%.2f | source=%s",
+            user_id,
+            final_result["prediction"].upper(),
+            final_result["confidence"],
+            final_result.get("prediction_source", "unknown"),
+        )
+        return final_result
+    except Exception as e:
+        logger.error("[predict] ERROR user=%s | %s", str(current_user.get("_id", "?")), e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+
+@router.post("/batch-predict")
+@limiter.limit("5/minute")
+async def batch_predict(
+    request: Request,
+    texts: list[str],
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Predict multiple news articles at once.
+    Flow: NewsAPI (real-world evidence) → Gemini AI (primary) → BERT (fallback only)
+    Requires authentication.
+    
+    Args:
+        texts: List of news article texts
+        
+    Returns:
+        List of predictions
+    """
+    try:
+        if len(texts) > 10:
+            raise HTTPException(status_code=422, detail="Max 10 items per batch request.")
+        user_id = str(current_user["_id"])
+        logger.info("[batch-predict] user=%s | count=%d", user_id, len(texts))
+        model, tokenizer, checkpoint = get_model()
+        results = []
+        predictions_collection = get_predictions_collection()
+        
+        for text in texts:
+            # ── STEP 1: NewsAPI / Google News ─────────────────────────────────
+            news_validation = news_validator.validate_claim(text)
+
+            # ── STEP 2: Gemini AI — PRIMARY (with news context) ───────────────
+            news_articles = news_validation.get("articles", []) if news_validation else []
+            ai_result = ai_checker.predict_with_context(text, news_articles=news_articles)
+
+            if ai_result:
+                final_result = {
+                    "text": text,
+                    "prediction": ai_result["prediction"],
+                    "confidence": ai_result["confidence"],
+                    "probabilities": ai_result["probabilities"],
+                    "is_fake": ai_result["is_fake"],
+                    "prediction_source": "gemini_ai",
+                    "classification_type": "binary",
+                    "reasoning": ai_result.get("reasoning", "No reasoning available."),
+                }
+                if news_validation and news_validation.get("relevant_articles", 0) >= 2:
+                    final_result["confidence"] = min(0.98, final_result["confidence"] + 0.05)
+            else:
+                # ── STEP 3: BERT — FALLBACK ────────────────────────────────────
+                formatted_input = f"{text} [SEP] {text}"
+                bert_result = predict_fake_news(formatted_input, model, tokenizer, checkpoint)
+                bert_result["text"] = text
+                final_result = {
+                    **bert_result,
+                    "is_fake": bert_result["prediction"] == "fake",
+                    "prediction_source": "bert_model_fallback",
+                    "reasoning": f"BERT model classified this as {bert_result['prediction']} with {bert_result['confidence']*100:.1f}% confidence based on linguistic pattern analysis.",
+                }
+
+            # ── Apply news validation insights ─────────────────────────────────
+            final_result = news_validator.enhance_prediction(final_result, ai_result, news_validation)
+            results.append(final_result)
+            
+            # Save to history
+            prediction_record = {
+                "user_id": str(current_user["_id"]),
+                "text": text[:500],
+                "prediction": final_result["prediction"],
+                "confidence": final_result["confidence"],
+                "is_fake": final_result["is_fake"],
+                "created_at": datetime.utcnow()
+            }
+            await predictions_collection.insert_one(prediction_record)
+        
+        logger.info("[batch-predict] DONE user=%s | processed=%d", user_id, len(results))
+        return {"predictions": results}
+    except Exception as e:
+        logger.error("[batch-predict] ERROR user=%s | %s", str(current_user.get("_id", "?")), e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Batch prediction error: {str(e)}")
+
+
+@router.post("/image-predict")
+@limiter.limit("10/minute")
+async def image_predict(
+    request: Request,
+    body: ImagePredictionRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Extract text from a news image and predict if it's fake or real.
+    Uses OCR to extract title and text, then runs through the prediction pipeline.
+    
+    Args:
+        request: ImagePredictionRequest containing base64 encoded image
+        
+    Returns:
+        Dict with extracted text and prediction results
+    """
+    try:
+        user_id = str(current_user["_id"])
+        logger.info("[image-predict] user=%s | mime=%s", user_id, body.mime_type)
+        # Step 1: Extract text from image using OCR
+        if not image_ocr.enabled:
+            raise HTTPException(status_code=503, detail="Image OCR service not available. Check AI API key.")
+        
+        extraction_result = image_ocr.extract_from_base64(body.image, body.mime_type)
+        
+        if not extraction_result or not extraction_result.get("extraction_success"):
+            raise HTTPException(
+                status_code=400, 
+                detail="Could not extract text from image. Please ensure the image contains readable news text."
+            )
+        
+        title = extraction_result.get("title", "")
+        text = extraction_result.get("text", "")
+        
+        # Use title if found, otherwise use first part of text
+        if title == "NOT_FOUND" or not title:
+            if text and text != "NOT_FOUND":
+                title = text[:200]  # Use first 200 chars of text as title
+            else:
+                raise HTTPException(status_code=400, detail="No readable text found in image.")
+        
+        # Step 2: News search (same as text pipeline — Gemini needs this context)
+        news_validation = news_validator.validate_claim(title)
+        logger.info(
+            "[image-predict] news_validation status=%s relevant=%d",
+            news_validation.get("verification_status", "n/a") if news_validation else "n/a",
+            news_validation.get("relevant_articles", 0) if news_validation else 0,
+        )
+        news_articles = news_validation.get("articles", []) if news_validation else []
+
+        # Step 3: Gemini AI — PRIMARY (with news context, identical to text pipeline)
+        ai_result = ai_checker.predict_with_context(title, news_articles=news_articles)
+
+        if ai_result:
+            final_result = {
+                "text": title,
+                "prediction": ai_result["prediction"],
+                "confidence": ai_result["confidence"],
+                "probabilities": ai_result["probabilities"],
+                "is_fake": ai_result["is_fake"],
+                "prediction_source": "gemini_ai",
+                "classification_type": "binary",
+                "extracted_from_image": True,
+                "reasoning": ai_result.get("reasoning", "No reasoning available."),
+                "context_articles_used": ai_result.get("context_articles_used", 0),
+            }
+            logger.info(
+                "[image-predict] Gemini answer=%s conf=%.2f context_articles=%d",
+                ai_result["prediction"].upper(),
+                ai_result["confidence"],
+                ai_result.get("context_articles_used", 0),
+            )
+        else:
+            # Step 4: BERT — FALLBACK (only when Gemini is unavailable)
+            logger.info("[image-predict] Gemini unavailable — falling back to BERT")
+            if text and text != "NOT_FOUND":
+                formatted_input = f"{title} [SEP] {text}"
+            else:
+                formatted_input = f"{title} [SEP] {title}"
+            model, tokenizer, checkpoint = get_model()
+            bert_result = predict_fake_news(formatted_input, model, tokenizer, checkpoint)
+            bert_result["text"] = title
+            final_result = {
+                **bert_result,
+                "is_fake": bert_result["prediction"] == "fake",
+                "prediction_source": "bert_model_fallback",
+                "extracted_from_image": True,
+                "reasoning": f"BERT model classified this as {bert_result['prediction']} with {bert_result['confidence']*100:.1f}% confidence based on linguistic pattern analysis.",
+            }
+
+        # Step 5: Apply news validation insights
+        final_result = news_validator.enhance_prediction(final_result, ai_result, news_validation)
+        
+        # Add extraction metadata
+        final_result["image_extraction"] = {
+            "title": title,
+            "text": text if text != "NOT_FOUND" else None,
+            "source": extraction_result.get("source") if extraction_result.get("source") != "NOT_FOUND" else None,
+            "date": extraction_result.get("date") if extraction_result.get("date") != "NOT_FOUND" else None
+        }
+        
+        # Save to history
+        predictions_collection = get_predictions_collection()
+        prediction_record = {
+            "user_id": str(current_user["_id"]),
+            "text": title[:500],
+            "prediction": final_result["prediction"],
+            "confidence": final_result["confidence"],
+            "is_fake": final_result["is_fake"],
+            "from_image": True,
+            "created_at": datetime.utcnow()
+        }
+        await predictions_collection.insert_one(prediction_record)
+
+        logger.info(
+            "[image-predict] DONE user=%s | title='%.60s' | result=%s | confidence=%.2f",
+            user_id, title,
+            final_result["prediction"].upper(),
+            final_result["confidence"],
+        )
+        return final_result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("[image-predict] ERROR user=%s | %s", str(current_user.get("_id", "?")), e, exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Image prediction error: {str(e)}")
+
+
+@router.post("/extract-image-text", response_model=ImageExtractionResponse)
+@limiter.limit("10/minute")
+async def extract_image_text(
+    request: Request,
+    body: ImagePredictionRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Extract text from an image without making a prediction.
+    Useful for previewing extracted content before verification.
+    
+    Args:
+        request: ImagePredictionRequest containing base64 encoded image
+        
+    Returns:
+        ImageExtractionResponse with extracted title and text
+    """
+    try:
+        if not image_ocr.enabled:
+            raise HTTPException(status_code=503, detail="Image OCR service not available.")
+        
+        result = image_ocr.extract_from_base64(body.image, body.mime_type)
+        
+        if not result:
+            raise HTTPException(status_code=400, detail="Failed to process image.")
+        
+        return ImageExtractionResponse(
+            title=result.get("title", "NOT_FOUND"),
+            text=result.get("text", "NOT_FOUND"),
+            source=result.get("source") if result.get("source") != "NOT_FOUND" else None,
+            date=result.get("date") if result.get("date") != "NOT_FOUND" else None,
+            extraction_success=result.get("extraction_success", False)
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Text extraction error: {str(e)}")

Backend/app/auth.py

@@ -0,0 +1,90 @@
+import os
+import bcrypt
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from dotenv import load_dotenv
+from app.database import get_users_collection
+from app.schemas.auth import TokenData
+
+load_dotenv()
+
+# JWT Configuration
+SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-super-secret-jwt-key-change-in-production")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "1440"))  # 24 hours
+
+# Security scheme
+security = HTTPBearer()
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash"""
+    return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password"""
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create a JWT access token"""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+def decode_token(token: str) -> Optional[TokenData]:
+    """Decode and validate a JWT token"""
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        email: str = payload.get("email")
+        if user_id is None:
+            return None
+        return TokenData(user_id=user_id, email=email)
+    except JWTError:
+        return None
+
+
+async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Get current authenticated user from JWT token"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    token = credentials.credentials
+    token_data = decode_token(token)
+    
+    if token_data is None:
+        raise credentials_exception
+    
+    # Get user from database
+    users_collection = get_users_collection()
+    from bson import ObjectId
+    
+    try:
+        user = await users_collection.find_one({"_id": ObjectId(token_data.user_id)})
+    except:
+        raise credentials_exception
+    
+    if user is None:
+        raise credentials_exception
+    
+    if not user.get("is_active", True):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User account is disabled"
+        )
+    
+    return user

Backend/app/database.py

@@ -0,0 +1,50 @@
+import os
+from motor.motor_asyncio import AsyncIOMotorClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# MongoDB connection settings
+MONGODB_URL = os.getenv("MONGODB_URL", "mongodb://localhost:27017")
+DATABASE_NAME = os.getenv("DATABASE_NAME", "fake_news_detector")
+
+# Global database client
+client: AsyncIOMotorClient = None
+db = None
+
+
+async def connect_to_mongodb():
+    """Connect to MongoDB database"""
+    global client, db
+    try:
+        client = AsyncIOMotorClient(MONGODB_URL)
+        db = client[DATABASE_NAME]
+        # Verify connection
+        await client.admin.command('ping')
+        print(f"✅ Connected to MongoDB: {DATABASE_NAME}")
+    except Exception as e:
+        print(f"❌ Failed to connect to MongoDB: {e}")
+        raise e
+
+
+async def close_mongodb_connection():
+    """Close MongoDB connection"""
+    global client
+    if client:
+        client.close()
+        print("MongoDB connection closed")
+
+
+def get_database():
+    """Get database instance"""
+    return db
+
+
+def get_users_collection():
+    """Get users collection"""
+    return db["users"]
+
+
+def get_predictions_collection():
+    """Get predictions history collection"""
+    return db["predictions"]

Backend/app/limiter.py

@@ -0,0 +1,6 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+# Shared rate limiter — uses client IP as the key.
+# Import this instance in main.py and all route files.
+limiter = Limiter(key_func=get_remote_address)

Backend/app/main.py

@@ -0,0 +1,84 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+import os
+import time
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+from app.api import routes, auth_routes
+from app.database import connect_to_mongodb, close_mongodb_connection
+from app.limiter import limiter
+from app.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage application lifecycle - connect/disconnect from MongoDB"""
+    logger.info("Starting up TruthLens API...")
+    await connect_to_mongodb()
+    logger.info("MongoDB connected. API is ready.")
+    yield
+    logger.info("Shutting down TruthLens API...")
+    await close_mongodb_connection()
+    logger.info("MongoDB disconnected. Goodbye.")
+
+
+app = FastAPI(
+    title="Fake News Detection API",
+    description="API for detecting fake news using fine-tuned BERT model with user authentication",
+    version="2.0.0",
+    lifespan=lifespan
+)
+
+# Attach rate limiter
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# Configure CORS – reads ALLOWED_ORIGINS from env (comma-separated) for production
+_raw_origins = os.getenv(
+    "ALLOWED_ORIGINS",
+    "http://localhost,http://localhost:80,http://localhost:3000,http://localhost:5173,http://127.0.0.1:3000,http://127.0.0.1:5173"
+)
+_allowed_origins = [o.strip() for o in _raw_origins.split(",") if o.strip()]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=_allowed_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Request/response logging middleware ──────────────────────────────────────
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start = time.time()
+    response = await call_next(request)
+    duration_ms = (time.time() - start) * 1000
+    logger.info(
+        "%s %s | status=%d | %.1fms",
+        request.method,
+        request.url.path,
+        response.status_code,
+        duration_ms,
+    )
+    return response
+
+
+# Include API routes
+app.include_router(auth_routes.router, prefix="/api", tags=["authentication"])
+app.include_router(routes.router, prefix="/api", tags=["predictions"])
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Fake News Detection API",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}

Backend/app/models/__init__.py

@@ -0,0 +1 @@
+# Models package

Backend/app/models/bert_model.py

@@ -0,0 +1,207 @@
+import torch
+import torch.nn as nn
+from transformers import BertTokenizer, BertModel
+from pathlib import Path
+from functools import lru_cache
+
+class EnhancedBertForSequenceClassification(nn.Module):
+    def __init__(self, model_name='bert-base-uncased', num_classes=2, dropout=0.3):
+        super().__init__()
+        self.num_classes = num_classes
+        self.bert = BertModel.from_pretrained(model_name)
+        self.dropout = nn.Dropout(dropout)
+
+        # Additional layers for better performance
+        self.lstm = nn.LSTM(
+            input_size=self.bert.config.hidden_size,
+            hidden_size=256,
+            num_layers=2,
+            batch_first=True,
+            dropout=0.2,
+            bidirectional=True
+        )
+
+        # Attention mechanism
+        self.attention = nn.MultiheadAttention(
+            embed_dim=512,  # bidirectional LSTM output
+            num_heads=8,
+            dropout=0.1
+        )
+
+        # Classification layers
+        self.classifier = nn.Sequential(
+            nn.Linear(512, 256),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(256, 128),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(128, num_classes)
+        )
+
+        # Layer normalization
+        self.layer_norm = nn.LayerNorm(512)
+
+    def forward(self, input_ids, attention_mask):
+        # BERT encoding
+        bert_output = self.bert(
+            input_ids=input_ids,
+            attention_mask=attention_mask
+        )
+
+        # Get sequence output (all tokens)
+        sequence_output = bert_output.last_hidden_state
+        sequence_output = self.dropout(sequence_output)
+
+        # LSTM layer
+        lstm_output, _ = self.lstm(sequence_output)
+        lstm_output = self.layer_norm(lstm_output)
+
+        # Self-attention
+        lstm_output_transposed = lstm_output.transpose(0, 1)
+        attn_output, _ = self.attention(
+            lstm_output_transposed,
+            lstm_output_transposed,
+            lstm_output_transposed
+        )
+        attn_output = attn_output.transpose(0, 1)
+
+        # Global max pooling
+        pooled_output = torch.max(attn_output, dim=1)[0]
+
+        # Classification
+        logits = self.classifier(pooled_output)
+
+        return logits
+
+@lru_cache(maxsize=1)
+def get_model():
+    """
+    Load the fine-tuned BERT model and tokenizer.
+    Uses caching to load only once.
+    
+    Returns:
+        tuple: (model, tokenizer, checkpoint_info)
+    """
+    model_path = Path(__file__).parent.parent.parent / "enhanced_bert_welfake_model"
+    
+    # Load tokenizer
+    tokenizer = BertTokenizer.from_pretrained(str(model_path))
+    
+    # Load checkpoint
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    checkpoint = torch.load(
+        model_path / "model.pth",
+        map_location=device
+    )
+    
+    # Get model configuration from checkpoint
+    num_classes = checkpoint.get('num_classes', 2)
+    classification_type = checkpoint.get('classification_type', 'binary')
+    model_config = checkpoint.get('config', {})
+    dropout = model_config.get('dropout', 0.3)
+    model_name = model_config.get('model_name', 'bert-base-uncased')
+    
+    # Create model with correct architecture
+    model = EnhancedBertForSequenceClassification(
+        model_name=model_name,
+        num_classes=num_classes,
+        dropout=dropout
+    )
+    
+    # Load state dict
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.to(device)
+    model.eval()
+    
+    return model, tokenizer, checkpoint
+
+def predict_fake_news(text: str, model=None, tokenizer=None, checkpoint=None):
+    """
+    Predict whether a news article is fake or real.
+    
+    Args:
+        text: News article text (can be title only, or title [SEP] text format)
+        model: Pre-loaded model (optional)
+        tokenizer: Pre-loaded tokenizer (optional)
+        checkpoint: Model checkpoint with metadata (optional)
+        
+    Returns:
+        dict: Prediction results with label, confidence, and probabilities
+    """
+    if model is None or tokenizer is None:
+        model, tokenizer, checkpoint = get_model()
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    # Format input to match training format: title [SEP] text
+    # If input doesn't have [SEP], treat the whole input as title + duplicate as text
+    if '[SEP]' not in text:
+        # User passed only headline/claim - format it like training data
+        # Use the text as both title and content for better model understanding
+        formatted_text = f"{text} [SEP] {text}"
+    else:
+        formatted_text = text
+    
+    # Determine classification type from checkpoint
+    num_classes = checkpoint.get('num_classes', 2) if checkpoint else 2
+    classification_type = checkpoint.get('classification_type', 'binary') if checkpoint else 'binary'
+    
+    # Label mapping based on classification type
+    # NOTE: WELFake dataset uses:
+    # 0 = real (legitimate news)
+    # 1 = fake (fake/misleading news)
+    if classification_type == 'binary' and num_classes == 2:
+        labels = {
+            0: "real",
+            1: "fake"
+        }
+    elif num_classes == 6:
+        labels = {
+            0: "pants-fire",
+            1: "false",
+            2: "barely-true",
+            3: "half-true",
+            4: "mostly-true",
+            5: "true"
+        }
+    else:
+        labels = {i: f"class_{i}" for i in range(num_classes)}
+    
+    # Tokenize input (use formatted text)
+    encoding = tokenizer(
+        formatted_text,
+        add_special_tokens=True,
+        max_length=512,
+        padding='max_length',
+        truncation=True,
+        return_tensors='pt'
+    )
+    
+    input_ids = encoding['input_ids'].to(device)
+    attention_mask = encoding['attention_mask'].to(device)
+    
+    # Make prediction
+    with torch.no_grad():
+        logits = model(input_ids, attention_mask)
+        probabilities = torch.softmax(logits, dim=1)
+        predicted_class = torch.argmax(probabilities, dim=1).item()
+        confidence = probabilities[0][predicted_class].item()
+    
+    # Convert probabilities to dict
+    prob_dict = {labels[i]: float(probabilities[0][i].item()) for i in range(num_classes)}
+    
+    # Determine if fake based on classification type
+    if classification_type == 'binary':
+        is_fake = predicted_class == 1  # class 1 is "fake" in WELFake dataset
+    else:
+        is_fake = predicted_class < 3  # pants-fire, false, barely-true are considered fake
+    
+    return {
+        "text": text,  # Return original text, not formatted
+        "prediction": labels[predicted_class],
+        "confidence": float(confidence),
+        "probabilities": prob_dict,
+        "is_fake": is_fake,
+        "classification_type": classification_type
+    }

Backend/app/schemas/__init__.py

@@ -0,0 +1 @@
+# Schemas package

Backend/app/schemas/auth.py

@@ -0,0 +1,86 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
+from datetime import datetime
+
+
+class UserCreate(BaseModel):
+    """Schema for user registration"""
+    email: EmailStr = Field(..., description="User email address")
+    username: str = Field(..., min_length=3, max_length=50, description="Username")
+    password: str = Field(..., min_length=6, description="Password (min 6 characters)")
+    full_name: Optional[str] = Field(None, description="Full name")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "email": "user@example.com",
+                "username": "johndoe",
+                "password": "securepassword123",
+                "full_name": "John Doe"
+            }
+        }
+
+
+class UserLogin(BaseModel):
+    """Schema for user login"""
+    email: EmailStr = Field(..., description="User email address")
+    password: str = Field(..., description="Password")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "email": "user@example.com",
+                "password": "securepassword123"
+            }
+        }
+
+
+class UserResponse(BaseModel):
+    """Schema for user response (without password)"""
+    id: str = Field(..., description="User ID")
+    email: str = Field(..., description="User email")
+    username: str = Field(..., description="Username")
+    full_name: Optional[str] = Field(None, description="Full name")
+    created_at: datetime = Field(..., description="Account creation date")
+    is_active: bool = Field(default=True, description="Whether user is active")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "id": "507f1f77bcf86cd799439011",
+                "email": "user@example.com",
+                "username": "johndoe",
+                "full_name": "John Doe",
+                "created_at": "2024-01-15T10:30:00Z",
+                "is_active": True
+            }
+        }
+
+
+class Token(BaseModel):
+    """Schema for JWT token response"""
+    access_token: str = Field(..., description="JWT access token")
+    token_type: str = Field(default="bearer", description="Token type")
+    user: UserResponse = Field(..., description="User information")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+                "token_type": "bearer",
+                "user": {
+                    "id": "507f1f77bcf86cd799439011",
+                    "email": "user@example.com",
+                    "username": "johndoe",
+                    "full_name": "John Doe",
+                    "created_at": "2024-01-15T10:30:00Z",
+                    "is_active": True
+                }
+            }
+        }
+
+
+class TokenData(BaseModel):
+    """Schema for decoded token data"""
+    user_id: Optional[str] = None
+    email: Optional[str] = None

Backend/app/schemas/prediction.py

@@ -0,0 +1,73 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class PredictionRequest(BaseModel):
+    title: str = Field(..., description="News headline/title to analyze", min_length=5)
+    text: Optional[str] = Field(default=None, description="Full article text (optional, improves accuracy)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "Scientists Discover New Treatment for Cancer",
+                "text": "Researchers at Johns Hopkins University have announced a breakthrough in cancer treatment."
+            }
+        }
+
+class ImagePredictionRequest(BaseModel):
+    image: str = Field(..., description="Base64 encoded image data")
+    mime_type: str = Field(default="image/jpeg", description="Image MIME type (image/jpeg, image/png)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "image": "base64_encoded_image_data_here...",
+                "mime_type": "image/jpeg"
+            }
+        }
+
+class ImageExtractionResponse(BaseModel):
+    title: str = Field(..., description="Extracted news title from image")
+    text: str = Field(..., description="Extracted text content from image")
+    source: Optional[str] = Field(default=None, description="News source if detected")
+    date: Optional[str] = Field(default=None, description="Date if detected")
+    extraction_success: bool = Field(..., description="Whether text extraction was successful")
+
+class PredictionResponse(BaseModel):
+    text: str = Field(..., description="Original input text")
+    prediction: str = Field(..., description="Predicted label (e.g., fake, real)")
+    confidence: float = Field(..., description="Confidence score for the prediction", ge=0, le=1)
+    probabilities: dict[str, float] = Field(..., description="Probabilities for all labels")
+    is_fake: bool = Field(..., description="Whether the news is considered fake")
+    classification_type: str = Field(default="binary", description="Type of classification (binary or multi-class)")
+    
+    # Prediction source tracking
+    prediction_source: str | None = Field(default=None, description="Source of prediction (bert_model, gemini_ai, or bert_model+gemini_ai)")
+    override_reason: str | None = Field(default=None, description="Reason if prediction was overridden by news sources")
+    
+    # Reasoning
+    reasoning: str | None = Field(default=None, description="Explanation of why the article was classified as real or fake")
+    
+    # News validation fields
+    news_validation: dict | None = Field(default=None, description="News source validation results")
+    news_insight: str | None = Field(default=None, description="Insight from news validation")
+    verification_boost: float | None = Field(default=None, description="Confidence adjustment from news validation")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Breaking news: Scientists have discovered a new planet in our solar system.",
+                "prediction": "fake",
+                "confidence": 0.85,
+                "probabilities": {
+                    "real": 0.15,
+                    "fake": 0.85
+                },
+                "is_fake": True,
+                "classification_type": "binary",
+                "news_validation": {
+                    "verification_status": "not_found",
+                    "total_articles_found": 0
+                },
+                "news_insight": "No news coverage found"
+            }
+        }

Backend/app/utils/__init__.py

@@ -0,0 +1 @@
+# Utils package

Backend/app/utils/ai_verification.py

@@ -0,0 +1,284 @@
+import os
+import re
+import time
+from google import genai
+from dotenv import load_dotenv
+from typing import Optional, Dict, List
+
+load_dotenv()
+
+# Models to try in order (current stable models per docs.ai.google.dev/gemini-api/docs/models)
+_CANDIDATE_MODELS = [
+    "gemini-2.5-flash-lite",     # most budget-friendly + fastest, separate quota pool
+    "gemini-2.5-flash",          # best price-performance fallback
+    "gemini-2.0-flash",          # deprecated but still available as last resort
+]
+
+_MAX_RETRIES = 3
+_RETRY_DELAY = 30  # seconds to wait on quota error
+
+class AIFactChecker:
+    def __init__(self):
+        api_key = os.getenv('AI_API_KEY')
+        self.enabled = os.getenv('ENABLE_AI_CHECK', 'true').lower() == 'true'
+        self._client = None
+        self._model_id = None
+
+        if api_key and api_key != 'your_api_key_here' and len(api_key) > 10:
+            try:
+                # New google-genai SDK uses a Client object
+                self._client = genai.Client(api_key=api_key)
+                # Pick the first model that doesn't raise on a list call
+                self._model_id = _CANDIDATE_MODELS[0]  # will be confirmed on first call
+                self.enabled = True
+                print(f"✓ Gemini AI (google-genai SDK) ready — primary model: {self._model_id}")
+            except Exception as e:
+                print(f"⚠ Failed to initialise Gemini AI: {e}")
+                self._client = None
+                self._model_id = None
+                self.enabled = False
+        else:
+            self._client = None
+            self._model_id = None
+            self.enabled = False
+            print("⚠ AI API key not configured, using BERT model only")
+
+    # ── robust response parser ─────────────────────────────────────────────────
+    def _parse_response(self, text_response: str) -> Optional[Dict]:
+        """
+        Parse Gemini's structured response.
+        Uses strict regex to avoid false-fake from lines like 'REAL (not FAKE)'.
+        """
+        print(f"[Gemini raw response]:\n{text_response}\n---")
+
+        # Strict match: look for CLASSIFICATION line
+        # Valid values: REAL, FAKE, UNVERIFIED
+        classification = "fake"  # default — for claims that can't be confirmed, lean fake
+        unverified = False
+        for line in text_response.split('\n'):
+            if 'CLASSIFICATION' in line.upper():
+                after_colon = line.split(':', 1)[-1].strip().upper()
+                if re.search(r'\bFAKE\b', after_colon) and not re.search(r'\bNOT\s+FAKE\b', after_colon):
+                    classification = "fake"
+                elif re.search(r'\b(UNVERIFIED|UNCERTAIN|UNCLEAR|MISLEADING)\b', after_colon):
+                    # UNVERIFIED = we cannot confirm the claim → treat as fake (safer default)
+                    classification = "fake"
+                    unverified = True
+                elif re.search(r'\bREAL\b', after_colon):
+                    classification = "real"
+                break
+
+        # UNVERIFIED gets a lower base confidence (0.60) instead of 0.75
+        confidence = 0.60 if unverified else 0.75
+        for line in text_response.split('\n'):
+            if 'CONFIDENCE' in line.upper():
+                match = re.search(r'(\d+(?:\.\d+)?)', line)
+                if match:
+                    confidence = float(match.group(1)) / 100.0
+                    if unverified:
+                        confidence = min(confidence, 0.68)  # cap UNVERIFIED so it stays low-confidence
+                    confidence = min(max(confidence, 0.50), 0.99)
+                break
+
+        # Extract the REASONING line for user-facing display
+        reasoning = ""
+        capture = False
+        for line in text_response.split('\n'):
+            if 'REASONING' in line.upper():
+                reasoning = line.split(':', 1)[-1].strip() if ':' in line else ""
+                capture = True
+                continue
+            if capture and line.strip():
+                reasoning += " " + line.strip()
+        reasoning = reasoning.strip() or "No detailed reasoning provided."
+
+        return {
+            "prediction": classification,
+            "confidence": confidence,
+            "probabilities": {
+                "fake": confidence if classification == "fake" else round(1 - confidence, 4),
+                "real": confidence if classification == "real" else round(1 - confidence, 4),
+            },
+            "is_fake": classification == "fake",
+            "ai_reasoning": text_response,
+            "reasoning": reasoning,
+            "ai_enabled": True,
+        }
+
+    # ── context-aware primary prediction ──────────────────────────────────────
+    def predict_with_context(
+        self,
+        text: str,
+        news_articles: Optional[List[Dict]] = None,
+    ) -> Optional[Dict]:
+        """
+        PRIMARY predictor. Gemini receives:
+          - The user's claim / headline
+          - Real news articles (title + description + fetched body snippet + URL)
+        Uses evidence to decide REAL vs FAKE.
+        """
+        if not self.enabled or not self._client:
+            return None
+
+        try:
+            # ── Build evidence block ──────────────────────────────────────────
+            evidence_block = ""
+            usable_articles = [a for a in (news_articles or []) if a.get("title")]
+            if usable_articles:  # noqa: SIM102
+                lines = []
+                for i, art in enumerate(usable_articles[:5], 1):
+                    title    = art.get("title", "").strip()
+                    source   = art.get("source", "Unknown")
+                    url      = art.get("url", "")
+                    pub_date = (art.get("published_at") or "").strip()
+                    desc     = (art.get("description") or art.get("snippet") or "").strip()[:300]
+                    snippet  = (art.get("fetched_snippet") or "").strip()[:500]
+
+                    entry  = f"[Article {i}] {source}\n"
+                    if pub_date:
+                        entry += f"  Published: {pub_date}\n"
+                    entry += f"  Headline : {title}\n"
+                    if desc:
+                        entry += f"  Summary  : {desc}\n"
+                    if snippet:
+                        entry += f"  Body text: {snippet}\n"
+                    if url:
+                        entry += f"  URL      : {url}\n"
+                    lines.append(entry)
+
+                evidence_block = (
+                    "\n=== LIVE NEWS ARTICLES RETRIEVED FROM THE WEB ===\n"
+                    + "\n".join(lines)
+                    + "=== END OF RETRIEVED ARTICLES ===\n"
+                )
+
+            # ── Prompt ────────────────────────────────────────────────────────
+            if evidence_block:
+                prompt = f"""You are an expert fact-checker. Assess whether the following claim is TRUE, FALSE, or UNVERIFIED.
+
+CLAIM TO VERIFY: "{text}"
+
+REAL NEWS ARTICLES RETRIEVED FROM THE WEB:
+{evidence_block}
+
+CLASSIFICATION RULES — read carefully before deciding:
+
+• REAL — Use this when:
+  - The retrieved articles SPECIFICALLY confirm the core factual event described in the claim (who, what, where) actually happened.
+  - The claim's key facts are directly supported by the articles — not just topically related.
+  - Sensationalist phrasing of a CONFIRMED real event is NOT fake news.
+  - Do NOT choose REAL merely because the articles cover a related topic without confirming the specific claim.
+
+• FAKE — Use this when:
+  - The retrieved articles DIRECTLY CONTRADICT the specific factual assertion (e.g. the event did not happen, the wrong person is named, the statistic is fabricated).
+  - The claim describes a HIGH-PROFILE EXTRAORDINARY EVENT (e.g. assassination of a sitting world leader, nuclear exchange, military attack on a capital city, declaration of world war) that would generate massive global breaking news coverage, yet NONE of the retrieved articles mention it occurring.
+  - There is clear evidence of fabrication or misinformation.
+  - Do NOT choose FAKE simply because the claim uses strong language or covers a sensitive topic — only when the specific facts are contradicted or clearly absent from worldwide coverage.
+
+• UNVERIFIED — Use this when:
+  - The retrieved articles cover a related topic but do NOT specifically confirm or deny the claim.
+  - The claim is about an ordinary or minor event in 2025–2026 that may not be fully reported yet.
+  - You cannot determine truth or falsehood from the available evidence.
+  - When in doubt between FAKE and UNVERIFIED for ORDINARY claims, choose UNVERIFIED.
+  - EXCEPTION: For extraordinary high-profile claims (world leader death, nuclear attack, etc.), if no article confirms it, choose FAKE — not UNVERIFIED.
+
+IMPORTANT: Finding articles about a RELATED TOPIC (e.g. Iran missile attacks) does NOT confirm a SPECIFIC claim (e.g. US President was killed). Check whether the articles confirm the exact claim, not just the general subject area.
+
+YOU MUST RESPOND IN EXACTLY THIS FORMAT — no preamble, no extra lines:
+CLASSIFICATION: REAL
+CONFIDENCE: 85%
+REASONING: Brief explanation referencing the articles.
+
+Valid classifications: REAL, FAKE, UNVERIFIED"""
+            else:
+                prompt = f"""You are an expert fact-checker.
+
+CLAIM TO VERIFY: "{text}"
+
+No live news articles were retrieved for this claim.
+
+INSTRUCTIONS:
+- For ordinary events in 2024–2026, default to UNVERIFIED — they may simply be outside your training data.
+- EXCEPTION: For extraordinary high-profile claims (e.g. assassination of a sitting world leader, nuclear war, major capital city attacked, declaration of world war between superpowers), the ABSENCE of news coverage is itself strong evidence the event did not happen. Such events would generate instant worldwide breaking news. If you have no knowledge of the event occurring AND no articles confirm it, classify as FAKE.
+- Choose FAKE for claims with clearly impossible statistics, demonstrably established hoaxes, direct logical impossibilities, classic misinformation patterns, or extraordinary world-headline events for which no confirmation exists anywhere.
+- Choose REAL only if you have strong, specific knowledge confirming this exact claim.
+- When uncertain about ordinary claims: UNVERIFIED is safer than FAKE.
+
+YOU MUST RESPOND IN EXACTLY THIS FORMAT — no preamble:
+CLASSIFICATION: UNVERIFIED
+CONFIDENCE: 60%
+REASONING: Brief explanation here.
+
+Valid classifications: REAL, FAKE, UNVERIFIED"""
+
+            # ── Call Gemini — try each model, fall to next on quota error ────
+            last_error = None
+            for attempt in range(_MAX_RETRIES):
+                all_quota = True
+                for model_id in _CANDIDATE_MODELS:
+                    try:
+                        response = self._client.models.generate_content(
+                            model=model_id,
+                            contents=prompt,
+                        )
+                        self._model_id = model_id
+                        result = self._parse_response(response.text)
+                        if result:
+                            result["context_articles_used"] = len(usable_articles)
+                        return result
+                    except Exception as model_err:
+                        err_str = str(model_err)
+                        last_error = model_err
+                        is_quota = (
+                            "quota" in err_str.lower()
+                            or "429" in err_str
+                            or "resource_exhausted" in err_str.lower()
+                        )
+                        if is_quota:
+                            # Parse suggested retry delay from error body
+                            delay_match = re.search(r'retry in (\d+(?:\.\d+)?)s', err_str.lower())
+                            suggested = int(float(delay_match.group(1))) + 2 if delay_match else _RETRY_DELAY
+                            print(f"⚠ Quota on {model_id} (attempt {attempt+1}), trying next model…")
+                            # DO NOT sleep here — try next model first
+                            continue  # ← try next model immediately
+                        else:
+                            all_quota = False
+                            print(f"⚠ Model {model_id} error: {err_str[:120]}")
+                            continue  # try next model
+
+                # All models failed this attempt
+                if all_quota and attempt < _MAX_RETRIES - 1:
+                    wait = suggested if 'suggested' in dir() else _RETRY_DELAY
+                    print(f"⚠ All models quota-exhausted. Waiting {wait}s before retry {attempt+2}/{_MAX_RETRIES}…")
+                    time.sleep(wait)
+
+            print(f"Gemini: all {len(_CANDIDATE_MODELS)} models failed after {_MAX_RETRIES} attempts. Last error: {str(last_error)[:200]}")
+            return None
+
+        except Exception as e:
+            print(f"Gemini unexpected error: {e}")
+            return None
+
+    # ── backwards-compat wrappers ──────────────────────────────────────────────
+    def predict(self, text: str) -> Optional[Dict]:
+        return self.predict_with_context(text, news_articles=None)
+
+    def check_claim(self, text: str) -> Optional[Dict]:
+        return self.predict(text)
+
+    def reconcile_predictions(self, bert_prediction: Dict, ai_result: Optional[Dict]) -> Dict:
+        if ai_result and self.enabled:
+            return {
+                "text": bert_prediction.get("text", ""),
+                "prediction": ai_result["prediction"],
+                "confidence": ai_result["confidence"],
+                "probabilities": ai_result["probabilities"],
+                "is_fake": ai_result["is_fake"],
+                "classification_type": "binary",
+            }
+        return {**bert_prediction, "is_fake": bert_prediction["prediction"] == "fake"}
+
+
+# Global instance
+ai_checker = AIFactChecker()
+

Backend/app/utils/image_ocr.py

@@ -0,0 +1,275 @@
+import os
+import base64
+import requests
+from dotenv import load_dotenv
+from typing import Optional, Dict
+
+try:
+    # mistralai>=1.x
+    from mistralai import Mistral
+except Exception:
+    try:
+        # mistralai<1.x
+        from mistralai.client import MistralClient as Mistral
+    except Exception:
+        Mistral = None
+
+load_dotenv()
+
+class ImageOCR:
+    """
+    Extract text from news images using Mistral OCR API.
+    Useful for analyzing screenshots of news shared on social media.
+    """
+    
+    def __init__(self):
+        self.api_key = os.getenv('MISTRAL_API_KEY')
+        self.enabled = False
+        self.client = None
+        self.use_http_fallback = False
+        self.model = "mistral-ocr-latest"  # Mistral's OCR model
+
+        if not (self.api_key and self.api_key != 'your_api_key_here' and len(self.api_key) > 10):
+            print("⚠ MISTRAL_API_KEY not configured, image OCR disabled")
+            return
+
+        if Mistral is not None:
+            try:
+                self.client = Mistral(api_key=self.api_key)
+                self.enabled = True
+                print("✓ Image OCR (Mistral OCR SDK) initialized successfully")
+                return
+            except Exception as e:
+                print(f"⚠ Failed to initialize Mistral OCR SDK: {e}")
+
+        # SDK import/init can fail in some cloud images; use direct HTTP API fallback.
+        self.use_http_fallback = True
+        self.enabled = True
+        print("⚠ Mistral SDK unavailable, using direct HTTP OCR fallback")
+    
+    def extract_text_from_image(self, image_data: bytes, mime_type: str = "image/jpeg") -> Optional[Dict]:
+        """
+        Extract news title and text from an image using Mistral OCR.
+        
+        Args:
+            image_data: Raw image bytes
+            mime_type: Image MIME type (image/jpeg, image/png, etc.)
+            
+        Returns:
+            Dict with extracted title, text, and metadata
+        """
+        if not self.enabled:
+            return None
+        
+        try:
+            # Convert to base64
+            base64_image = base64.b64encode(image_data).decode('utf-8')
+            return self._call_mistral_ocr(base64_image, mime_type)
+            
+        except Exception as e:
+            print(f"Image OCR error: {e}")
+            return {
+                "title": "NOT_FOUND",
+                "text": "NOT_FOUND",
+                "source": "NOT_FOUND",
+                "date": "NOT_FOUND",
+                "error": str(e),
+                "extraction_success": False
+            }
+    
+    def _call_mistral_ocr(self, base64_image: str, mime_type: str) -> Dict:
+        """Call Mistral OCR API for text extraction."""
+        
+        try:
+            # Use Mistral OCR API with base64 image
+            image_data_url = f"data:{mime_type};base64,{base64_image}"
+            if self.client and not self.use_http_fallback:
+                ocr_response = self.client.ocr.process(
+                    model=self.model,
+                    document={
+                        "type": "image_url",
+                        "image_url": image_data_url
+                    }
+                )
+            else:
+                ocr_response = self._call_mistral_ocr_http(image_data_url)
+
+            extracted_text = self._extract_text_from_ocr_response(ocr_response)
+            
+            extracted_text = extracted_text.strip()
+            
+            if not extracted_text:
+                return {
+                    "title": "NOT_FOUND",
+                    "text": "NOT_FOUND",
+                    "source": "NOT_FOUND",
+                    "date": "NOT_FOUND",
+                    "extraction_success": False
+                }
+            
+            # Parse the extracted text to find title and content
+            return self._parse_extracted_text(extracted_text)
+            
+        except Exception as e:
+            print(f"Mistral OCR API error: {e}")
+            return {
+                "title": "NOT_FOUND",
+                "text": "NOT_FOUND",
+                "source": "NOT_FOUND",
+                "date": "NOT_FOUND",
+                "error": str(e),
+                "extraction_success": False
+            }
+
+    def _call_mistral_ocr_http(self, image_data_url: str) -> Dict:
+        """Fallback to Mistral OCR REST API if SDK is unavailable."""
+        if not self.api_key:
+            raise RuntimeError("MISTRAL_API_KEY is missing")
+
+        response = requests.post(
+            "https://api.mistral.ai/v1/ocr",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": self.model,
+                "document": {
+                    "type": "image_url",
+                    "image_url": image_data_url,
+                },
+            },
+            timeout=60,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _extract_text_from_ocr_response(self, ocr_response) -> str:
+        """Extract page text from both SDK objects and HTTP JSON responses."""
+        extracted_text = ""
+
+        if isinstance(ocr_response, dict):
+            pages = ocr_response.get("pages", [])
+            for page in pages:
+                markdown = page.get("markdown") if isinstance(page, dict) else None
+                text = page.get("text") if isinstance(page, dict) else None
+                if markdown:
+                    extracted_text += markdown + "\n"
+                elif text:
+                    extracted_text += text + "\n"
+            return extracted_text.strip()
+
+        if ocr_response and hasattr(ocr_response, 'pages'):
+            for page in ocr_response.pages:
+                if hasattr(page, 'markdown') and page.markdown:
+                    extracted_text += page.markdown + "\n"
+                elif hasattr(page, 'text') and page.text:
+                    extracted_text += page.text + "\n"
+
+        return extracted_text.strip()
+    
+    def _parse_extracted_text(self, text: str) -> Dict:
+        """Parse OCR extracted text to identify title, content, source, and date."""
+        
+        lines = [line.strip() for line in text.split('\n') if line.strip()]
+        
+        if not lines:
+            return {
+                "title": "NOT_FOUND",
+                "text": "NOT_FOUND",
+                "source": "NOT_FOUND",
+                "date": "NOT_FOUND",
+                "extraction_success": False
+            }
+        
+        # Heuristic: First substantial line is likely the title
+        title = "NOT_FOUND"
+        text_content = "NOT_FOUND"
+        source = "NOT_FOUND"
+        date = "NOT_FOUND"
+        
+        # Find title (first line with significant content)
+        for i, line in enumerate(lines):
+            # Skip very short lines or common UI elements
+            if len(line) > 15 and not any(x in line.lower() for x in ['follow', 'share', 'comment', 'like', 'reply', 'retweet']):
+                title = line[:300]  # Limit title length
+                # Rest is the text content
+                remaining_lines = lines[i+1:] if i+1 < len(lines) else []
+                if remaining_lines:
+                    text_content = ' '.join(remaining_lines)[:2000]  # Limit text length
+                break
+        
+        # If no title found, use first line
+        if title == "NOT_FOUND" and lines:
+            title = lines[0][:300]
+            if len(lines) > 1:
+                text_content = ' '.join(lines[1:])[:2000]
+        
+        # Try to detect source (common news sources)
+        source_keywords = ['reuters', 'bbc', 'cnn', 'fox', 'nbc', 'abc', 'times', 'post', 'guardian', 'india today', 'ndtv', 'hindu', 'express', 'twitter', 'x.com', 'facebook', 'instagram']
+        for line in lines:
+            line_lower = line.lower()
+            for keyword in source_keywords:
+                if keyword in line_lower:
+                    source = line[:100]
+                    break
+            if source != "NOT_FOUND":
+                break
+        
+        # Try to detect date patterns
+        import re
+        date_patterns = [
+            r'\d{1,2}[/-]\d{1,2}[/-]\d{2,4}',  # DD/MM/YYYY or similar
+            r'\d{1,2}\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{4}',  # 26 Feb 2026
+            r'(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2},?\s+\d{4}',  # Feb 26, 2026
+        ]
+        
+        for pattern in date_patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                date = match.group()
+                break
+        
+        return {
+            "title": title,
+            "text": text_content if text_content != "NOT_FOUND" else title,
+            "source": source,
+            "date": date,
+            "raw_text": text[:3000],
+            "extraction_success": True
+        }
+    
+    def extract_from_base64(self, base64_string: str, mime_type: str = "image/jpeg") -> Optional[Dict]:
+        """
+        Extract text from a base64-encoded image.
+        
+        Args:
+            base64_string: Base64 encoded image string
+            mime_type: Image MIME type
+            
+        Returns:
+            Dict with extracted text
+        """
+        if not self.enabled:
+            return None
+            
+        try:
+            # Remove data URL prefix if present
+            if ',' in base64_string:
+                base64_string = base64_string.split(',')[1]
+            
+            return self._call_mistral_ocr(base64_string, mime_type)
+        except Exception as e:
+            print(f"Image OCR error: {e}")
+            return {
+                "title": "NOT_FOUND",
+                "text": "NOT_FOUND",
+                "source": "NOT_FOUND",
+                "date": "NOT_FOUND",
+                "error": str(e),
+                "extraction_success": False
+            }
+
+
+# Global instance
+image_ocr = ImageOCR()

Backend/app/utils/logger.py

@@ -0,0 +1,50 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+# ── Log directory ────────────────────────────────────────────────────────────
+LOG_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "logs")
+os.makedirs(LOG_DIR, exist_ok=True)
+
+LOG_FILE = os.path.join(LOG_DIR, "app.log")
+
+# ── Formatter ────────────────────────────────────────────────────────────────
+LOG_FORMAT = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
+
+# ── Handlers ─────────────────────────────────────────────────────────────────
+# Rotating file: max 10 MB per file, keep 5 backups
+file_handler = RotatingFileHandler(
+    LOG_FILE,
+    maxBytes=10 * 1024 * 1024,  # 10 MB
+    backupCount=5,
+    encoding="utf-8"
+)
+file_handler.setFormatter(formatter)
+file_handler.setLevel(logging.DEBUG)
+
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+console_handler.setLevel(logging.INFO)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a named logger that writes to both console and logs/app.log.
+
+    Usage:
+        from app.utils.logger import get_logger
+        logger = get_logger(__name__)
+        logger.info("Hello")
+    """
+    logger = logging.getLogger(name)
+
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(file_handler)
+        logger.addHandler(console_handler)
+        logger.propagate = False
+
+    return logger

Backend/app/utils/news_validator.py

@@ -0,0 +1,471 @@
+import os
+import requests
+from typing import Optional, Dict, List
+from dotenv import load_dotenv
+from datetime import datetime, timedelta
+import re
+
+load_dotenv()
+
+class NewsValidator:
+    """
+    Validates claims against real news sources using multiple APIs.
+    Supports: Google News RSS (free), NewsAPI, SerpAPI
+    """
+    
+    def __init__(self):
+        self.newsapi_key = os.getenv('NEWSAPI_KEY')
+        self.serpapi_key = os.getenv('SERPAPI_KEY')
+        # Always enabled because Google News RSS is free and doesn't need API key
+        self.enabled = True
+        
+    def extract_keywords(self, text: str) -> List[str]:
+        """Extract important keywords from text for searching"""
+        # Common stop words to filter out
+        stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 
+                      'of', 'with', 'is', 'are', 'was', 'were', 'been', 'be', 'have', 'has', 
+                      'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 
+                      'might', 'can', 'said', 'says', 'that', 'this', 'they', 'their', 'them',
+                      'there', 'these', 'those', 'what', 'which', 'when', 'where', 'who', 'whom',
+                      'how', 'why', 'just', 'only', 'even', 'also', 'very', 'most', 'some', 
+                      'many', 'much', 'more', 'other', 'than', 'then', 'now', 'here', 'such',
+                      'like', 'into', 'over', 'after', 'before', 'between', 'under', 'again',
+                      'about', 'being', 'once', 'during', 'each', 'because', 'through', 'while',
+                      'news', 'breaking', 'report', 'says', 'according', 'announced', 'claims',
+                      'article', 'story', 'sources', 'officials', 'people', 'percent', 'years'}
+        
+        # Extract words (including proper nouns with capitals)
+        words = re.findall(r'\b[A-Za-z]{3,}\b', text)
+        
+        # Prioritize capitalized words (likely proper nouns - names, places, organizations)
+        proper_nouns = [w for w in words if w[0].isupper() and w.lower() not in stop_words]
+        
+        # Get other important words
+        other_words = [w.lower() for w in words if w.lower() not in stop_words and not w[0].isupper()]
+        
+        # Combine: proper nouns first, then other words
+        keywords = proper_nouns[:4] + other_words[:3]
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_keywords = []
+        for k in keywords:
+            k_lower = k.lower()
+            if k_lower not in seen:
+                seen.add(k_lower)
+                unique_keywords.append(k)
+        
+        return unique_keywords[:6]
+    
+    def build_search_query(self, text: str) -> str:
+        """Build an effective search query from the text"""
+        # Clean the text - remove extra whitespace
+        clean_text = ' '.join(text.split())
+        
+        # If text is short enough, use it directly (best for relevance)
+        if len(clean_text) <= 150:
+            return clean_text
+        
+        # For longer text, extract the most important parts
+        keywords = self.extract_keywords(text)
+        
+        if not keywords:
+            # Fallback: use first 100 chars
+            return clean_text[:100].strip()
+        
+        # Build query with proper nouns quoted for exact matching
+        query_parts = []
+        for kw in keywords[:5]:
+            if kw[0].isupper():
+                query_parts.append(f'"{kw}"')
+            else:
+                query_parts.append(kw)
+        
+        return ' '.join(query_parts)
+    
+    def search_google_news_rss(self, query: str) -> Optional[Dict]:
+        """Search Google News RSS feed for free, real-time results"""
+        try:
+            import urllib.parse
+            
+            # Google News RSS - free and always up-to-date
+            encoded_query = urllib.parse.quote(query)
+            url = f"https://news.google.com/rss/search?q={encoded_query}&hl=en-IN&gl=IN&ceid=IN:en"
+            
+            response = requests.get(url, timeout=10, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            })
+            
+            if response.status_code == 200:
+                import xml.etree.ElementTree as ET
+                root = ET.fromstring(response.content)
+                
+                articles = []
+                for item in root.findall('.//item')[:10]:
+                    title = item.find('title')
+                    link = item.find('link')
+                    pub_date = item.find('pubDate')
+                    source = item.find('source')
+                    
+                    if title is not None and link is not None:
+                        # Extract and clean the RSS <description> element (contains HTML snippet)
+                        description_elem = item.find('description')
+                        desc_text = ""
+                        if description_elem is not None and description_elem.text:
+                            desc_text = re.sub(r'<[^>]+>', '', description_elem.text).strip()[:300]
+                        articles.append({
+                            'title': title.text,
+                            'url': link.text,
+                            'source': source.text if source is not None else 'Google News',
+                            'published_at': pub_date.text if pub_date is not None else None,
+                            'description': desc_text or (title.text[:200] if title.text else '')
+                        })
+                
+                return {
+                    'total_results': len(articles),
+                    'articles': articles[:5]
+                }
+            return None
+        except Exception as e:
+            print(f"Google News RSS error: {e}")
+            return None
+    
+    def search_newsapi(self, query: str, days: int = 7) -> Optional[Dict]:
+        """Search NewsAPI for relevant articles"""
+        if not self.newsapi_key or self.newsapi_key == 'your_newsapi_key_here':
+            return None
+            
+        try:
+            from_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+            url = 'https://newsapi.org/v2/everything'
+            
+            params = {
+                'q': query,
+                'from': from_date,
+                'sortBy': 'publishedAt',  # Sort by date for recent news
+                'language': 'en',
+                'pageSize': 10,
+                'apiKey': self.newsapi_key
+            }
+            
+            response = requests.get(url, params=params, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                articles = data.get('articles', [])
+                
+                return {
+                    'total_results': data.get('totalResults', 0),
+                    'articles': [
+                        {
+                            'title': article.get('title'),
+                            'source': article.get('source', {}).get('name'),
+                            'url': article.get('url'),
+                            'published_at': article.get('publishedAt'),
+                            'description': article.get('description', '')[:200] if article.get('description') else ''
+                        }
+                        for article in articles[:5]
+                    ]
+                }
+            else:
+                print(f"NewsAPI response: {response.status_code} - {response.text[:200]}")
+            return None
+        except Exception as e:
+            print(f"NewsAPI error: {e}")
+            return None
+    
+    def search_serpapi(self, query: str) -> Optional[Dict]:
+        """Search Google News using SerpAPI"""
+        if not self.serpapi_key or self.serpapi_key == 'your_serpapi_key_here':
+            return None
+            
+        try:
+            import serpapi
+            
+            params = {
+                "q": query,
+                "tbm": "nws",  # News search
+                "api_key": self.serpapi_key,
+                "num": 10
+            }
+            
+            results = serpapi.search(params)
+            
+            news_results = results.get('news_results', [])
+            
+            return {
+                'total_results': len(news_results),
+                'articles': [
+                    {
+                        'title': item.get('title'),
+                        'source': item.get('source', {}).get('name') if isinstance(item.get('source'), dict) else item.get('source'),
+                        'url': item.get('link'),
+                        'published_at': item.get('date'),
+                        'description': item.get('snippet', '')[:200]
+                    }
+                    for item in news_results[:5]
+                ]
+            }
+        except Exception as e:
+            print(f"SerpAPI error: {e}")
+            return None
+
+    def fetch_article_snippet(self, url: str, max_chars: int = 600) -> str:
+        """
+        Fetch the opening paragraphs of an article URL so Gemini gets
+        real content, not just the headline.
+
+        Handles Google News redirect URLs (news.google.com/rss/articles/...)
+        by resolving the redirect with a HEAD request first.
+        Returns an empty string on any error (non-blocking).
+        """
+        if not url or not url.startswith("http"):
+            return ""
+        try:
+            from bs4 import BeautifulSoup
+
+            headers = {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/122.0.0.0 Safari/537.36"
+                ),
+                "Accept": "text/html,application/xhtml+xml,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+            }
+
+            # Google News RSS returns redirect URLs — resolve them first
+            if "news.google.com" in url:
+                try:
+                    head = requests.head(url, headers=headers, timeout=5, allow_redirects=True)
+                    resolved = head.url
+                    if resolved and resolved != url and "news.google.com" not in resolved:
+                        url = resolved
+                except Exception:
+                    pass  # keep original URL and attempt anyway
+
+            resp = requests.get(url, headers=headers, timeout=7, allow_redirects=True)
+            if resp.status_code != 200:
+                return ""
+
+            # Many paywalled sites return thin HTML but some text still leaks
+            soup = BeautifulSoup(resp.text, "html.parser")
+            for tag in soup(["script", "style", "nav", "header", "footer", "aside", "figure"]):
+                tag.decompose()
+            paragraphs = [
+                p.get_text(" ", strip=True)
+                for p in soup.find_all("p")
+                if len(p.get_text(strip=True)) > 60
+            ]
+            snippet = " ".join(paragraphs[:6])
+            return snippet[:max_chars].strip()
+
+        except Exception:
+            return ""
+
+    def validate_claim(self, text: str) -> Optional[Dict]:
+        """
+        Validate a claim against real news sources
+        
+        Args:
+            text: The claim to validate
+            
+        Returns:
+            Dict with validation results or None if no API available
+        """
+        if not self.enabled:
+            return None
+        
+        # Build search query from user's full input
+        query = self.build_search_query(text)
+        keywords = self.extract_keywords(text)
+        
+        print(f"🔍 Searching news with query: {query[:100]}...")
+        
+        # Try Google News RSS first (free, real-time, most relevant)
+        print(f"🔍 Searching Google News with query: {query[:80]}...")
+        news_results = self.search_google_news_rss(query)
+        
+        # If no results, try with keywords only
+        if not news_results or news_results.get('total_results', 0) == 0:
+            keyword_query = ' '.join(keywords[:4]) if keywords else query[:50]
+            print(f"🔍 Retry Google News with keywords: {keyword_query}")
+            news_results = self.search_google_news_rss(keyword_query)
+        
+        # If Google News fails, try NewsAPI
+        if not news_results or news_results.get('total_results', 0) == 0:
+            print("🔍 Trying NewsAPI...")
+            news_results = self.search_newsapi(query, days=7)
+        
+        # If NewsAPI no results, try with keywords
+        if not news_results or news_results.get('total_results', 0) == 0:
+            keyword_query = ' '.join(keywords[:4]) if keywords else query[:50]
+            news_results = self.search_newsapi(keyword_query, days=7)
+        
+        # If NewsAPI fails, try SerpAPI
+        if not news_results or news_results.get('total_results', 0) == 0:
+            print("🔍 Trying SerpAPI...")
+            news_results = self.search_serpapi(query)
+        
+        # If still no results, try SerpAPI with keywords
+        if not news_results or news_results.get('total_results', 0) == 0:
+            keyword_query = ' '.join(keywords[:4]) if keywords else query[:50]
+            news_results = self.search_serpapi(keyword_query)
+        
+        if not news_results:
+            return {
+                'news_validation_enabled': True,
+                'verification_status': 'unavailable',
+                'confidence': 0.5,
+                'message': 'News validation service unavailable.',
+                'total_results': 0,
+                'relevant_articles': 0,
+                'articles': [],
+                'search_keywords': keywords[:3],
+                'search_query': query[:100]
+            }
+        
+        # Analyze results
+        total_articles = news_results.get('total_results', 0)
+        articles = news_results.get('articles', [])
+        
+        # Check if any articles are relevant by matching keywords or text fragments
+        relevant_count = 0
+        relevant_articles = []
+        
+        # Also check for words from the original text
+        text_words = set(word.lower() for word in text.split() if len(word) > 4)
+        
+        for article in articles:
+            title = article.get('title', '').lower()
+            desc = article.get('description', '').lower() if article.get('description') else ''
+            article_text = title + ' ' + desc
+            
+            # Check if keywords appear in article
+            keyword_matches = 0
+            for keyword in keywords[:5]:
+                kw_lower = keyword.lower()
+                if kw_lower in article_text:
+                    keyword_matches += 1
+            
+            # Also check for common words from original text
+            text_matches = sum(1 for w in text_words if w in article_text)
+            
+            # Consider relevant if keyword match or significant text overlap
+            if keyword_matches >= 1 or text_matches >= 3:
+                relevant_count += 1
+                article['relevance_score'] = keyword_matches + (text_matches * 0.5)
+                relevant_articles.append(article)
+        
+        # Sort by relevance score and prioritize
+        relevant_articles.sort(key=lambda x: x.get('relevance_score', 0), reverse=True)
+
+        # Combine: relevant first, then others
+        if relevant_articles:
+            other_articles = [a for a in articles if a not in relevant_articles]
+            articles = relevant_articles + other_articles
+
+        # ── Fetch real article body snippets for Gemini context ──────────────
+        # Only fetch for the top 3 to keep response time reasonable
+        print(f"📰 Fetching article snippets for top {min(3, len(articles))} articles...")
+        for art in articles[:3]:
+            url = art.get('url', '')
+            if url:
+                art['fetched_snippet'] = self.fetch_article_snippet(url)
+                if art['fetched_snippet']:
+                    print(f"   ✓ Fetched snippet from {art.get('source','?')} ({len(art['fetched_snippet'])} chars)")
+                else:
+                    print(f"   ✗ Could not fetch snippet from {url[:60]}")
+        
+        # Calculate confidence based on findings
+        if total_articles == 0:
+            verification_status = "unverified"
+            confidence = 0.3
+            message = "No recent news articles found matching this claim."
+        elif relevant_count >= 2:
+            verification_status = "found"
+            confidence = min(0.9, 0.5 + (relevant_count * 0.1))
+            message = f"Found {relevant_count} relevant news articles discussing this topic."
+        elif relevant_count == 1:
+            verification_status = "limited"
+            confidence = 0.6
+            message = "Found limited news coverage of this topic."
+        else:
+            verification_status = "not_found"
+            confidence = 0.4
+            message = "No relevant news articles found. This may be unverified information."
+        
+        return {
+            'news_validation_enabled': True,
+            'verification_status': verification_status,
+            'confidence': confidence,
+            'message': message,
+            'total_results': total_articles,
+            'relevant_articles': relevant_count,
+            'articles': articles,
+            'search_keywords': keywords[:4],
+            'search_query': query[:100]
+        }
+    
+    def enhance_prediction(self, bert_result: Dict, ai_result: Optional[Dict], 
+                          news_validation: Optional[Dict]) -> Dict:
+        """
+        Enhance the final prediction with news validation data.
+        NEWS SOURCES CAN OVERRIDE AI/MODEL PREDICTIONS when strong evidence exists.
+        
+        Args:
+            bert_result: Model prediction (already corrected by AI silently)
+            ai_result: AI prediction (can be None)
+            news_validation: News validation results (can be None)
+            
+        Returns:
+            Enhanced prediction with news validation insights
+        """
+        result = bert_result.copy()
+        
+        # Add news validation data
+        if news_validation:
+            result['news_validation'] = news_validation
+            
+            # Adjust final prediction based on news validation
+            verification = news_validation['verification_status']
+            relevant_count = news_validation.get('relevant_articles', 0)
+            
+            if verification == 'not_found':
+                # No news found - slightly reduce confidence in a "real" prediction
+                result['news_insight'] = "⚠️ No recent news coverage found. Treat with caution."
+                result['verification_boost'] = -0.1
+                
+                if result.get('prediction') == 'real':
+                    result['confidence'] = max(0.3, result.get('confidence', 0.5) - 0.1)
+                    result['probabilities'] = {'real': result['confidence'], 'fake': 1 - result['confidence']}
+                
+            elif verification == 'found':
+                # Related articles found - informational only, does NOT verify the claim
+                result['news_insight'] = f"ℹ️ Found {relevant_count} related news article(s) on this topic."
+                result['verification_boost'] = 0.05
+                # NOTE: Finding related articles does not mean the specific claim is true.
+                # The model prediction is preserved as-is.
+                
+            elif verification == 'limited':
+                result['news_insight'] = "ℹ️ Limited related news coverage found."
+                result['verification_boost'] = 0.0
+                # NOTE: Finding related articles does not mean the specific claim is true.
+                # The model prediction is preserved as-is.
+                
+            else:  # unverified
+                result['news_insight'] = "Unable to verify against news sources."
+                result['verification_boost'] = 0.0
+        else:
+            result['news_validation'] = None
+            result['news_insight'] = "News validation not available."
+            result['verification_boost'] = 0.0
+        
+        # Update is_fake based on final prediction
+        if result.get('prediction'):
+            result['is_fake'] = result['prediction'] == 'fake'
+        
+        return result
+
+# Global instance
+news_validator = NewsValidator()

Backend/enhanced_bert_liar_model/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Backend/enhanced_bert_liar_model/tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

Backend/enhanced_bert_welfake_model/tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

Backend/run_api.py

@@ -0,0 +1,49 @@
+import uvicorn
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+LOG_DIR = os.path.join(os.path.dirname(__file__), "logs")
+os.makedirs(LOG_DIR, exist_ok=True)
+
+# Configure uvicorn to also write its own logs to the logs/ folder
+LOG_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": {
+            "format": "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+            "datefmt": "%Y-%m-%d %H:%M:%S",
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "default",
+            "stream": "ext://sys.stdout",
+        },
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "formatter": "default",
+            "filename": os.path.join(LOG_DIR, "app.log"),
+            "maxBytes": 10 * 1024 * 1024,  # 10 MB
+            "backupCount": 5,
+            "encoding": "utf-8",
+        },
+    },
+    "loggers": {
+        "uvicorn": {"handlers": ["console", "file"], "level": "INFO", "propagate": False},
+        "uvicorn.error": {"handlers": ["console", "file"], "level": "INFO", "propagate": False},
+        "uvicorn.access": {"handlers": ["console", "file"], "level": "INFO", "propagate": False},
+    },
+}
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info",
+        log_config=LOG_CONFIG,
+    )