Delete model files to prevent Binary files

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,21 @@
+# syntax=docker/dockerfile:1.7-labs
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm
+
+# App directory
+WORKDIR /app
+
+# Install dependencies with uv (uses cache for speed)
+COPY pyproject.toml ./
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --no-dev --python /usr/local/bin/python3
+
+# Copy the rest of the project
+COPY . .
+
+# Ensure uv uses the project virtualenv
+ENV UV_PROJECT_ENVIRONMENT=/app/.venv
+
+EXPOSE 7860
+
+# Start the FastAPI app
+CMD ["uv", "run", "main.py"]

README.md

@@ -0,0 +1,75 @@
+# Model FastAPI
+
+FastAPI service that provides two capabilities:
+
+- Deepfake image detection using a SigLIP image-classification backbone with a LoRA adapter.
+- A news-aware chatbot that selectively performs web search via Tavily and responds with verified sources when evidence is found.
+
+## Project Layout
+
+- main app entry: main.py
+- Deepfake detector: app/detector.py, app/core/detector/_, app/services/detector/_, model/output/siglip-lora-optimized/
+- Chatbot: app/chatbot.py, app/core/chatbot/_, app/services/chatbot/_, app/schemas/chat.py
+- Database migration (chat history table): supabase/migrations/
+
+## Requirements
+
+- Python 3.13+
+- uv package manager (https://docs.astral.sh/uv/)
+- Access to the SigLIP base model and the LoRA adapter stored at model/output/siglip-lora-optimized/
+
+## Environment Variables
+
+- DATABASE_URL (or SUPABASE_DATABASE_URL): PostgreSQL connection string for chat history (if save_to_db=true).
+- GROQ_API_KEY: required by the Groq LLM used for responses.
+- OPENROUTER_API_KEY: required by the OpenRouter model used for classification/query rewriting.
+- TAVILY_API_KEY: required for Tavily search.
+- Optional: set CUDA-visible devices as needed for GPU inference.
+
+## Setup (local)
+
+```bash
+uv sync
+uv run main.py  # starts FastAPI on 0.0.0.0:7860
+```
+
+The detector will load the SigLIP base model and apply the LoRA adapter from model/output/siglip-lora-optimized/.
+
+## API
+
+- POST /detect
+  - Form-data file field: file (image). Returns predicted_class (index), predicted_label (from id2label), prediction (real/fake thresholded at P(real) >= 0.90), confidence, and class probabilities.
+- POST /chat
+  - JSON: {"query": "...", "session_id": "optional", "save_to_db": true|false}
+  - Auto-classifies need for search, optionally queries Tavily, then responds. Returns response.content, session_id, used_search, and search_reason.
+- DELETE /chat/{session_id}
+  - Clears chat history (both in-memory guest sessions and DB rows).
+
+### Quick cURL examples
+
+```bash
+# Deepfake detection
+curl -X POST "http://localhost:7860/detect" \
+  -F "file=@path/to/image.jpg"
+
+# Chat (without forcing search decision)
+curl -X POST "http://localhost:7860/chat" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "Is the latest SpaceX launch successful?", "save_to_db": false}'
+```
+
+## Docker
+
+A Dockerfile is provided using the uv base image.
+
+```bash
+docker build -t model-fast-api .
+docker run -p 7860:7860 --env-file .env model-fast-api
+```
+
+The image installs dependencies with uv sync and runs `uv run main.py`.
+
+## Notes
+
+- The news verification prompt only returns source links when the claim is supported by the retrieved results; otherwise it replies with UNDETERMINED and no links.
+- If chat history persistence is disabled (save_to_db=false), sessions are stored in-memory.

app/chatbot.py

@@ -0,0 +1,138 @@
+"""
+Chatbot API routes.
+"""
+
+import logging
+from uuid import uuid4
+
+from fastapi import APIRouter, Depends, HTTPException
+from psycopg import Connection
+from langchain_core.runnables.history import RunnableWithMessageHistory
+from langchain_tavily import TavilySearch
+
+from app.core.chatbot.config import CHAT_HISTORY_TABLE
+from app.core.chatbot.chains import general_chain, news_chain
+from app.core.chatbot.database import db_connection_dependency
+from app.schemas.chat import ChatRequest
+from app.services.chatbot.history import delete_guest_session, get_message_history
+from app.services.chatbot.search import (
+    extract_search_query,
+    format_search_results,
+    get_tavily_search,
+    should_use_search,
+)
+
+logger = logging.getLogger(__name__)
+
+chat = APIRouter()
+
+
+@chat.post("/chat")
+async def chat_endpoint(
+    request: ChatRequest,
+    tavily_search: TavilySearch = Depends(get_tavily_search),
+):
+    """
+    Chat endpoint with intelligent query processing.
+
+    Flow:
+    1. LLM classifies if query needs web search
+    2. If NO search needed -> respond directly with LLM knowledge
+    3. If search needed -> extract optimized search query -> search with Tavily -> respond with sources
+
+    Returns:
+        response: The LLM's response
+        session_id: Session ID for conversation history
+        used_search: Whether web search was used
+        search_reason: Why search was/wasn't used
+    """
+    try:
+        # Ensure every session has an id for history tracking (DB or in-memory)
+        session_id = request.session_id or str(uuid4())
+        save_to_db = request.save_to_db
+
+        # Step 1: LLM decides if search is needed
+        needs_search, search_reason = should_use_search(request.query)
+        logger.info("Search needed: %s, Reason: %s", needs_search, search_reason)
+
+        def get_history(sid: str):
+            return get_message_history(sid, save_to_db)
+
+        # Step 2: Take appropriate path
+        if not needs_search:
+            # Respond directly without search
+            chain_with_history = RunnableWithMessageHistory(
+                general_chain,
+                get_history,
+                input_messages_key="question",
+                history_messages_key="chat_history",
+            )
+            response = chain_with_history.invoke(
+                {"question": request.query},
+                config={"configurable": {"session_id": session_id}},
+            )
+        else:
+            # Step 2a: Extract optimized search query
+            optimized_query = extract_search_query(request.query)
+            logger.info("Optimized search query: %s", optimized_query)
+            # Step 2b: Search with optimized query
+            search_results = tavily_search.invoke(optimized_query)
+            formatted_results = format_search_results(search_results)
+            logger.debug("Search results: %s", search_results)
+
+            # Step 2c: Respond with sources
+            chain_with_history = RunnableWithMessageHistory(
+                news_chain,
+                get_history,
+                input_messages_key="question",
+                history_messages_key="chat_history",
+            )
+            response = chain_with_history.invoke(
+                {
+                    "question": request.query,
+                    "search_results": formatted_results,
+                },
+                config={"configurable": {"session_id": session_id}},
+            )
+
+            logger.debug("Response: %s", response.content)
+
+        return {
+            "response": {
+                "content": response.content,
+            },
+            "session_id": session_id,
+            "used_search": needs_search,
+            "search_reason": search_reason,
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:  # pragma: no cover - defensive server guard
+        logger.exception("Unhandled error in chat_endpoint")
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@chat.delete("/chat/{session_id}")
+async def delete_chat_history(session_id: str, conn: Connection = Depends(db_connection_dependency)):
+    """Delete chat history for a specific session."""
+    try:
+        # Delete from in-memory guest sessions
+        delete_guest_session(session_id)
+
+        # Delete from database
+        with conn.cursor() as cursor:
+            cursor.execute(
+                f'DELETE FROM "{CHAT_HISTORY_TABLE}" WHERE session_id = %s',
+                (session_id,),
+            )
+            deleted_count = cursor.rowcount
+            conn.commit()
+
+        return {
+            "success": True,
+            "deleted_count": deleted_count,
+            "session_id": session_id,
+        }
+    except Exception as e:
+        logger.exception("Error in delete_chat_history")
+        raise HTTPException(status_code=500, detail=str(e))

app/core/chatbot/chains.py

@@ -0,0 +1,23 @@
+"""
+LangChain chain definitions.
+"""
+
+from app.core.chatbot.llm import classify_query_llm, construct_query_llm, response_llm
+from app.core.chatbot.prompt_templates import (
+    classification_prompt,
+    search_query_prompt,
+    general_prompt,
+    news_verification_prompt,
+)
+
+# Chain for classifying if a query needs web search
+classification_chain = classification_prompt | construct_query_llm
+
+# Chain for extracting optimized search queries
+search_query_chain = search_query_prompt | construct_query_llm
+
+# Chain for general responses (no search)
+general_chain = general_prompt | response_llm
+
+# Chain for news verification responses (with search results)
+news_chain = news_verification_prompt | response_llm

app/core/chatbot/config.py

@@ -0,0 +1,19 @@
+"""
+Configuration module for environment variables and database settings.
+"""
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+# Database connection string
+DATABASE_URL = os.getenv("DATABASE_URL") or os.getenv("SUPABASE_DATABASE_URL")
+
+if not DATABASE_URL:
+    raise ValueError(
+        "DATABASE_URL or SUPABASE_DATABASE_URL environment variable is required"
+    )
+
+# Table name for chat history
+CHAT_HISTORY_TABLE = "chat_history"

app/core/chatbot/database.py

@@ -0,0 +1,41 @@
+"""
+Database utilities for chat history.
+"""
+
+from typing import Iterator
+
+from psycopg_pool import ConnectionPool
+
+from app.core.chatbot.config import DATABASE_URL
+
+# Connection pool for efficient connection management
+# min_size=1 keeps at least 1 connection ready
+# max_size=10 limits concurrent connections
+_connection_pool = None
+
+
+def get_connection_pool() -> ConnectionPool:
+    """Get or create the connection pool (lazy initialization)."""
+
+    global _connection_pool
+    if _connection_pool is None:
+        _connection_pool = ConnectionPool(
+            DATABASE_URL,
+            min_size=1,
+            max_size=10,
+            kwargs={"connect_timeout": 10},
+        )
+    return _connection_pool
+
+
+def get_db_connection():
+    """Get a database connection from the pool."""
+
+    return get_connection_pool().connection()
+
+
+def db_connection_dependency() -> Iterator:
+    """FastAPI dependency that yields a pooled DB connection."""
+
+    with get_db_connection() as conn:
+        yield conn

app/core/chatbot/llm.py

@@ -0,0 +1,42 @@
+"""
+LLM client initialization module.
+"""
+
+import os
+
+# from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+
+
+# LLM for constructing optimized search querie
+construct_query_llm = ChatOpenAI(
+    model="xiaomi/mimo-v2-flash:free",
+    api_key=os.getenv("OPENROUTER_API_KEY"),
+    base_url="https://openrouter.ai/api/v1",
+)
+
+# Main LLM for generating responses
+response_llm = ChatGroq(
+    model="meta-llama/llama-4-scout-17b-16e-instruct",
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+)
+
+# Set classify_query_llm to reuse construct_query_llm
+classify_query_llm = construct_query_llm
+
+
+class LLMService:
+    """
+    LLM Service class to encapsulate LLM clients.
+    """
+
+    def __init__(self):
+        self.models = {
+            "construct_query_llm": construct_query_llm,
+            "response_llm": response_llm,
+            "classify_query_llm": classify_query_llm,
+        }

app/core/chatbot/prompt_templates.py

@@ -0,0 +1,109 @@
+"""
+Prompt templates for the chatbot.
+"""
+
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+# Prompt to classify if query needs web search
+classification_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are a query classifier. Analyze the user's input and determine if it requires searching the web for verification or current information.
+
+Return ONLY a JSON object in this exact format:
+{{"needs_search": true/false, "reason": "brief explanation"}}
+
+Set needs_search to TRUE if:
+- Query asks about recent news, current events, or breaking stories
+- Query asks to verify/fact-check a claim or statement
+- Query mentions specific dates, "today", "yesterday", "this week", etc.
+- Query asks about something that may have changed recently
+- User makes a statement of fact about current events that you cannot verify from your training data
+- User claims something happened recently (appointments, elections, announcements, etc.)
+- The statement contains specific names, positions, or events you're unsure about
+
+Set needs_search to FALSE if:
+- Query is a greeting (e.g., "Hello", "Hi", "Good morning")
+- Query is a personal introduction or statement about themselves (e.g., "My name is...", "I am a developer")
+- Query is about general knowledge, concepts, or definitions that don't change
+- Query asks about well-established historical facts (before 2024)
+- Query is about how things work, explanations, or tutorials
+- Query is personal advice, opinions, or hypothetical scenarios
+
+Examples:
+- "My name is John" -> {{"needs_search": false, "reason": "User personal introduction"}}
+- "Hello, who are you?" -> {{"needs_search": false, "reason": "Greeting/Chitchat"}}
+- "Is it true that SpaceX launched yesterday?" -> {{"needs_search": true, "reason": "Recent event needs verification"}}
+- "What is photosynthesis?" -> {{"needs_search": false, "reason": "General scientific knowledge"}}
+- "Abu Bakar Hamzah was appointed as menteri besar of Perlis" -> {{"needs_search": true, "reason": "Statement about political appointment needs verification"}}
+- "Trump won the 2024 election" -> {{"needs_search": true, "reason": "Recent political event needs verification"}}
+- "The earth orbits the sun" -> {{"needs_search": false, "reason": "Established scientific fact"}}""",
+        ),
+        ("human", "{question}"),
+    ]
+)
+
+# Prompt to extract search query from user's question
+search_query_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are a search query extractor. Given a user's question about news or current events, extract the key facts and create an optimal search query.
+
+Your task:
+1. Identify the key entities (people, places, organizations, events)
+2. Remove unnecessary words like "Is it true that", "Did", "Has", etc.
+3. Create a concise, focused search query that will find relevant news articles
+
+Return ONLY a JSON object in this exact format:
+{{"search_query": "the optimized search query"}}
+
+Examples:
+- "Is the news true that Biden signed a new climate bill?" -> {{"search_query": "Biden climate bill signed"}}
+- "Did SpaceX successfully launch Starship yesterday?" -> {{"search_query": "SpaceX Starship launch"}}
+- "Is it true that Apple announced a new iPhone model?" -> {{"search_query": "Apple new iPhone announcement"}}
+- "Is the news true, Bersatu's Kuala Perlis assemblyman Abu Bakar Hamzah appointed as 12th menteri besar of Perlis?" -> {{"search_query": "Abu Bakar Hamzah menteri besar Perlis"}}""",
+        ),
+        ("human", "{question}"),
+    ]
+)
+
+# General response prompt (when no search needed)
+general_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are a helpful assistant. Answer the user's question based on your knowledge. 
+Be informative and accurate. If you're not sure about something, say so.""",
+        ),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("human", "{question}"),
+    ]
+)
+
+# News verification prompt (when search results are used)
+news_verification_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """You are a helpful news verification assistant. Analyze the search results to answer the user's query.
+
+When responding:
+- Use the search results to provide accurate, up-to-date information.
+- Only include source links when the claim is matched and clearly supported by the search results.
+- If the claim cannot be confirmed with recent or credible information, respond with exactly: UNDETERMINED, and do not include any sources.
+- Be clear and cite your sources with URLs only when the information is confirmed.""",
+        ),
+        MessagesPlaceholder(variable_name="chat_history"),
+        (
+            "human",
+            """User's query: {question}
+
+Search results:
+{search_results}
+
+Respond based on these search results.""",
+        ),
+    ]
+)

app/core/detector/config.py

@@ -0,0 +1,20 @@
+"""
+Detector configuration - device settings, model paths, and thresholds.
+"""
+
+import torch
+import warnings
+
+warnings.filterwarnings("ignore")
+
+# Check for GPU availability
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {DEVICE}")
+if torch.cuda.is_available():
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
+
+# Model configuration
+BASE_MODEL_NAME = "shunda012/siglip-deepfake-detector"
+
+# Prediction threshold
+REAL_THRESHOLD = 0.90  # classify as real only when P(real) >= 90%

app/core/detector/model.py

@@ -0,0 +1,47 @@
+"""
+Model loading for the deepfake detector.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from transformers import AutoImageProcessor, SiglipForImageClassification
+
+from app.core.detector.config import BASE_MODEL_NAME, DEVICE
+
+
+@dataclass(frozen=True)
+class SiglipResources:
+    """Container for the SigLIP model and processor."""
+
+    model: SiglipForImageClassification
+    processor: AutoImageProcessor
+
+
+_siglip_resources: Optional[SiglipResources] = None
+
+
+def get_siglip_model() -> SiglipResources:
+    """
+    Get or load the merged SigLIP detector model.
+
+    Returns:
+        SiglipResources: Loaded model and processor (cached singleton).
+    """
+
+    global _siglip_resources
+
+    if _siglip_resources is None:
+        print("Loading SigLIP Model...")
+
+        siglip_processor = AutoImageProcessor.from_pretrained(BASE_MODEL_NAME)
+        siglip_model = SiglipForImageClassification.from_pretrained(BASE_MODEL_NAME)
+        siglip_model = siglip_model.to(DEVICE)
+        siglip_model.eval()
+
+        _siglip_resources = SiglipResources(
+            model=siglip_model,
+            processor=siglip_processor,
+        )
+
+    return _siglip_resources

app/detector.py

@@ -0,0 +1,61 @@
+"""
+Detector API routes.
+"""
+
+import logging
+from functools import lru_cache
+from io import BytesIO
+
+from typing import Callable
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+from PIL import Image, UnidentifiedImageError
+
+from app.core.detector.model import SiglipResources, get_siglip_model
+from app.services.detector.prediction import predict_single_image
+from app.services.detector.transforms import get_eval_transforms
+
+detector = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=1)
+def get_siglip_transforms():
+    """Build and cache SigLIP evaluation transforms once per process."""
+
+    resources = get_siglip_model()
+    return get_eval_transforms(resources.processor, "siglip")
+
+
+@detector.post("/detect")
+async def detect_deepfake(
+    file: UploadFile = File(...),
+    resources: SiglipResources = Depends(get_siglip_model),
+    siglip_transforms: Callable = Depends(get_siglip_transforms),
+):
+    """
+    Detect if an image is a deepfake or real using SigLIP + LoRA model.
+
+    Args:
+        file: Uploaded image file
+
+    Returns:
+        JSON response with prediction results
+    """
+
+    try:
+        image_bytes = await file.read()
+        image = Image.open(BytesIO(image_bytes)).convert("RGB")
+
+        result = predict_single_image(
+            image, resources.model, siglip_transforms, "SigLIP + LoRA"
+        )
+
+        return result
+    except UnidentifiedImageError:
+        raise HTTPException(status_code=422, detail="Invalid or unsupported image file")
+    except HTTPException:
+        raise
+    except Exception as exc:  # pragma: no cover - defensive server guard
+        logger.exception("Unhandled error during deepfake detection")
+        raise HTTPException(status_code=500, detail="Error processing image") from exc

app/schemas/chat.py

@@ -0,0 +1,28 @@
+"""
+Pydantic models for chat API.
+"""
+
+from pydantic import BaseModel
+from typing import Optional
+
+
+class ChatRequest(BaseModel):
+    """Request model for the chat endpoint."""
+    query: str
+    session_id: Optional[str] = None
+    save_to_db: bool = True
+
+
+class ChatResponse(BaseModel):
+    """Response model for the chat endpoint."""
+    response: dict
+    session_id: Optional[str]
+    used_search: bool
+    search_reason: str
+
+
+class DeleteResponse(BaseModel):
+    """Response model for the delete endpoint."""
+    success: bool
+    deleted_count: int
+    session_id: str

app/services/chatbot/history.py

@@ -0,0 +1,58 @@
+"""
+Session and message history management.
+"""
+
+from langchain_postgres import PostgresChatMessageHistory
+from langchain_core.chat_history import InMemoryChatMessageHistory
+from app.core.chatbot.config import DATABASE_URL, CHAT_HISTORY_TABLE
+from app.core.chatbot.database import get_connection_pool
+
+# In-memory store for guest sessions
+guest_sessions: dict[str, InMemoryChatMessageHistory] = {}
+
+
+def get_message_history(session_id: str, save_to_db: bool = True):
+    """
+    Get message history for a session.
+
+    Args:
+        session_id: The session identifier
+        save_to_db: If True, use PostgreSQL storage; if False, use in-memory storage
+
+    Returns:
+        Message history instance (PostgresChatMessageHistory or InMemoryChatMessageHistory)
+
+    Note:
+        For PostgreSQL storage, the connection is managed by the connection pool.
+        The PostgresChatMessageHistory will use a pooled connection that is
+        properly returned to the pool when done.
+    """
+    if save_to_db:
+        # Get a connection from the pool
+        # The pool manages the connection lifecycle
+        pool = get_connection_pool()
+        return PostgresChatMessageHistory(
+            CHAT_HISTORY_TABLE,
+            session_id,
+            sync_connection=pool,  # Pool handles connection management
+        )
+    else:
+        if session_id not in guest_sessions:
+            guest_sessions[session_id] = InMemoryChatMessageHistory()
+        return guest_sessions[session_id]
+
+
+def delete_guest_session(session_id: str) -> bool:
+    """
+    Delete a guest session from in-memory storage.
+
+    Args:
+        session_id: The session identifier
+
+    Returns:
+        True if session was deleted, False if it didn't exist
+    """
+    if session_id in guest_sessions:
+        del guest_sessions[session_id]
+        return True
+    return False

app/services/chatbot/search.py

@@ -0,0 +1,147 @@
+"""
+Search utilities for Tavily integration and query processing.
+"""
+
+import json
+from functools import lru_cache
+
+from langchain_tavily import TavilySearch
+
+from app.core.chatbot.chains import classification_chain, search_query_chain
+
+
+@lru_cache(maxsize=1)
+def get_tavily_search() -> TavilySearch:
+    """Get or create Tavily Search instance (process-wide cache)."""
+
+    return TavilySearch(
+        max_results=3,
+        topic="general",
+        include_answer=None,
+        search_depth="basic",
+    )
+
+
+def should_use_search(query: str) -> tuple[bool, str]:
+    """
+    Use LLM to decide if query needs web search.
+
+    Args:
+        query: The user's query
+
+    Returns:
+        Tuple of (needs_search: bool, reason: str)
+    """
+    # Quick pre-check for simple greetings (no LLM needed)
+    simple_patterns = [
+        "hi",
+        "hello",
+        "hey",
+        "good morning",
+        "good afternoon",
+        "good evening",
+        "good night",
+        "thanks",
+        "thank you",
+        "bye",
+        "goodbye",
+        "ok",
+        "okay",
+        "yes",
+        "no",
+        "sure",
+        "help",
+        "what can you do",
+        "who are you",
+    ]
+    query_lower = query.lower().strip()
+
+    # Check if query is a simple greeting or short phrase
+    if query_lower in simple_patterns or len(query_lower) < 5:
+        return False, "Simple greeting or short phrase"
+
+    # Check if starts with common greeting words
+    greeting_starters = ["hi ", "hello ", "hey ", "thanks ", "thank you"]
+    for starter in greeting_starters:
+        if query_lower.startswith(starter) and len(query_lower) < 30:
+            return False, "Greeting message"
+
+    try:
+        response = classification_chain.invoke({"question": query})
+        content = response.content.strip()
+
+        # Extract JSON from response (handle markdown code blocks)
+        if "```" in content:
+            content = content.split("```")[1]
+            if content.startswith("json"):
+                content = content[4:]
+
+        result = json.loads(content)
+        needs_search = result.get("needs_search", False)
+        reason = result.get("reason", "")
+        return needs_search, reason
+    except Exception as e:
+        print(f"Classification error: {e}")
+        # Default to NOT searching if classification fails (safer for simple queries)
+        return False, "Classification failed, defaulting to no search"
+
+
+def extract_search_query(query: str) -> str:
+    """
+    Use LLM to extract an optimized search query from user's question.
+
+    Args:
+        query: The user's original query
+
+    Returns:
+        Optimized search query string
+    """
+    try:
+        response = search_query_chain.invoke({"question": query})
+        content = response.content.strip()
+
+        # Extract JSON from response (handle markdown code blocks)
+        if "```" in content:
+            content = content.split("```")[1]
+            if content.startswith("json"):
+                content = content[4:]
+
+        result = json.loads(content)
+        search_query = result.get("search_query", query)
+        print(f"Extracted search query: {search_query}")
+        return search_query
+    except Exception as e:
+        print(f"Search query extraction error: {e}")
+        # Fall back to original query
+        return query
+
+
+def format_search_results(search_results) -> str:
+    """
+    Format Tavily search results for the LLM prompt.
+
+    Args:
+        search_results: Raw search results from Tavily
+
+    Returns:
+        Formatted string of search results
+    """
+    formatted = ""
+
+    if isinstance(search_results, dict):
+        if "answer" in search_results and search_results["answer"]:
+            formatted += f"Summary: {search_results['answer']}\n\n"
+
+        if "results" in search_results:
+            formatted += "Sources:\n"
+            for i, result in enumerate(search_results["results"], 1):
+                formatted += f"\n{i}. {result.get('title', 'No title')}\n"
+                formatted += f"   URL: {result.get('url', 'No URL')}\n"
+                formatted += f"   Content: {result.get('content', 'No content')}\n"
+    elif isinstance(search_results, str):
+        formatted = search_results
+
+    if not formatted.strip():
+        formatted = "No relevant search results found."
+
+    return formatted

app/services/detector/prediction.py

@@ -0,0 +1,59 @@
+"""
+Prediction logic for the deepfake detector.
+"""
+
+import torch
+from app.core.detector.config import DEVICE, REAL_THRESHOLD
+
+
+def predict_single_image(image, model, transforms, model_name="Model"):
+    """
+    Predict whether a single image is real or fake using a strict real-probability threshold.
+
+    Args:
+        image: PIL Image object
+        model: The PyTorch model to use
+        transforms: Image transforms to apply
+        model_name: Name of the model for display
+
+    Returns:
+        Dictionary with prediction result and confidence
+    """
+    # Load and preprocess image
+    pixel_values = transforms(image).unsqueeze(0).to(DEVICE)
+
+    # Run inference
+    model.eval()
+    with torch.no_grad():
+        outputs = model(pixel_values)
+        logits = outputs.logits
+        predicted_class = torch.argmax(logits, dim=1).item()
+        label = model.config.id2label[predicted_class]
+        probs = torch.softmax(logits, dim=-1)
+        fake_prob = probs[0][0].item()
+        real_prob = probs[0][1].item()
+
+    # Apply threshold rule: only label real if real_prob >= 90%
+    formatted_prediction = "real" if real_prob >= REAL_THRESHOLD else "fake"
+    confidence = real_prob if formatted_prediction == "real" else fake_prob
+
+    # Display results
+    print(f"\n{'='*50}")
+    print(f"Prediction Results ({model_name})")
+    print(f"{'='*50}")
+    print(f"Threshold rule: real if P(real) >= {REAL_THRESHOLD:.0%}")
+    print(f"Prediction: {formatted_prediction.upper()}")
+    print(f"Confidence: {confidence:.2%}")
+    print(f"Predicted class: {predicted_class} ({label})")
+    print(f"{'='*50}")
+    print(f"\nClass Probabilities:")
+    print(f"  Fake: {fake_prob:.2%}")
+    print(f"  Real: {real_prob:.2%}")
+
+    return {
+        "formatted_prediction": formatted_prediction,
+        "predicted_class": predicted_class,
+        "predicted_label": label,
+        "confidence": confidence,
+        "probabilities": {"fake": fake_prob, "real": real_prob},
+    }

app/services/detector/transforms.py

@@ -0,0 +1,31 @@
+"""
+Image transforms for the deepfake detector.
+"""
+
+from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
+
+
+def get_eval_transforms(processor, model_type="vit"):
+    """
+    Create evaluation transforms based on processor settings.
+    
+    Args:
+        processor: The image processor from the model
+        model_type: Type of model ("vit" or "siglip")
+        
+    Returns:
+        Composed transforms for image preprocessing
+    """
+    size = processor.size["height"]
+    image_mean = processor.image_mean
+    image_std = processor.image_std
+    normalize = Normalize(mean=image_mean, std=image_std)
+    
+    return Compose(
+        [
+            Resize(size if model_type == "siglip" else 256),
+            CenterCrop(size),
+            ToTensor(),
+            normalize,
+        ]
+    )

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

main.py

@@ -0,0 +1,24 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+
+from app.detector import detector
+from app.chatbot import chat
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://127.0.0.1:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(detector, tags=["deepfake detector api"])
+app.include_router(chat, tags=["chat api"])
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)
+

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "model-fast-api"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.118.0",
+    "langchain>=0.3.27",
+    "langchain-community>=0.3.31",
+    "langchain-deepseek>=1.0.1",
+    "langchain-google-genai>=2.1.12",
+    "langchain-groq>=1.1.1",
+    "langchain-postgres>=0.0.15",
+    "langchain-tavily>=0.1.0",
+    "peft>=0.18.0",
+    "pillow>=11.0.0",
+    "protobuf>=6.32.1",
+    "psycopg>=3.2.10",
+    "psycopg-binary>=3.2.10",
+    "psycopg-pool>=3.2.6",
+    "python-dotenv>=1.1.1",
+    "python-multipart>=0.0.20",
+    "safetensors>=0.6.2",
+    "sentencepiece>=0.2.1",
+    "supabase>=2.22.0",
+    "transformers>=4.57.0",
+    "uvicorn>=0.37.0",
+]

supabase/migrations/20251230120000_create_chat_history.sql

@@ -0,0 +1,11 @@
+-- Chat message history storage for LangChain PostgresChatMessageHistory
+-- Handles pooled connections in app.core.database; schema is managed via Supabase migrations
+
+create table if not exists public.chat_history (
+  id bigint generated by default as identity primary key,
+  session_id uuid not null,
+  message jsonb not null,
+  created_at timestamptz not null default now()
+);
+
+create index if not exists chat_history_session_id_idx on public.chat_history (session_id);