Upload 6 files

.dockerignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+env/
+venv/
+.venv/
+.git/
+.gitignore
+dist/
+build/
+node_modules/
+*.log
+.env
+public/frames/*
+*.sqlite3
+*.db
+uploads/
+__pycache__/

.gitignore

@@ -0,0 +1,24 @@
+# Backend-specific ignores
+__pycache__/
+*.py[cod]
+
+# Local env files
+.env
+.env.local
+
+# Virtualenvs (in case devs create them here)
+venv/
+env/
+.venv/
+
+# Generated frames and uploads
+public/frames/
+uploads/
+
+# Logs and temp
+*.log
+tmp/
+temp/
+
+# Docker artifacts
+*.tar

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.9
+
+# Install system dependencies required by some Python packages (OpenCV, Pillow, ffmpeg)
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+	   build-essential \
+	   ffmpeg \
+	   libsm6 \
+	   libxext6 \
+	   libxrender1 \
+	   libgl1 \
+	   git \
+	&& rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip \
+	&& pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

add_sample_data.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Script to add sample rumour data to MongoDB for testing real-time updates
+"""
+
+import os
+import sys
+import asyncio
+from datetime import datetime, timedelta
+from pymongo import MongoClient
+from pymongo.errors import DuplicateKeyError
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def get_mongo_client():
+    """Get MongoDB client connection"""
+    connection_string = os.getenv('MONGO_CONNECTION_STRING')
+    if not connection_string:
+        raise ValueError("MONGO_CONNECTION_STRING environment variable not set")
+    
+    client = MongoClient(connection_string)
+    # Test connection
+    client.admin.command('ping')
+    return client
+
+def add_sample_rumours():
+    """Add sample rumour data to MongoDB"""
+    
+    client = get_mongo_client()
+    db = client['aegis']
+    collection = db['debunk_posts']
+    
+    # Sample rumour data with unique post_ids
+    sample_rumours = [
+        {
+            "post_id": "sample_rumour_001",
+            "claim": "Scientists have discovered a new planet that could support human life",
+            "summary": "Recent astronomical observations suggest the possibility of a habitable exoplanet",
+            "platform": "Twitter",
+            "Post_link": "https://twitter.com/example/status/123456789",
+            "verification": {
+                "verdict": "true",
+                "message": "This claim is accurate based on NASA's recent findings",
+                "reasoning": "The discovery was confirmed by multiple telescopes and peer-reviewed research",
+                "verification_date": datetime.now() - timedelta(hours=2),
+                "sources": {
+                    "count": 3,
+                    "links": [
+                        "https://www.nasa.gov/feature/nasa-discovers-new-exoplanet",
+                        "https://www.nature.com/articles/space-discovery-2024",
+                        "https://www.scientificamerican.com/article/new-habitable-planet"
+                    ],
+                    "titles": [
+                        "NASA Discovers New Exoplanet",
+                        "Nature: Space Discovery 2024",
+                        "Scientific American: New Habitable Planet Found"
+                    ]
+                }
+            },
+            "stored_at": datetime.now() - timedelta(hours=2)
+        },
+        {
+            "post_id": "sample_rumour_002", 
+            "claim": "Breaking: Major tech company announces they're shutting down all services",
+            "summary": "A viral post claims a major technology company is discontinuing all its services",
+            "platform": "Facebook",
+            "Post_link": "https://facebook.com/example/posts/987654321",
+            "verification": {
+                "verdict": "false",
+                "message": "This is completely false and has been debunked by the company",
+                "reasoning": "The company's official channels have confirmed this is a hoax. No such announcement was made.",
+                "verification_date": datetime.now() - timedelta(hours=1, minutes=30),
+                "sources": {
+                    "count": 2,
+                    "links": [
+                        "https://company.com/official-statement",
+                        "https://techcrunch.com/company-denies-shutdown-rumors"
+                    ],
+                    "titles": [
+                        "Official Company Statement",
+                        "TechCrunch: Company Denies Shutdown Rumors"
+                    ]
+                }
+            },
+            "stored_at": datetime.now() - timedelta(hours=1, minutes=30)
+        },
+        {
+            "post_id": "sample_rumour_003",
+            "claim": "New study shows that coffee increases life expectancy by 5 years",
+            "summary": "A recent research paper claims significant health benefits from coffee consumption",
+            "platform": "Instagram",
+            "Post_link": "https://instagram.com/p/coffee-study-2024",
+            "verification": {
+                "verdict": "mostly true",
+                "message": "While coffee does have health benefits, the 5-year claim is exaggerated",
+                "reasoning": "Studies show moderate coffee consumption has health benefits, but the specific 5-year claim is not supported by the research cited.",
+                "verification_date": datetime.now() - timedelta(minutes=45),
+                "sources": {
+                    "count": 4,
+                    "links": [
+                        "https://www.nejm.org/journal/coffee-health-study",
+                        "https://www.mayoclinic.org/coffee-health-benefits",
+                        "https://www.hsph.harvard.edu/coffee-research",
+                        "https://www.healthline.com/coffee-life-expectancy-study"
+                    ],
+                    "titles": [
+                        "NEJM: Coffee Health Study",
+                        "Mayo Clinic: Coffee Health Benefits",
+                        "Harvard: Coffee Research",
+                        "Healthline: Coffee Life Expectancy Study"
+                    ]
+                }
+            },
+            "stored_at": datetime.now() - timedelta(minutes=45)
+        },
+        {
+            "post_id": "sample_rumour_004",
+            "claim": "Local restaurant caught serving expired food to customers",
+            "summary": "Social media posts allege a popular local restaurant is serving expired ingredients",
+            "platform": "Reddit",
+            "Post_link": "https://reddit.com/r/localnews/expired-food-restaurant",
+            "verification": {
+                "verdict": "disputed",
+                "message": "The claims are under investigation by health authorities",
+                "reasoning": "Health department inspection is ongoing. Some allegations have been confirmed, others are disputed by the restaurant management.",
+                "verification_date": datetime.now() - timedelta(minutes=20),
+                "sources": {
+                    "count": 3,
+                    "links": [
+                        "https://healthdept.gov/inspection-reports",
+                        "https://localnews.com/restaurant-investigation",
+                        "https://restaurant.com/official-response"
+                    ],
+                    "titles": [
+                        "Health Department Inspection Reports",
+                        "Local News: Restaurant Investigation",
+                        "Restaurant Official Response"
+                    ]
+                }
+            },
+            "stored_at": datetime.now() - timedelta(minutes=20)
+        },
+        {
+            "post_id": "sample_rumour_005",
+            "claim": "Mysterious lights spotted in the sky over the city last night",
+            "summary": "Multiple reports of unusual lights in the night sky",
+            "platform": "TikTok",
+            "Post_link": "https://tiktok.com/@user/video/mysterious-lights-city",
+            "verification": {
+                "verdict": "unverified",
+                "message": "Unable to verify the source or authenticity of these reports",
+                "reasoning": "No official explanation has been provided. Could be various phenomena including aircraft, drones, or natural occurrences.",
+                "verification_date": datetime.now() - timedelta(minutes=10),
+                "sources": {
+                    "count": 2,
+                    "links": [
+                        "https://weather.gov/sky-conditions-report",
+                        "https://faa.gov/flight-tracker-archive"
+                    ],
+                    "titles": [
+                        "Weather Service: Sky Conditions Report",
+                        "FAA: Flight Tracker Archive"
+                    ]
+                }
+            },
+            "stored_at": datetime.now() - timedelta(minutes=10)
+        }
+    ]
+    
+    print("🔄 Adding sample rumour data to MongoDB...")
+    
+    added_count = 0
+    skipped_count = 0
+    
+    for rumour in sample_rumours:
+        try:
+            # Try to insert the document
+            result = collection.insert_one(rumour)
+            print(f"✅ Added rumour: {rumour['post_id']} - {rumour['claim'][:50]}...")
+            added_count += 1
+            
+        except DuplicateKeyError:
+            print(f"⚠️  Skipped rumour (already exists): {rumour['post_id']}")
+            skipped_count += 1
+            
+        except Exception as e:
+            print(f"❌ Error adding rumour {rumour['post_id']}: {e}")
+    
+    print(f"\n📊 Summary:")
+    print(f"   ✅ Added: {added_count} rumours")
+    print(f"   ⚠️  Skipped: {skipped_count} rumours")
+    print(f"   📝 Total in database: {collection.count_documents({})} rumours")
+    
+    # Close connection
+    client.close()
+    print("\n🔌 MongoDB connection closed")
+
+def test_realtime_update():
+    """Add a new rumour to test real-time updates"""
+    
+    client = get_mongo_client()
+    db = client['aegis']
+    collection = db['debunk_posts']
+    
+    # Create a new rumour with current timestamp
+    new_rumour = {
+        "post_id": f"test_realtime_{int(datetime.now().timestamp())}",
+        "claim": "Test real-time update: This is a new rumour added for testing WebSocket functionality",
+        "summary": "This rumour was added to test the real-time WebSocket update system",
+        "platform": "Test Platform",
+        "Post_link": "https://example.com/test-realtime-update",
+        "verification": {
+            "verdict": "true",
+            "message": "This is a test rumour for real-time updates",
+            "reasoning": "Added programmatically to verify WebSocket functionality",
+            "verification_date": datetime.now(),
+            "sources": {
+                "count": 1,
+                "links": ["https://example.com/test-source"],
+                "titles": ["Test Source"]
+            }
+        },
+        "stored_at": datetime.now()
+    }
+    
+    print("🔄 Adding test rumour for real-time update...")
+    
+    try:
+        result = collection.insert_one(new_rumour)
+        print(f"✅ Test rumour added successfully!")
+        print(f"   📝 Post ID: {new_rumour['post_id']}")
+        print(f"   📅 Added at: {new_rumour['stored_at']}")
+        print(f"   🔍 MongoDB ID: {result.inserted_id}")
+        print("\n💡 Check your frontend - you should see this new rumour appear automatically!")
+        
+    except Exception as e:
+        print(f"❌ Error adding test rumour: {e}")
+    
+    # Close connection
+    client.close()
+    print("\n🔌 MongoDB connection closed")
+
+if __name__ == "__main__":
+    print("🚀 MongoDB Sample Data Script")
+    print("=" * 50)
+    
+    if len(sys.argv) > 1 and sys.argv[1] == "test":
+        test_realtime_update()
+    else:
+        add_sample_rumours()
+    
+    print("\n✨ Script completed!")
+    print("\n💡 Usage:")
+    print("   python add_sample_data.py          # Add sample rumours")
+    print("   python add_sample_data.py test     # Add test rumour for real-time updates")

config.py

@@ -0,0 +1,136 @@
+import os
+from typing import Optional
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    """Configuration class for the Visual Verification Service"""
+    
+    # API Configuration
+    SERP_API_KEY: Optional[str] = os.getenv("SERP_API_KEY")
+    SERPAPI_BASE_URL: str = "https://serpapi.com/search"
+    GEMINI_API_KEY: Optional[str] = os.getenv("GEMINI_API_KEY")
+    GEMINI_MODEL: str = os.getenv("GEMINI_MODEL", "gemini-1.5-flash")
+    GEMINI_TEMPERATURE: float = float(os.getenv("GEMINI_TEMPERATURE", "0.1"))
+    GEMINI_TOP_P: float = float(os.getenv("GEMINI_TOP_P", "0.8"))
+    GEMINI_MAX_TOKENS: int = int(os.getenv("GEMINI_MAX_TOKENS", "1000000"))
+    
+    # Google Custom Search API Configuration (replaces deprecated Fact Check Tools API)
+    GOOGLE_FACT_CHECK_API_KEY: Optional[str] = os.getenv("GOOGLE_FACT_CHECK_API_KEY")
+    GOOGLE_FACT_CHECK_CX: Optional[str] = os.getenv("GOOGLE_FACT_CHECK_CX")
+    
+    # Low-priority (social/UGC) domains to downrank (override via LOW_PRIORITY_DOMAINS)
+    LOW_PRIORITY_DOMAINS: set = set((os.getenv(
+        "LOW_PRIORITY_DOMAINS",
+        ",".join([
+            "twitter.com","www.twitter.com","x.com","www.x.com",
+            "reddit.com","www.reddit.com",
+            "facebook.com","www.facebook.com","m.facebook.com",
+            "instagram.com","www.instagram.com",
+            "tiktok.com","www.tiktok.com",
+            "threads.net","www.threads.net"
+        ])
+    ) or "").split(","))
+    # Analysis thresholds (kept configurable to avoid hardcoding)
+    CONTEXT_SIM_THRESHOLD: float = float(os.getenv("CONTEXT_SIM_THRESHOLD", "0.6"))
+
+    # Streaming downloader (yt-dlp) integration
+    # If true, prefer yt-dlp for any video_url (works for YouTube/Instagram/Twitter/etc.)
+    USE_STREAM_DOWNLOADER: bool = os.getenv("USE_STREAM_DOWNLOADER", "true").lower() == "true"
+    # Binary path for yt-dlp (auto-resolved in code if not absolute)
+    YTDLP_BIN: str = os.getenv("YTDLP_BIN", "yt-dlp")
+    STREAM_DOWNLOAD_TIMEOUT: int = int(os.getenv("STREAM_DOWNLOAD_TIMEOUT", "120"))
+    # Optional comma-separated list of domains to always treat as streaming
+    STREAMING_DOMAINS: str = os.getenv("STREAMING_DOMAINS", "youtube.com,youtu.be,instagram.com,twitter.com,x.com,tiktok.com,facebook.com,fb.watch")
+    
+    # Cloudinary
+    CLOUDINARY_CLOUD_NAME: Optional[str] = os.getenv("CLOUDINARY_CLOUD_NAME")
+    CLOUDINARY_API_KEY: Optional[str] = os.getenv("CLOUDINARY_API_KEY")
+    CLOUDINARY_API_SECRET: Optional[str] = os.getenv("CLOUDINARY_API_SECRET")
+    CLOUDINARY_UPLOAD_PRESET: Optional[str] = os.getenv("CLOUDINARY_UPLOAD_PRESET")
+    CLOUDINARY_FOLDER: str = os.getenv("CLOUDINARY_FOLDER", "frames")
+    
+    # Service Configuration
+    SERVICE_HOST: str = os.getenv("SERVICE_HOST", "0.0.0.0")
+    SERVICE_PORT: int = int(os.getenv("SERVICE_PORT", "8000"))
+    
+    # File Processing Configuration
+    MAX_FILE_SIZE: int = int(os.getenv("MAX_FILE_SIZE", "50")) * 1024 * 1024  # 50MB default
+    ALLOWED_IMAGE_EXTENSIONS: set = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp'}
+    ALLOWED_VIDEO_EXTENSIONS: set = {'.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.m4v'}
+    
+    # Video Processing Configuration
+    FRAME_EXTRACTION_INTERVAL: int = int(os.getenv("FRAME_INTERVAL", "4"))  # seconds
+    MAX_FRAMES_TO_ANALYZE: int = int(os.getenv("MAX_FRAMES", "10"))
+    CLIP_DURATION: int = int(os.getenv("CLIP_DURATION", "5"))  # seconds
+    
+    # Image Processing Configuration
+    COUNTER_MEASURE_WIDTH: int = int(os.getenv("IMAGE_WIDTH", "400"))
+    COUNTER_MEASURE_HEIGHT: int = int(os.getenv("IMAGE_HEIGHT", "300"))
+    
+    # Temporary Storage Configuration
+    TEMP_DIR: str = os.getenv("TEMP_DIR", "/tmp")
+    CLEANUP_INTERVAL: int = int(os.getenv("CLEANUP_INTERVAL", "3600"))  # seconds
+    
+    # Logging Configuration
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FORMAT: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Debug Configuration
+    DEBUG: bool = os.getenv("DEBUG", "false").lower() == "true"
+    
+    # Redis Configuration
+    REDIS_HOST: str = os.getenv("REDIS_HOST", "localhost")
+    REDIS_PORT: int = int(os.getenv("REDIS_PORT", "6379"))
+    REDIS_DB: int = int(os.getenv("REDIS_DB", "0"))
+    REDIS_TTL: int = int(os.getenv("REDIS_TTL", "86400"))  # 24 hours in seconds
+    
+    @classmethod
+    def validate(cls) -> bool:
+        """Validate configuration values"""
+        if not cls.SERP_API_KEY:
+            print("Warning: SERP_API_KEY not set. Service will not function without it.")
+            return False
+        
+        if not cls.GOOGLE_FACT_CHECK_API_KEY:
+            print("Warning: GOOGLE_FACT_CHECK_API_KEY not set. Text fact-checking will not function without it.")
+            return False
+        
+        if not cls.GOOGLE_FACT_CHECK_CX:
+            print("Warning: GOOGLE_FACT_CHECK_CX not set. Text fact-checking will not function without it.")
+            return False
+        
+        if cls.MAX_FILE_SIZE <= 0:
+            print("Error: MAX_FILE_SIZE must be positive")
+            return False
+        
+        if cls.FRAME_EXTRACTION_INTERVAL <= 0:
+            print("Error: FRAME_EXTRACTION_INTERVAL must be positive")
+            return False
+        
+        if cls.CLIP_DURATION <= 0:
+            print("Error: CLIP_DURATION must be positive")
+            return False
+        
+        return True
+    
+    @classmethod
+    def get_allowed_extensions(cls) -> set:
+        """Get all allowed file extensions"""
+        return cls.ALLOWED_IMAGE_EXTENSIONS.union(cls.ALLOWED_VIDEO_EXTENSIONS)
+    
+    @classmethod
+    def is_image_file(cls, filename: str) -> bool:
+        """Check if file is a valid image"""
+        from pathlib import Path
+        return Path(filename).suffix.lower() in cls.ALLOWED_IMAGE_EXTENSIONS
+    
+    @classmethod
+    def is_video_file(cls, filename: str) -> bool:
+        """Check if file is a valid video"""
+        from pathlib import Path
+        return Path(filename).suffix.lower() in cls.ALLOWED_VIDEO_EXTENSIONS
+
+# Global configuration instance
+config = Config()

main.py

@@ -0,0 +1,509 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form, WebSocket, WebSocketDisconnect
+from typing import Optional, List, Dict, Any
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+import os
+import tempfile
+from pathlib import Path
+import asyncio
+import logging
+import json
+
+from services.image_verifier import ImageVerifier
+from services.video_verifier import VideoVerifier
+from services.input_processor import InputProcessor
+from services.text_fact_checker import TextFactChecker
+from services.educational_content_generator import EducationalContentGenerator
+from services.mongodb_service import MongoDBService
+from services.websocket_service import connection_manager, initialize_mongodb_change_stream, cleanup_mongodb_change_stream
+from utils.file_utils import save_upload_file, cleanup_temp_files
+
+app = FastAPI(
+    title="Visual Verification Service",
+    description="A service to verify images/videos and generate visual counter-measures",
+    version="1.0.0"
+)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static directory for local assets (e.g., extracted frames)
+import os
+os.makedirs("public/frames", exist_ok=True)
+app.mount("/static", StaticFiles(directory="public"), name="static")
+
+
+# Initialize verifiers and input processor
+image_verifier = ImageVerifier()
+video_verifier = VideoVerifier()
+input_processor = InputProcessor()
+text_fact_checker = TextFactChecker()
+educational_generator = EducationalContentGenerator()
+
+# Initialize MongoDB service
+mongodb_service = None
+try:
+    mongodb_service = MongoDBService()
+except Exception as e:
+    print(f"Warning: MongoDB service initialization failed: {e}")
+
+# Initialize MongoDB change service (will be set in startup event)
+mongodb_change_service = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize services on startup"""
+    global mongodb_change_service
+    try:
+        mongodb_change_service = await initialize_mongodb_change_stream()
+        logger.info("✅ All services initialized successfully")
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize services: {e}")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup services on shutdown"""
+    try:
+        await cleanup_mongodb_change_stream()
+        logger.info("🧹 All services cleaned up successfully")
+    except Exception as e:
+        logger.error(f"❌ Error during cleanup: {e}")
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket endpoint for real-time updates"""
+    await connection_manager.connect(websocket, {"connected_at": asyncio.get_event_loop().time()})
+    logger.info(f"✅ WebSocket client connected. Total connections: {len(connection_manager.active_connections)}")
+    
+    try:
+        while True:
+            try:
+                # Wait for incoming messages with a timeout
+                data = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+                
+                # Echo back a response (optional)
+                await connection_manager.send_personal_message(
+                    json.dumps({"type": "pong", "message": "Connection active"}), 
+                    websocket
+                )
+            except asyncio.TimeoutError:
+                # Send a ping to keep connection alive
+                await connection_manager.send_personal_message(
+                    json.dumps({"type": "ping", "message": "Keep alive"}), 
+                    websocket
+                )
+            except Exception as e:
+                logger.error(f"❌ Error in WebSocket message handling: {e}")
+                break
+                
+    except WebSocketDisconnect:
+        logger.info("🔌 WebSocket client disconnected normally")
+        connection_manager.disconnect(websocket)
+    except Exception as e:
+        logger.error(f"❌ WebSocket error: {e}")
+        connection_manager.disconnect(websocket)
+
+@app.get("/")
+async def root():
+    return {"message": "Visual Verification Service is running"}
+
+@app.post("/verify/image")
+async def verify_image(
+    file: Optional[UploadFile] = File(None),
+    image_url: Optional[str] = Form(None),
+    claim_context: str = Form("Unknown context"),
+    claim_date: str = Form("Unknown date")
+):
+    """
+    Verify a single image and generate a visual counter-measure
+    """
+    try:
+        # Save uploaded file temporarily
+        temp_file_path = None
+        if file is not None:
+            temp_file_path = await save_upload_file(file)
+        
+        # Verify image
+        result = await image_verifier.verify(
+            image_path=temp_file_path,
+            claim_context=claim_context,
+            claim_date=claim_date,
+            image_url=image_url
+        )
+        
+        # Clean up temp file
+        if temp_file_path:
+            cleanup_temp_files([temp_file_path])
+        
+        return result
+            
+    except Exception as e:
+        # Clean up on error
+        if 'temp_file_path' in locals() and temp_file_path:
+            cleanup_temp_files([temp_file_path])
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/verify/video")
+async def verify_video(
+    file: Optional[UploadFile] = File(None),
+    video_url: Optional[str] = Form(None),
+    claim_context: str = Form("Unknown context"),
+    claim_date: str = Form("Unknown date")
+):
+    """
+    Verify a video and generate a visual counter-measure video
+    """
+    try:
+        # Save uploaded file temporarily
+        temp_file_path = None
+        if file is not None:
+            temp_file_path = await save_upload_file(file)
+        
+        # Verify video
+        result = await video_verifier.verify(
+            video_path=temp_file_path,
+            claim_context=claim_context,
+            claim_date=claim_date,
+            video_url=video_url
+        )
+        
+        # Clean up temp file
+        if temp_file_path:
+            cleanup_temp_files([temp_file_path])
+        
+        return result
+            
+    except Exception as e:
+        # Clean up on error
+        if 'temp_file_path' in locals() and temp_file_path:
+            cleanup_temp_files([temp_file_path])
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/verify/text")
+async def verify_text(
+    text_input: str = Form(...),
+    claim_context: str = Form("Unknown context"),
+    claim_date: str = Form("Unknown date")
+):
+    """
+    Verify a textual claim using Google's Fact Check Tools API
+    """
+    try:
+        # Verify text claim
+        result = await text_fact_checker.verify(
+            text_input=text_input,
+            claim_context=claim_context,
+            claim_date=claim_date
+        )
+        
+        return result
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/chatbot/verify")
+async def chatbot_verify(
+    text_input: Optional[str] = Form(None),
+    files: Optional[List[UploadFile]] = File(None)
+):
+    """
+    Chatbot-friendly endpoint that intelligently processes input and routes to appropriate verification
+    """
+    try:
+        # Process input with LLM
+        processed_input = await input_processor.process_input(
+            text_input=text_input,
+            files=files
+        )
+        
+        if "error" in processed_input:
+            return {"error": processed_input["error"]}
+        
+        verification_type = processed_input["verification_type"]
+        content = processed_input["content"]
+        claim_context = processed_input["claim_context"]
+        claim_date = processed_input["claim_date"]
+        
+        results = []
+        temp_files_to_cleanup = []
+        
+        # Handle text-only verification
+        if verification_type == "text" and content.get("text"):
+            result = await text_fact_checker.verify(
+                text_input=content["text"],
+                claim_context=claim_context,
+                claim_date=claim_date
+            )
+            result["source"] = "text_input"
+            results.append(result)
+        
+        # Process files if any
+        for file_path in content["files"]:
+            temp_files_to_cleanup.append(file_path)
+            
+            if verification_type == "image":
+                result = await image_verifier.verify(
+                    image_path=file_path,
+                    claim_context=claim_context,
+                    claim_date=claim_date
+                )
+            else:  # video
+                result = await video_verifier.verify(
+                    video_path=file_path,
+                    claim_context=claim_context,
+                    claim_date=claim_date
+                )
+            
+            result["source"] = "uploaded_file"
+            results.append(result)
+        
+        # Process URLs if any
+        for url in content["urls"]:
+            if verification_type == "image":
+                result = await image_verifier.verify(
+                    image_url=url,
+                    claim_context=claim_context,
+                    claim_date=claim_date
+                )
+            else:  # video
+                result = await video_verifier.verify(
+                    video_url=url,
+                    claim_context=claim_context,
+                    claim_date=claim_date
+                )
+            
+            result["source"] = "url"
+            results.append(result)
+        
+        # Clean up temp files
+        if temp_files_to_cleanup:
+            input_processor.cleanup_temp_files(temp_files_to_cleanup)
+        
+        # Build a single concise chatbot message
+        overall = _aggregate_verdicts(results)
+        # Prefer consolidated video summary when present, else per-item message
+        candidates: List[str] = []
+        for r in results:
+            if isinstance(r, dict):
+                details = r.get("details") or {}
+                if isinstance(details, dict) and details.get("overall_summary"):
+                    candidates.append(str(details.get("overall_summary")))
+                elif r.get("message"):
+                    candidates.append(str(r.get("message")))
+        best_msg = max(candidates, key=len) if candidates else ""
+        # Avoid duplication by detecting if clarification already begins with a verdict phrase
+        verdict_prefixes = [
+            "this claim is true:",
+            "this claim is false:",
+            "this claim is uncertain:",
+            "this claim has mixed evidence:",
+            "the claim is true:",
+            "the claim is false:",
+            "the claim is uncertain:",
+            "result:",
+        ]
+        prefix_map = {
+            "true": "This claim is true:",
+            "false": "This claim is false:",
+            "uncertain": "This claim is uncertain:",
+            "mixed": "This claim has mixed evidence:",
+            "no_content": "No verifiable content found:",
+        }
+        prefix = prefix_map.get(overall, "Result:")
+        lower_msg = (best_msg or "").strip().lower()
+        if best_msg and any(lower_msg.startswith(p) for p in verdict_prefixes):
+            final_message = best_msg.strip()
+        else:
+            final_message = f"{prefix} {best_msg}" if best_msg else prefix
+        return {
+            "message": final_message,
+            "verdict": overall,
+            "details": {
+                "results": results,
+                "verification_type": verification_type,
+                "claim_context": claim_context,
+                "claim_date": claim_date
+            }
+        }
+            
+    except Exception as e:
+        # Clean up any temp files on error
+        if 'temp_files_to_cleanup' in locals():
+            input_processor.cleanup_temp_files(temp_files_to_cleanup)
+        raise HTTPException(status_code=500, detail=str(e))
+
+def _aggregate_verdicts(results: List[Dict]) -> str:
+    """Aggregate individual verification results into overall verdict.
+
+    Supports image results (with 'verdict'), video results (with details.overall_verdict), 
+    and text results (with 'verdict').
+    """
+    if not results:
+        return "no_content"
+    
+    normalized: List[str] = []
+    for r in results:
+        # Prefer explicit boolean 'verified' if present
+        if "verified" in r and isinstance(r.get("verified"), bool):
+            v = "true" if r.get("verified") else "false"
+        else:
+            v = r.get("verdict")
+        if not v:
+            details = r.get("details") or {}
+            v = details.get("overall_verdict")
+        normalized.append((v or "unknown").lower())
+    
+    # If any false, overall is false
+    if "false" in normalized:
+        return "false"
+    
+    # If any uncertain, overall is uncertain
+    if "uncertain" in normalized:
+        return "uncertain"
+    
+    # If all true, overall is true
+    if all(v == "true" for v in normalized):
+        return "true"
+    
+    return "mixed"
+
+@app.get("/mongodb/recent-posts")
+async def get_recent_debunk_posts(limit: int = 5):
+    """
+    Get recent debunk posts from MongoDB
+    
+    Args:
+        limit: Maximum number of posts to return (default: 5)
+        
+    Returns:
+        List of recent debunk posts
+    """
+    try:
+        print(f"🔍 DEBUG: Endpoint called with limit={limit}")
+        print(f"🔍 DEBUG: MongoDB service available: {mongodb_service is not None}")
+        
+        if not mongodb_service:
+            print("❌ DEBUG: MongoDB service is None!")
+            raise HTTPException(
+                status_code=503, 
+                detail="MongoDB service is not available. Check MONGO_CONNECTION_STRING environment variable."
+            )
+        
+        print("🔍 DEBUG: Calling mongodb_service.get_recent_posts()")
+        posts = mongodb_service.get_recent_posts(limit)
+        print(f"🔍 DEBUG: Service returned {len(posts)} posts")
+        
+        if posts:
+            print(f"🔍 DEBUG: First post keys: {list(posts[0].keys())}")
+            print(f"🔍 DEBUG: First post _id: {posts[0].get('_id')}")
+        else:
+            print("⚠️ DEBUG: No posts returned from service")
+        
+        result = {
+            "success": True,
+            "count": len(posts),
+            "posts": posts
+        }
+        
+        print(f"🔍 DEBUG: Returning result with {len(posts)} posts")
+        return result
+        
+    except Exception as e:
+        print(f"❌ DEBUG: Exception in endpoint: {e}")
+        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "service": "visual-verification"}
+
+
+# Educational Content API Endpoints
+@app.get("/educational/modules")
+async def get_educational_modules():
+    """Get list of available educational modules"""
+    try:
+        modules_data = await educational_generator.get_modules_list()
+        return modules_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/educational/modules/{module_id}")
+async def get_module_content(
+    module_id: str,
+    difficulty_level: str = "beginner"
+):
+    """Get educational content for a specific module"""
+    try:
+        content = await educational_generator.generate_module_content(
+            module_id, difficulty_level
+        )
+        return content
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/educational/contextual-learning")
+async def get_contextual_learning(verification_result: Dict[str, Any]):
+    """Generate educational content based on verification result"""
+    try:
+        content = await educational_generator.generate_contextual_learning(
+            verification_result
+        )
+        return content
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/educational/clear-cache")
+async def clear_educational_cache():
+    """Clear all educational content from Redis cache"""
+    try:
+        if educational_generator.redis_client:
+            # Get all educational cache keys
+            keys = educational_generator.redis_client.keys("educational:*")
+            if keys:
+                educational_generator.redis_client.delete(*keys)
+                return {"message": f"Cleared {len(keys)} cache entries", "keys": keys}
+            else:
+                return {"message": "No cache entries found"}
+        else:
+            return {"message": "Redis not available"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/educational/cache-status")
+async def get_cache_status():
+    """Get status of educational content cache"""
+    try:
+        if educational_generator.redis_client:
+            keys = educational_generator.redis_client.keys("educational:*")
+            cache_info = {}
+            for key in keys:
+                ttl = educational_generator.redis_client.ttl(key)
+                cache_info[key] = {
+                    "ttl": ttl,
+                    "exists": ttl > 0
+                }
+            return {
+                "redis_connected": True,
+                "total_keys": len(keys),
+                "cache_info": cache_info
+            }
+        else:
+            return {"redis_connected": False, "message": "Redis not available"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)