Initial deployment

Dockerfile

@@ -0,0 +1,18 @@
+cat > ~/FactCheckAI/Dockerfile << 'EOF'
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y build-essential && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN python -m spacy download en_core_web_trf
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+EOF

apisetup.py

@@ -0,0 +1,93 @@
+'''
+Collecting all the links through api
+'''
+import requests, json
+from langdetect import detect, LangDetectException
+# super dev 
+
+class Apicaller():
+    def __init__(self, key):
+        self.api = key
+    
+    def superdev(self, keywords: list[str]):
+
+        if not isinstance(keywords, list):
+            raise ValueError("Invalid data type")
+        
+        attempts = 0
+        links = []
+
+        for keyword in keywords:
+            
+            if len(keyword) < 3:
+                continue
+
+            url = "https://google.serper.dev/news"
+
+            payload = {
+            "q": keyword,
+            "gl": "in",
+            "hl": "en"
+            }
+
+            headers = {
+            'X-API-KEY': self.api,
+            'Content-Type': 'application/json'
+            }
+
+            # FIX 1: requests.request() itself can throw RequestException (timeout,
+            # DNS failure, no network) before .status_code is ever accessible.
+            # Catch it, log it, count it as a failed attempt, and move on.
+            try:
+                response = requests.request("POST", url, headers=headers, json=payload)
+            except requests.exceptions.RequestException as e:
+                print(f"[Apicaller] Network error for keyword '{keyword}': {e}")
+                attempts += 1
+                if attempts >= len(keywords) / 2:
+                    print("Too many network failures, exiting...")
+                    break
+                continue
+
+            if response.status_code != 200:
+                # Wrong api key or something else
+                print(f"Request failed with status code: {response.status_code}")
+                attempts += 1
+
+                if attempts >= len(keywords) / 2:
+                    print("Wrrong api key or somthing else exiting...")
+                    break
+
+                continue
+
+            # FIX 2: response_json["news"] raises KeyError when the API returns
+            # a different top-level structure (e.g. an error payload with no "news" key).
+            # Skip the keyword and continue rather than crashing the whole call.
+            try:
+                response_json = response.json()
+                news_items = response_json["news"]
+            except (KeyError, ValueError) as e:
+                print(f"[Apicaller] Unexpected response structure for keyword '{keyword}': {e}")
+                continue
+
+            for result in news_items:
+
+                # FIX 3: result["title"] and result["link"] raise KeyError when a
+                # news entry is missing expected fields. Skip the malformed entry.
+                try:
+                    title = result["title"]
+                    link  = result["link"]
+                except KeyError as e:
+                    print(f"[Apicaller] Missing field {e} in news entry — skipping entry.")
+                    continue
+
+                # FIX 4: langdetect.detect() raises LangDetectException on very short,
+                # numeric, or character-ambiguous titles. Treat detection failure as
+                # non-English so the link is simply not added (safe, conservative default).
+                try:
+                    if detect(title) == "en":
+                        links.append(link)
+                except LangDetectException as e:
+                    print(f"[Apicaller] Language detection failed for title '{title[:40]}': {e} — skipping.")
+                    continue
+        
+        return links

conflictdetection.py

@@ -0,0 +1,309 @@
+import re
+import json
+import torch
+import spacy
+from sentence_transformers import SentenceTransformer, util
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, logging
+from dataclasses import dataclass
+from typing import List, Tuple
+
+logging.set_verbosity_error()
+
+
+# Spacy model — loaded once at module level with proper error handling
+
+_SPACY_MODEL_NAME = "en_core_web_trf"
+
+def _load_spacy_model(model_name: str):
+    try:
+        return spacy.load(model_name)
+
+    except OSError:
+        print(f"[ConflictDetector] spaCy model '{model_name}' not found. Downloading...")
+        try:
+            spacy.cli.download(model_name)
+            print(f"[ConflictDetector] Model '{model_name}' downloaded successfully.")
+            return spacy.load(model_name)
+        except Exception as e:
+            raise RuntimeError(f"[ConflictDetector] spaCy model download failed: {e}") from e
+
+    except Exception as e:
+        raise RuntimeError(f"[ConflictDetector] spaCy model loading failed: {e}") from e
+
+
+try:
+    _spacy_model = _load_spacy_model(_SPACY_MODEL_NAME)
+except RuntimeError as e:
+    print(f"[ConflictDetector] WARNING: spaCy model could not be loaded: {e}")
+    print("[ConflictDetector] NER-based conflict classification will fall back to 'Factual Conflict'.")
+    _spacy_model = None
+
+
+# Data class
+
+@dataclass
+class Conflict:
+    sentence_a: str
+    sentence_b: str
+    conflict_type: str
+    severity: str
+    confidence: float
+    contradiction_score: float
+
+
+# ConflictDetector
+
+class ConflictDetector:
+    def __init__(self, strictness: float = 0.7):
+        if not (0.0 <= strictness <= 1.0):
+            raise ValueError(f"strictness must be between 0.0 and 1.0, got {strictness}")
+
+        self.strictness = strictness
+
+        print("[ConflictDetector] Loading semantic similarity model...")
+        try:
+            self.similarity_model = SentenceTransformer("all-MiniLM-L6-v2")
+        except Exception as e:
+            raise RuntimeError(f"[ConflictDetector] Failed to load similarity model: {e}") from e
+
+        print("[ConflictDetector] Loading NLI contradiction detection model...")
+        try:
+            _nli_model_name = "cross-encoder/nli-deberta-v3-base"
+            self.nli_tokenizer = AutoTokenizer.from_pretrained(_nli_model_name)
+            self.nli_model = AutoModelForSequenceClassification.from_pretrained(_nli_model_name)
+            self.nli_model.eval()
+        except Exception as e:
+            raise RuntimeError(f"[ConflictDetector] Failed to load NLI model: {e}") from e
+
+        print("[ConflictDetector] Loading NER model...")
+        self.nlp = _spacy_model
+
+        self.ignore_patterns = [
+            r"\b(published|updated|posted|written by|author|reporter|editor)\b",
+            r"\b\d{1,2}:\d{2}\s?(am|pm|AM|PM)\b",
+            r"\bfollow us\b|\bsubscribe\b|\bclick here\b",
+            r"\bcopyright\b|\ball rights reserved\b",
+        ]
+
+        print("[ConflictDetector] All models loaded.\n")
+
+    def split_into_claims(self, text: str) -> List[str]:
+        if not isinstance(text, str) or not text.strip():
+            return []
+
+        sentences = re.split(r"(?<=[.!?])\s+", text.strip())
+
+        claims = []
+        for sent in sentences:
+            sent = sent.strip()
+            if len(sent.split()) < 6:
+                continue
+            if any(re.search(p, sent, re.IGNORECASE) for p in self.ignore_patterns):
+                continue
+            claims.append(sent)
+
+        return claims
+
+    def find_similar_pairs(self, claims_a, claims_b):
+        if not claims_a or not claims_b:
+            return []
+
+        similarity_threshold = 0.75 - (self.strictness * 0.25)
+
+        try:
+            embeddings_a = self.similarity_model.encode(claims_a, batch_size=24, convert_to_tensor=True)
+            embeddings_b = self.similarity_model.encode(claims_b, batch_size=24, convert_to_tensor=True)
+        except Exception as e:
+            print(f"[ConflictDetector] Encoding failed during similarity search: {e}")
+            return []
+
+        cosine_scores = util.cos_sim(embeddings_a, embeddings_b)
+
+        pairs = []
+        for i in range(len(claims_a)):
+            for j in range(len(claims_b)):
+                score = cosine_scores[i][j].item()
+                if score >= similarity_threshold:
+                    pairs.append((claims_a[i], claims_b[j], score))
+
+        pairs.sort(key=lambda x: x[2], reverse=True)
+        return pairs
+
+    def check_contradiction(self, sentence_a: str, sentence_b: str) -> float:
+        try:
+            inputs = self.nli_tokenizer(
+                sentence_a, sentence_b,
+                return_tensors="pt", truncation=True, max_length=512,
+            )
+            with torch.no_grad():
+                outputs = self.nli_model(**inputs)
+                probs = torch.softmax(outputs.logits, dim=-1)
+            return probs[0][0].item()
+        except Exception as e:
+            print(f"[ConflictDetector] NLI check failed for pair: {e}")
+            return 0.0
+
+    def classify_conflict_type(self, sentence_a: str, sentence_b: str) -> str:
+        try:
+            doc_a = self.nlp(sentence_a)
+            doc_b = self.nlp(sentence_b)
+        except Exception as e:
+            print(f"[ConflictDetector] NER classification failed: {e}")
+            return "Factual Conflict"
+
+        entities_a = {ent.label_: ent.text for ent in doc_a.ents}
+        entities_b = {ent.label_: ent.text for ent in doc_b.ents}
+
+        entity_type_map = {
+            "PERSON":   "Name Mismatch",
+            "ORG":      "Organization Mismatch",
+            "GPE":      "Location Mismatch",
+            "LOC":      "Location Mismatch",
+            "DATE":     "Date Mismatch",
+            "TIME":     "Time Mismatch",
+            "CARDINAL": "Number Mismatch",
+            "ORDINAL":  "Order/Rank Mismatch",
+            "MONEY":    "Financial Mismatch",
+            "PERCENT":  "Statistics Mismatch",
+            "EVENT":    "Event Mismatch",
+        }
+
+        conflicts_found = []
+        for entity_label, conflict_name in entity_type_map.items():
+            val_a = entities_a.get(entity_label)
+            val_b = entities_b.get(entity_label)
+            if val_a and val_b and val_a.lower() != val_b.lower():
+                conflicts_found.append(conflict_name)
+
+        return " & ".join(set(conflicts_found)) if conflicts_found else "Factual Conflict"
+
+    def get_severity(self, contradiction_score: float, conflict_type: str) -> str:
+        high_priority_types = [
+            "Date Mismatch", "Location Mismatch", "Number Mismatch",
+            "Event Mismatch", "Factual Conflict",
+        ]
+        is_high_priority = any(t in conflict_type for t in high_priority_types)
+
+        if contradiction_score >= 0.85:
+            return "HIGH"
+        elif contradiction_score >= 0.65:
+            return "HIGH" if is_high_priority else "MEDIUM"
+        else:
+            return "MEDIUM" if is_high_priority else "LOW"
+
+    def detect_conflicts(self, doc_a: str, doc_b: str) -> List[Conflict]:
+        contradiction_threshold = 0.85 - (self.strictness * 0.35)
+        print(f"[ConflictDetector] Strictness: {self.strictness} | Contradiction threshold: {contradiction_threshold:.2f}")
+
+        claims_a = self.split_into_claims(doc_a)
+        claims_b = self.split_into_claims(doc_b)
+        print(f"[ConflictDetector] Doc A: {len(claims_a)} claims | Doc B: {len(claims_b)} claims")
+
+        if not claims_a or not claims_b:
+            print("[ConflictDetector] One or both documents produced no claims. Skipping.")
+            return []
+
+        similar_pairs = self.find_similar_pairs(claims_a, claims_b)
+        print(f"[ConflictDetector] Similar pairs found: {len(similar_pairs)}")
+
+        conflicts = []
+        seen_pairs: set = set()
+
+        for sent_a, sent_b, sim_score in similar_pairs:
+            pair_key = (sent_a[:50], sent_b[:50])
+            if pair_key in seen_pairs:
+                continue
+            seen_pairs.add(pair_key)
+
+            contradiction_score = self.check_contradiction(sent_a, sent_b)
+
+            if contradiction_score >= contradiction_threshold:
+                conflict_type = self.classify_conflict_type(sent_a, sent_b)
+                severity = self.get_severity(contradiction_score, conflict_type)
+
+                conflicts.append(Conflict(
+                    sentence_a=sent_a,
+                    sentence_b=sent_b,
+                    conflict_type=conflict_type,
+                    severity=severity,
+                    confidence=round(sim_score, 3),
+                    contradiction_score=round(contradiction_score, 3),
+                ))
+
+        severity_order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
+        conflicts.sort(key=lambda x: (severity_order[x.severity], -x.contradiction_score))
+
+        return conflicts
+
+    def report(self, doc_a: str, doc_b: str, external_source: str = "unknown") -> dict:
+        """
+        Runs conflict detection and returns a structured dict.
+        Always returns a dict — .
+        """
+        # BUG FIX: Previously, when doc_a had no extractable claims (input too
+        # short, or all sentences under 6 words), detect_conflicts() returned []
+        # and report() returned {"status": "NO_CONFLICTS"}. That is a false result —
+        # the pipeline had no basis to say "no conflicts"; it simply couldn't read
+        # the input. The AI bot receiving NO_CONFLICTS would tell the user the
+        # article is consistent, which is a wrong conclusion from an empty analysis.
+        # Now we detect this before running the full pipeline and return a distinct
+        # INSUFFICIENT_CONTENT status that accurately describes what happened.
+        claims_a = self.split_into_claims(doc_a)
+        if not claims_a:
+            return {
+                "status": "INSUFFICIENT_CONTENT",
+                "error": (
+                    "The input text could not be broken into verifiable claims. "
+                    "It may be too short (under 6 words per sentence) or contain "
+                    "only boilerplate/metadata. Provide a paragraph or more of "
+                    "substantive text for meaningful conflict analysis."
+                ),
+                "total": 0,
+                "conflicts": {},
+            }
+
+        try:
+            conflicts = self.detect_conflicts(doc_a, doc_b)
+        except Exception as e:
+            print(f"[ConflictDetector] detect_conflicts raised unexpectedly: {e}")
+            return {
+                "status": "ERROR",
+                "error": f"Detection pipeline failed: {type(e).__name__}: {e}",
+                "total": 0,
+                "conflicts": {},
+            }
+
+        if not conflicts:
+            return {"status": "NO_CONFLICTS", "total": 0, "conflicts": {}}
+
+        high   = [c for c in conflicts if c.severity == "HIGH"]
+        medium = [c for c in conflicts if c.severity == "MEDIUM"]
+        low    = [c for c in conflicts if c.severity == "LOW"]
+
+        if len(high) >= 3:
+            verdict = "BIG_MISMATCH"
+        elif len(high) >= 1:
+            verdict = "MISMATCH_DETECTED"
+        elif len(medium) >= 2:
+            verdict = "MINOR_MISMATCH"
+        else:
+            verdict = "MOSTLY_CONSISTENT"
+
+        return {
+            "status": verdict,
+            "total": len(conflicts),
+            "high": len(high),
+            "medium": len(medium),
+            "low": len(low),
+            "conflicts": {
+                f"conflict_{i}": {
+                    "conflict_type":       conflict.conflict_type,
+                    "severity":            conflict.severity.lower(),
+                    "contradiction_score": conflict.contradiction_score,
+                    "similarity_score":    conflict.confidence,
+                    "user_claim":          conflict.sentence_a,
+                    external_source:       conflict.sentence_b,
+                }
+                for i, conflict in enumerate(conflicts, 1)
+            },
+        }

dataretrieval.py

@@ -0,0 +1,247 @@
+"""
+All the process related to data collection and filtering
+will happen here.
+"""
+
+import trafilatura, json, tldextract
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from similarity import ModelFunctions
+
+
+# ── Standardised response builders ──────────────────────────────────────── #
+
+def _ok(data: dict) -> str:
+    """Successful result with matched articles."""
+    return {"status": "success", "results": data}
+
+def _no_match(fetched: int, scored: int, threshold: float) -> str:
+    """Articles were fetched and scored, but none crossed the threshold."""
+    return {
+        "status": "no_match",
+        "reason": (
+            f"Fetched {fetched} article(s) and scored {scored}, "
+            f"but none had a similarity score >= {threshold}. "
+            "The available content may not be directly related to the input topic."
+        )
+    }
+
+def _no_content(total_links: int, failed: int) -> str:
+    """Every URL either failed to fetch or returned no extractable text."""
+    return {
+        "status": "error",
+        "error": (
+            f"Could not retrieve content from any of the {total_links} link(s). "
+            f"{failed} link(s) failed during fetch/extraction. "
+            "Possible causes: paywalls, network timeouts, bot-blocking, or invalid URLs."
+        )
+    }
+
+def _bad_input(detail: str) -> str:
+    """Caller passed invalid arguments."""
+    return {"status": "error", "error": f"Invalid input — {detail}"}
+
+def _internal_error(context: str, exc: Exception) -> str:
+    """Unexpected exception in a named context."""
+    return {
+        "status": "error",
+        "error": f"Unexpected failure in [{context}]: {type(exc).__name__}: {exc}"
+    }
+
+
+# Similarity threshold
+SIMILARITY_THRESHOLD = 0.4
+
+
+class DataCollector():
+
+    def __init__(self, ModelFunctionsObj):
+        self.object = ModelFunctionsObj
+
+    # ------------------------------------------------------------------ #
+    # Fetches a single URL — returns (link, text, error_reason)           #
+    # error_reason is None on success, a short string on failure          #
+    # ------------------------------------------------------------------ #
+    def _fetch_one(self, link: str) -> tuple:
+        try:
+            html = trafilatura.fetch_url(link)
+            if not html:
+                return link, None, "no HTML returned (possible bot-block or empty page)"
+            text = trafilatura.extract(html)
+            if not text:
+                return link, None, "HTML fetched but no text could be extracted"
+            return link, text, None
+        except Exception as e:
+            return link, None, f"{type(e).__name__}: {e}"
+
+    # ------------------------------------------------------------------ #
+    # Parallel fetch + batch similarity                                   #
+    # ------------------------------------------------------------------ #
+    def retriever(self, OriginalContent: str, links: list) -> str:
+
+        # validate inputs 
+        if not isinstance(OriginalContent, str) or not OriginalContent.strip():
+            return _bad_input("OriginalContent must be a non-empty string.")
+        if not isinstance(links, list) or not links:
+            return _bad_input("links must be a non-empty list of URL strings.")
+
+        try:
+            # Step 1: Parallel fetch
+            fetched = {}            # link -> raw text
+            fetch_failures = []     # track failures for diagnostics
+
+            with ThreadPoolExecutor(max_workers=20) as executor:
+                futures = {executor.submit(self._fetch_one, link): link for link in links}
+                for future in as_completed(futures):
+                    link, text, reason = future.result()
+                    if text:
+                        fetched[link] = text
+                    else:
+                        fetch_failures.append(f"{link} → {reason}")
+
+            # Log which URLs failed
+            if fetch_failures:
+                print(f"[DataRetrieval] {len(fetch_failures)}/{len(links)} link(s) failed:")
+                for f in fetch_failures:
+                    print(f"  ✗ {f}")
+
+            # Zero articles retrieved — no point going further
+            if not fetched:
+                return _no_content(len(links), len(fetch_failures))
+
+            # ── Step 2: Extract titles ───────────────────────────────────
+            valid_links  = []
+            valid_titles = []
+            valid_texts  = []
+
+            for link, text in fetched.items():
+                try:
+                    title = text.strip().split(".")[0].lower()
+                except (AttributeError, IndexError):
+                    title = ""      # empty string still gets scored, just poorly
+
+                valid_links.append(link)
+                valid_titles.append(title)
+                valid_texts.append(text)
+
+            # ── Step 3: Single batch similarity pass ─────────────────────
+            try:
+                scores = self.object.BatchSimilarityScores(OriginalContent, valid_titles)
+            except Exception as e:
+                return _internal_error("BatchSimilarityScores", e)
+
+            # ── Step 4: Filter by threshold ──────────────────────────────
+            data = {}
+            for link, text, score in zip(valid_links, valid_texts, scores):
+                # print(f"[Score] {score:.4f}  {link}") # only for testing dev
+                if score >= SIMILARITY_THRESHOLD:
+                    try:
+                        data[f"searchresult{len(data) + 1}"] = {
+                            "organization": tldextract.extract(link).domain,
+                            "score": score,
+                            "article": text
+                        }
+                    except Exception as e:
+                        print(f"[DataRetrieval] Could not save result for {link}: {e} — skipping.")
+                        continue
+
+            # ── Step 5: Return with clear status ─────────────────────────
+            if not data:
+                return _no_match(
+                    fetched=len(fetched),
+                    scored=len(valid_titles),
+                    threshold=SIMILARITY_THRESHOLD
+                )
+
+            return _ok(data)
+
+        except Exception as e:
+            return _internal_error("retriever main block", e)
+
+    # ------------------------------------------------------------------ #
+    # top_results — handles both old bare-dict and new status-wrapped fmt #
+    # ------------------------------------------------------------------ #
+    def top_results(self, data, num_of_articals: int = 2):
+
+        try:
+            if isinstance(data, str):
+                try:
+                    data = json.loads(data)
+                except json.JSONDecodeError as e:
+                    print(f"[top_results] Failed to parse JSON input: {e}")
+                    return None
+
+            # Unwrap new response format if present
+            if isinstance(data, dict) and "results" in data:
+                data = data["results"]
+
+            if not isinstance(data, dict) or not data:
+                print("[top_results] Invalid or empty data — nothing to sort.")
+                return None
+
+            sorted_items = sorted(
+                data.items(),
+                key=lambda item: item[1]["score"],
+                reverse=True
+            )
+
+            num_of_articals = min(num_of_articals, len(sorted_items))
+            top_n = sorted_items[:num_of_articals]
+
+            result = {}
+            for i, (_, value) in enumerate(top_n, start=1):
+                result[f"searchresult{i}"] = value
+
+            return result
+
+        except Exception as e:
+            print(f"[top_results] Unexpected error: {e}")
+            return None
+
+
+# ── Standalone helper: fetch and parse a single user-supplied article ─────── #
+
+def get_user_article(user_link: str) -> dict:
+
+    if not isinstance(user_link, str) or not user_link.strip():
+        return {"status": "error", "error": "Invalid or empty URL provided."}
+
+    try:
+        try:
+            html = trafilatura.fetch_url(user_link)
+            article_text = trafilatura.extract(html) if html else None
+        except Exception as e:
+            msg = f"Network or extraction failure: {type(e).__name__}: {e}"
+            print(f"[get_user_article] {msg}")
+            return {"status": "error", "error": msg}
+
+        if not article_text:
+            return {
+                "status": "error",
+                "error": (
+                    "Could not extract readable text from the provided URL. "
+                    "The page may be paywalled, JavaScript-rendered, or block scrapers."
+                )
+            }
+
+        try:
+            title = article_text.strip().split(".")[0].lower()
+        except (AttributeError, IndexError, TypeError, ValueError):
+            title = None
+
+        try:
+            organization = tldextract.extract(user_link).domain
+        except (AttributeError, TypeError, ValueError):
+            organization = None
+
+        return {
+            "status": "success",
+            "organization": organization,
+            "title": title,
+            "article": article_text
+        }
+
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": f"Unexpected failure in get_user_article: {type(e).__name__}: {e}"
+        }

main.py

@@ -0,0 +1,184 @@
+import asyncio
+import logging
+from concurrent.futures import ThreadPoolExecutor
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel, field_validator
+
+from prototype import Prototype
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+# Pipeline is I/O-heavy (scraping + LLM calls). 150 s is generous but not infinite.
+# If it hasn't returned by then, tell the user to retry rather than hanging forever.
+PIPELINE_TIMEOUT_SECONDS = 150
+
+# ThreadPoolExecutor lets us run the blocking Prototype.run() without freezing
+# FastAPI's async event loop. max_workers=4 handles 4 simultaneous requests.
+THREAD_POOL = ThreadPoolExecutor(max_workers=4)
+
+# ── App ───────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="FactCheck AI",
+    description="AI-powered news fact-checking and trust analysis",
+    version="1.1.0",
+)
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
+
+# ── Request / Response Models ─────────────────────────────────────────────────
+class ChatRequest(BaseModel):
+    text:           str
+    inputType:      str   # "query" | "article_link"
+    searchApiKey:   str   # user's search API key
+    searchProvider: str   # "serper.dev" | "gnews" | "publicapi.dev"
+    llmApiKey:      str   # user's LLM API key
+    llmProvider:    str   # "anthropic" | "openai" | "google" | "groq"
+
+    @field_validator("text")
+    @classmethod
+    def text_not_empty(cls, v: str) -> str:
+        v = v.strip()
+        if not v:
+            raise ValueError("text must not be empty")
+        if len(v) > 5000:
+            raise ValueError("text exceeds 5 000 characters")
+        return v
+
+    @field_validator("inputType")
+    @classmethod
+    def valid_input_type(cls, v: str) -> str:
+        allowed = {"query", "article_link"}
+        if v not in allowed:
+            raise ValueError(f"inputType must be one of {allowed}")
+        return v
+
+    @field_validator("llmProvider")
+    @classmethod
+    def valid_llm_provider(cls, v: str) -> str:
+        allowed = {"anthropic", "openai", "google", "groq"}
+        if v not in allowed:
+            raise ValueError(f"llmProvider must be one of {allowed}")
+        return v
+
+
+class ChatResponse(BaseModel):
+    response:  str
+    inputType: str
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+@app.get("/", response_class=HTMLResponse)
+async def homepage(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(payload: ChatRequest):
+    """
+    Runs the Prototype pipeline end-to-end and streams the LLM explanation
+    back to the frontend as a plain string inside ChatResponse.
+
+    Flow:
+      1. Build Prototype with the user-supplied search API key.
+         key_provider is always "superdev" — that is the internal name used by
+         Apicaller regardless of which search provider the user picked in the UI.
+      2. Run the blocking pipeline in a thread-pool so FastAPI stays responsive.
+      3. Enforce a 150-second timeout. If it fires, return a user-friendly
+         "please try again" message instead of hanging the request forever.
+      4. Catch any unexpected exception and return a readable error message.
+         The pipeline itself already converts most internal errors into LLM
+         explanations, so this outer catch is only a safety net.
+    """
+    logger.info(
+        "Chat request | type=%s | llm=%s | search=%s | text=%.120s",
+        payload.inputType,
+        payload.llmProvider,
+        payload.searchProvider,
+        payload.text,
+    )
+
+    # Prototype's internal search provider name is always "superdev".
+    # The UI label ("serper.dev", "gnews", etc.) is only for display;
+    # the actual API call routing is done inside Apicaller.
+    KEY_PROVIDER = "superdev"
+
+    pipeline = Prototype(payload.searchApiKey, KEY_PROVIDER)
+
+    def _run_pipeline() -> str:
+        """Blocking call — executed in the thread pool."""
+        return pipeline.run(
+            payload.text,
+            payload.inputType,
+            llm_api_key=payload.llmApiKey,
+            llm_provider=payload.llmProvider,
+        )
+
+    loop = asyncio.get_event_loop()
+
+    try:
+        result: str = await asyncio.wait_for(
+            loop.run_in_executor(THREAD_POOL, _run_pipeline),
+            timeout=PIPELINE_TIMEOUT_SECONDS,
+        )
+        logger.info("Pipeline finished successfully | type=%s", payload.inputType)
+        return ChatResponse(response=result, inputType=payload.inputType)
+
+    except asyncio.TimeoutError:
+        logger.warning(
+            "Pipeline timed out after %ds | type=%s | text=%.80s",
+            PIPELINE_TIMEOUT_SECONDS,
+            payload.inputType,
+            payload.text,
+        )
+        return ChatResponse(
+            response=(
+                "⏱️ Analysis timed out.\n\n"
+                "The pipeline ran for over 2.5 minutes without finishing. "
+                "This usually happens when sources are slow to load or the claim is very broad.\n\n"
+                "Please try again with a shorter or more specific query."
+            ),
+            inputType=payload.inputType,
+        )
+
+    except Exception as exc:
+        # This fires only if something completely unexpected blows up —
+        # the pipeline's own error handling converts most failures into
+        # user-readable LLM explanations before reaching this point.
+        logger.exception("Unhandled exception in pipeline: %s", exc)
+        return ChatResponse(
+            response=(
+                "⚠️ Something unexpected went wrong.\n\n"
+                "The analysis could not complete. Please check that your API keys "
+                "are correct and try again.\n\n"
+                f"Technical detail: {str(exc)[:200]}"
+            ),
+            inputType=payload.inputType,
+        )
+
+
+# ── Health / Info ─────────────────────────────────────────────────────────────
+@app.get("/health")
+async def health():
+    return {"status": "ok", "service": "FactCheck AI", "version": "1.1.0"}
+
+
+@app.get("/about")
+async def about():
+    return {
+        "name":        "FactCheck AI",
+        "description": "AI-powered news verification and trust analysis",
+        "version":     "1.1.0",
+        "modes":       ["query verification", "article URL analysis"],
+    }

prototype.py

@@ -0,0 +1,527 @@
+import json
+import requests
+from querygeneration import KeywordExtractor, KeywordExtractionError
+from conflictdetection import ConflictDetector
+from dataretrieval import DataCollector, get_user_article
+from apisetup import Apicaller
+from similarity import ModelFunctions
+
+_SUPPORTED_PROVIDERS  = ("superdev",)
+_SUPPORTED_LLM_PROVIDERS = ("anthropic", "openai", "google", "groq")
+
+_FACT_CHECK_SYSTEM_PROMPT = """
+You are an AI assistant that explains fact-check results to normal users.
+Your job is to convert structured analysis data into a simple explanation that anyone can understand.
+Important rules:
+1. NEVER mention internal system terms such as: pipeline, retrieval, similarity score, model, API, system status, JSON, or technical errors.
+2. If the system could not find reliable information, explain it in simple language like: "We could not find reliable news reports about this claim."
+3. Use very simple and clear English. Avoid technical or academic words.
+4. Only use the information provided in the input data.
+5. Do NOT invent facts or add outside knowledge.
+6. Keep the explanation short and easy to read.
+7. Maximum length: 100 words.
+
+Output format:
+Verdict: <True / False / Partially True / Inconclusive>
+
+Explanation:
+Explain the situation in plain language so an average person can understand what was found.
+
+Evidence Summary:
+* Briefly mention what different news sources reported.
+
+Notes:
+Mention uncertainty, conflicting reports, or lack of reliable information in simple words.
+"""
+
+
+class Prototype:
+    def __init__(self, api_key: str, key_provider: str):
+        self.key_provider = key_provider
+        self.keyword_extractor = KeywordExtractor()
+        self.api_caller = Apicaller(api_key)
+        self.model_functions = ModelFunctions()
+        self.data_collector = DataCollector(self.model_functions)
+        self.conflict_detector = ConflictDetector(strictness=0.7)
+
+    def extract_keywords(self, input_type: str, data: str) -> list[str]:
+        try:
+            return self.keyword_extractor.extract(data)
+        except KeywordExtractionError as e:
+            print(f"[Pipeline] Keyword extraction failed, using fallback: {e}")
+            if input_type == "article_link":
+                return [data.split(".")[0]]
+            return [data]
+
+    def collect_links(self, keywords: list[str]) -> list[str]:
+        try:
+            if self.key_provider == "superdev":
+                return self.api_caller.superdev(keywords)
+            return []
+        except Exception as e:
+            print(f"[Pipeline] Link collection failed: {e}")
+            return []
+
+    def retrieve_online_data(self, article: str, links: list[str]) -> dict:
+        raw_data = self.data_collector.retriever(article, links)
+        if not isinstance(raw_data, dict) or raw_data.get("status") != "success":
+            return raw_data
+        top_data = self.data_collector.top_results(raw_data)
+        if top_data is None:
+            return {
+                "status": "error",
+                "error": "top_results() returned no data after a successful fetch. Internal scoring failure."
+            }
+        return {"status": "success", "results": top_data}
+
+    def detect_conflicts(self, original_data: dict | str, collected_data: dict) -> str:
+        if isinstance(original_data, dict):
+            original_article = original_data["article"]
+            organization = original_data.get("organization", "unknown")
+        else:
+            original_article = original_data
+            organization = "unknown"
+
+        results = {}
+        for result_name, result in collected_data.items():
+            try:
+                result["conflict"] = self.conflict_detector.report(
+                    original_article, result["article"], organization,
+                )
+                results[result_name] = result
+            except Exception as e:
+                print(f"[Pipeline] Conflict detection skipped for '{result_name}': {e}")
+        
+        return json.dumps(results, indent=4)
+
+
+    # structured summary for the AI bot
+
+    def final_explanation(self, userTypedquery: str, userinputType: str, raw_aggregated: str, article_text: str = None) -> dict:
+        """
+        Converts raw pipeline output into a structured dict for the AI bot.
+
+        Preserves every distinct status from dataretrieval.py:
+          "success"              → pipeline ran fully, analysis list included
+          "no_match"             → articles fetched but none passed similarity threshold
+                                   (has "reason" key, not "error")
+          "error"                → fetch/scraping/scoring failure
+                                   (has "error" key)
+          "INSUFFICIENT_CONTENT" → input too short to extract claims
+          empty dict {}          → conflict loop ran but all articles threw individually
+
+        The AI bot receives the exact reason string from each case — not a
+        generic "error" label — so it can give the user a specific explanation.
+        """
+        input_key = "user_article" if userinputType == "article_link" else "user_query"
+
+        # For article_link: use the full scraped text if fetch succeeded, otherwise
+        # fall back to the URL (fetch failed — no text available).
+        input_value = article_text if (userinputType == "article_link" and article_text) else userTypedquery
+        final: dict = {
+            input_key: input_value,
+        }
+
+        # -- Parse raw_aggregated ----------------------------------------
+        if isinstance(raw_aggregated, dict):
+            data = raw_aggregated
+
+        elif isinstance(raw_aggregated, str):
+            try:
+                data = json.loads(raw_aggregated)
+            except (json.JSONDecodeError, ValueError) as e:
+                final["pipeline_status"] = "error"
+                final["problem"] = {
+                    "status": "error",
+                    "error": f"Pipeline produced unparseable output: {e}",
+                }
+                return final
+        else:
+            final["pipeline_status"] = "error"
+            final["problem"] = {
+                "status": "error",
+                "error": (
+                    f"Unexpected type for raw_aggregated: {type(raw_aggregated).__name__}. "
+                    "Expected a JSON string or dict."
+                ),
+            }
+            return final
+
+        if not isinstance(data, dict):
+            final["pipeline_status"] = "error"
+            final["problem"] = {
+                "status": "error",
+                "error": "Parsed pipeline output is not a dict — cannot interpret results.",
+            }
+            return final
+
+        # -- Identify output shape ----------------------------------------
+        # detect_conflicts() success → keys like "searchresult1", "searchresult2"
+        # dataretrieval / pipeline error → top-level "status" key
+        # Empty dict                     → conflict loop ran, all articles skipped
+        has_search_results  = any(k.startswith("searchresult") for k in data)
+        top_level_status    = data.get("status")  # None if not present
+
+        if has_search_results and top_level_status is None:
+            # ── FULL SUCCESS ─────────────────────────────────────────────
+            final["pipeline_status"] = "success"
+            final["retrieved_articles"] = len(data)
+            final["analysis"] = list(data.values())
+
+        elif top_level_status == "no_match":
+            # ── NO_MATCH from _no_match() ────────────────────────────────
+            # dataretrieval fetched articles and scored them, but none crossed
+            # the similarity threshold. pipeline_status is "error" because the
+            # pipeline could not produce an analysis — "reason" key inside
+            # problem preserves the specific cause for the AI bot.
+            final["pipeline_status"] = "error"
+            final["problem"] = data   # preserves "status" and "reason" as-is
+
+        elif top_level_status == "error":
+            # ── HARD ERROR from _no_content / _bad_input / _internal_error ──
+            # or from any pipeline stage (provider check, fetch fail, etc.)
+            # Carries an "error" key with the specific reason string.
+            final["pipeline_status"] = "error"
+            final["problem"] = data   # preserves "status" and "error" as-is
+
+        elif top_level_status == "INSUFFICIENT_CONTENT":
+            # ── SHORT INPUT from conflictdetection.report() ──────────────
+            # Input text could not be broken into claims of >= 6 words.
+            # Distinct from an error — the pipeline ran fine, input was just too short.
+            final["pipeline_status"] = "insufficient_input"
+            final["problem"] = data
+
+        elif not data:
+            # ── EMPTY DICT ───────────────────────────────────────────────
+            # detect_conflicts() ran but every article was individually skipped.
+            final["pipeline_status"] = "error"
+            final["problem"] = {
+                "status": "error",
+                "error": (
+                    "Conflict detection completed but produced no results. "
+                    "Every retrieved article was individually skipped — "
+                    "possible causes: model errors, empty article text, or encoding failures."
+                ),
+            }
+
+        else:
+            # ── UNKNOWN SHAPE ────────────────────────────────────────────
+            # Pipeline produced a dict we don't recognise. Pass it through
+            # rather than silently discarding it — the AI can still read it.
+            final["pipeline_status"] = "error"
+            final["problem"] = {
+                "status": "error",
+                "error": (
+                    f"Pipeline returned an unrecognised output shape "
+                    f"(top-level keys: {list(data.keys())}). Cannot classify result."
+                ),
+            }
+            
+        return final
+
+    
+    # Send the structured summary to any supported LLM
+    
+    def get_response(
+        self,
+        final_aggregatedStructure: dict,
+        user_any_llm_api_key: str,
+        llm_provider: str = "anthropic",
+    ) -> str:
+        # -- Input validation --------------------------------------------
+        if not isinstance(user_any_llm_api_key, str) or not user_any_llm_api_key.strip():
+            return json.dumps({
+                "status": "error",
+                "error": "LLM API key is missing or empty.",
+            }, indent=4)
+
+        llm_provider = llm_provider.strip().lower()
+        if llm_provider not in _SUPPORTED_LLM_PROVIDERS:
+            return json.dumps({
+                "status": "error",
+                "error": (
+                    f"Unsupported LLM provider: '{llm_provider}'. "
+                    f"Supported providers are: {', '.join(_SUPPORTED_LLM_PROVIDERS)}."
+                ),
+            }, indent=4)
+
+        user_message_text = (
+            "Here is the fact-checking pipeline output. "
+            "Generate the fact-checking report according to your instructions.\n\n"
+            f"{json.dumps(final_aggregatedStructure, indent=2)}"
+        )
+
+        # -- Build provider-specific request -----------------------------
+        try:
+            if llm_provider == "anthropic":
+                url = "https://api.anthropic.com/v1/messages"
+                headers = {
+                    "x-api-key":         user_any_llm_api_key,
+                    "anthropic-version": "2023-06-01",
+                    "content-type":      "application/json",
+                }
+                body = {
+                    "model":      "claude-sonnet-4-20250514",
+                    "max_tokens": 1000,
+                    "system":     _FACT_CHECK_SYSTEM_PROMPT,
+                    "messages":   [{"role": "user", "content": user_message_text}],
+                }
+
+            elif llm_provider == "openai":
+                url = "https://api.openai.com/v1/chat/completions"
+                headers = {
+                    "Authorization": f"Bearer {user_any_llm_api_key}",
+                    "content-type":  "application/json",
+                }
+                body = {
+                    "model":    "gpt-4o",
+                    "messages": [
+                        {"role": "system",  "content": _FACT_CHECK_SYSTEM_PROMPT},
+                        {"role": "user",    "content": user_message_text},
+                    ],
+                }
+
+            elif llm_provider == "google":
+                url = (
+                    "https://generativelanguage.googleapis.com/v1beta/models/"
+                    f"gemini-2.0-flash-lite:generateContent?key={user_any_llm_api_key}"
+                )
+                headers = {"content-type": "application/json"}
+                body = {
+                    "systemInstruction": {
+                        "parts": [{"text": _FACT_CHECK_SYSTEM_PROMPT}]
+                    },
+                    "contents": [
+                        {"parts": [{"text": user_message_text}]}
+                    ],
+                }
+
+            elif llm_provider == "groq":
+                url = "https://api.groq.com/openai/v1/chat/completions"
+                headers = {
+                    "Authorization": f"Bearer {user_any_llm_api_key}",
+                    "content-type":  "application/json",
+                }
+                body = {
+                    "model":    "llama-3.3-70b-versatile",
+                    "messages": [
+                        {"role": "system", "content": _FACT_CHECK_SYSTEM_PROMPT},
+                        {"role": "user",   "content": user_message_text},
+                    ],
+                }
+
+        except Exception as e:
+            return json.dumps({
+                "status": "error",
+                "error": f"Failed to build request for provider '{llm_provider}': {e}",
+            }, indent=4)
+
+        # -- Make the HTTP call ------------------------------------------
+        try:
+            response = requests.post(url, headers=headers, json=body, timeout=30)
+
+        except requests.exceptions.Timeout:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Request timed out after 30 seconds.",
+            }, indent=4)
+
+        except requests.exceptions.ConnectionError as e:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Could not connect. Check your network: {e}",
+            }, indent=4)
+
+        except requests.exceptions.RequestException as e:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Request failed: {type(e).__name__}: {e}",
+            }, indent=4)
+
+        # -- Handle non-200 HTTP responses --------------------------------
+        if response.status_code == 401:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] API key is invalid or unauthorized (HTTP 401).",
+            }, indent=4)
+
+        if response.status_code == 429:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Rate limit exceeded (HTTP 429). Wait and retry.",
+            }, indent=4)
+
+        if response.status_code != 200:
+            body_preview = response.text[:300] if response.text else "(empty body)"
+            return json.dumps({
+                "status": "error",
+                "error": (
+                    f"[{llm_provider}] HTTP {response.status_code}. "
+                    f"Body preview: {body_preview}"
+                ),
+            }, indent=4)
+
+        # -- Parse the response body -------------------------------------
+        try:
+            response_data = response.json()
+        except (ValueError, json.JSONDecodeError) as e:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Returned a non-JSON body: {e}",
+            }, indent=4)
+
+        # -- Extract text using provider-specific response shape ---------
+        try:
+            if llm_provider == "anthropic":
+                # {"content": [{"type": "text", "text": "..."}]}
+                content_blocks = response_data.get("content", [])
+                explanation = "\n".join(
+                    block["text"]
+                    for block in content_blocks
+                    if isinstance(block, dict) and block.get("type") == "text"
+                ).strip()
+
+            elif llm_provider == "openai":
+                # {"choices": [{"message": {"role": "assistant", "content": "..."}}]}
+                choices = response_data.get("choices", [])
+                if not choices:
+                    return json.dumps({
+                        "status": "error",
+                        "error": "[openai] Response contained no choices.",
+                    }, indent=4)
+                explanation = choices[0].get("message", {}).get("content", "").strip()
+
+            elif llm_provider == "google":
+                # {"candidates": [{"content": {"parts": [{"text": "..."}]}}]}
+                candidates = response_data.get("candidates", [])
+                if not candidates:
+                    return json.dumps({
+                        "status": "error",
+                        "error": "[google] Response contained no candidates.",
+                    }, indent=4)
+                parts = candidates[0].get("content", {}).get("parts", [])
+                explanation = "\n".join(
+                    p["text"] for p in parts if isinstance(p, dict) and "text" in p
+                ).strip()
+    
+            elif llm_provider == "groq":
+                # {"choices": [{"message": {"role": "assistant", "content": "..."}}]}
+                choices = response_data.get("choices", [])
+                if not choices:
+                    return json.dumps({
+                        "status": "error",
+                        "error": "[groq] Response contained no choices.",
+                    }, indent=4)
+                explanation = choices[0].get("message", {}).get("content", "").strip()
+
+        except (KeyError, IndexError, TypeError) as e:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Unexpected response structure: {e}",
+            }, indent=4)
+
+        if not explanation:
+            return json.dumps({
+                "status": "error",
+                "error": f"[{llm_provider}] Response contained no text.",
+            }, indent=4)
+
+        return explanation
+
+    
+    
+    # Full pipeline — single entry point
+    
+    def run(
+        self,
+        user_input: str,
+        input_type: str,
+        llm_api_key: str = None,
+        llm_provider: str = "anthropic",
+    ) -> str:
+        raw_aggregated: str | None = None
+        article_data      = None
+        collected_data    = None
+        text_for_keywords = None
+
+        # -- Step 1: Validate key_provider --------------------------------
+        if self.key_provider not in _SUPPORTED_PROVIDERS:
+            raw_aggregated = json.dumps({
+                "status": "error",
+                "error": (
+                    f"Unsupported key provider: '{self.key_provider}'. "
+                    f"Supported providers are: {', '.join(_SUPPORTED_PROVIDERS)}."
+                ),
+            }, indent=4)
+
+        # -- Step 2: Fetch article / validate query -----------------------
+        if raw_aggregated is None:
+            if input_type == "article_link":
+                article_data = get_user_article(user_input)
+                print(f"[Pipeline] Article fetch status: {article_data.get('status')}")
+                if article_data.get("status") != "success":
+                    raw_aggregated = json.dumps(article_data, indent=4)
+                else:
+                    text_for_keywords = article_data["article"]
+            else:
+                claims_preview = self.conflict_detector.split_into_claims(user_input)
+                if not claims_preview:
+                    raw_aggregated = json.dumps({
+                        "status": "error",
+                        "error": (
+                            "Input text is too short for conflict detection. "
+                            "Provide at least one complete sentence (6+ words) so the "
+                            "system can extract claims to compare against retrieved articles."
+                        ),
+                    }, indent=4)
+                else:
+                    article_data      = user_input
+                    text_for_keywords = user_input
+
+        # -- Step 3: Extract keywords -------------------------------------
+        if raw_aggregated is None:
+            keywords = self.extract_keywords(input_type, text_for_keywords)
+            print(f"[Pipeline] Keywords: {keywords}")
+
+        # -- Step 4: Collect links ----------------------------------------
+        if raw_aggregated is None:
+            links = self.collect_links(keywords)
+            print(f"[Pipeline] Collected {len(links)} links")
+            if not links:
+                raw_aggregated = json.dumps({
+                    "status": "error",
+                    "error": (
+                        "No search result links were collected. "
+                        "Possible causes: API key is invalid or rate-limited, "
+                        "all extracted keywords were too short, or a network failure occurred."
+                    ),
+                }, indent=4)
+
+        # -- Step 5: Retrieve and rank articles ---------------------------
+        if raw_aggregated is None:
+            retrieval_result = self.retrieve_online_data(text_for_keywords, links)
+            print(f"[Pipeline] Retrieval status: {retrieval_result.get('status')}")
+            if retrieval_result.get("status") != "success":
+                raw_aggregated = json.dumps(retrieval_result, indent=4)
+            else:
+                collected_data = retrieval_result["results"]
+                print(f"[Pipeline] Retrieved {len(collected_data)} results")
+
+        # -- Step 6: Conflict detection -----------------------------------
+        if raw_aggregated is None:
+            raw_aggregated = self.detect_conflicts(article_data, collected_data)
+
+        # -- Step 7: Build AI-readable summary ----------------------------
+
+        fetched_article_text = (
+            article_data.get("article")
+            if isinstance(article_data, dict) and input_type == "article_link"
+            else None
+        )
+        final_structure = self.final_explanation(user_input, input_type, raw_aggregated, fetched_article_text)
+
+        # -- Step 8: Generate AI explanation (optional) -------------------
+        if llm_api_key:
+            return self.get_response(final_structure, llm_api_key, llm_provider)
+
+        return json.dumps(final_structure, indent=4)

querygeneration.py

@@ -0,0 +1,55 @@
+from keybert import KeyBERT
+from transformers import logging
+
+logging.set_verbosity_error()
+
+
+class KeywordExtractionError(Exception):
+    """Raised when keyword extraction fails and no fallback is possible."""
+    pass
+
+
+class KeywordExtractor:
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        try:
+            self.kw_model = KeyBERT(model=model_name)
+        except Exception as e:
+            raise KeywordExtractionError(
+                f"Failed to load KeyBERT model '{model_name}': {e}"
+            ) from e
+
+    def extract(
+        self,
+        text: str,
+        num_keywords: int = 3,
+        ngram_range: tuple = (1, 2),
+    ) -> list[str]:
+        """
+        Extract keywords from text.
+        Returns a list of keyword strings.
+        Raises KeywordExtractionError if extraction fails completely.
+        """
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError("Input text must be a non-empty string.")
+
+        try:
+            keywords = self.kw_model.extract_keywords(
+                text,
+                keyphrase_ngram_range=ngram_range,
+                stop_words="english",
+                top_n=num_keywords,
+            )
+
+            # extract_keywords returns list of (keyword, score) tuples
+            result = [kw[0] for kw in keywords if kw]
+
+            if not result:
+                raise KeywordExtractionError("Model returned no keywords for the given text.")
+
+            return result
+
+        except KeywordExtractionError:
+            raise  # let it bubble up cleanly
+
+        except Exception as e:
+            raise KeywordExtractionError(f"Unexpected error during keyword extraction: {e}") from e

requirements.txt

@@ -0,0 +1,20 @@
+numpy
+newspaper3k
+trafilatura
+torch
+transformers
+sentence-transformers
+scikit-learn
+keybert
+tldextract
+spacy
+langdetect
+fastapi
+uvicorn
+Jinja2
+pydantic
+html_clean
+lxml_html_clean
+aiohttp
+google-generativeai
+groq

similarity.py

@@ -0,0 +1,115 @@
+import torch
+import torch.nn.functional as F
+from sentence_transformers import SentenceTransformer
+from transformers import logging
+
+logging.set_verbosity_error()
+
+
+class SimilarityModelError(Exception):
+    """Raised when the similarity model fails to load or run."""
+    pass
+
+
+class ModelFunctions:
+    def __init__(self, model_name: str = "all-mpnet-base-v2"):
+        try:
+            self.sbert_model = SentenceTransformer(model_name)
+        except Exception as e:
+            raise SimilarityModelError(
+                f"Failed to load SentenceTransformer model '{model_name}': {e}"
+            ) from e
+
+    # ------------------------------------------------------------------
+    # Single pair comparison
+    # ------------------------------------------------------------------
+    def SimilarityScore(self, sent1: str, sent2: str) -> float:
+        """
+        Returns cosine similarity between two sentences (0.0 to 1.0).
+        Returns 0.0 on failure instead of crashing — safe to use in loops.
+        """
+        if not isinstance(sent1, str) or not isinstance(sent2, str):
+            print("[ModelFunctions] SimilarityScore: both inputs must be strings.")
+            return 0.0
+
+        if not sent1.strip() or not sent2.strip():
+            print("[ModelFunctions] SimilarityScore: received empty string input.")
+            return 0.0
+
+        try:
+            embeddings = self.sbert_model.encode(
+                [sent1, sent2],
+                convert_to_tensor=True,
+                batch_size=32,
+            )
+            emb1, emb2 = embeddings
+            score = F.cosine_similarity(emb1, emb2, dim=0)
+            return round(score.item(), 4)
+
+        except Exception as e:
+            print(f"[ModelFunctions] SimilarityScore failed: {e}")
+            return 0.0
+
+    # ------------------------------------------------------------------
+    # Batch comparison — one forward pass for all candidates
+    # ------------------------------------------------------------------
+    def BatchSimilarityScores(self, original: str, candidates: list[str]) -> list[float]:
+        """
+        Compares `original` against every string in `candidates` in a
+        single encoding pass. Returns a list of scores in the same order.
+
+        Why this is faster than calling SimilarityScore() N times:
+        SentenceTransformer.encode() has per-call overhead (tokenization,
+        GPU dispatch). One call with N+1 sentences amortises that cost once.
+        """
+        if not isinstance(original, str) or not original.strip():
+            print("[ModelFunctions] BatchSimilarityScores: original must be a non-empty string.")
+            return [0.0] * len(candidates)
+
+        if not candidates:
+            return []
+
+        # Filter out any non-string or empty entries, track their positions
+        valid_candidates = []
+        index_map = []  # maps valid index → original index
+
+        for i, candidate in enumerate(candidates):
+            if isinstance(candidate, str) and candidate.strip():
+                valid_candidates.append(candidate)
+                index_map.append(i)
+            else:
+                print(f"[ModelFunctions] Skipping invalid candidate at index {i}.")
+
+        if not valid_candidates:
+            print("[ModelFunctions] No valid candidates to compare against.")
+            return [0.0] * len(candidates)
+
+        try:
+            all_texts = [original] + valid_candidates
+
+            embeddings = self.sbert_model.encode(
+                all_texts,
+                convert_to_tensor=True,
+                batch_size=64,
+                show_progress_bar=False,
+            )
+
+            orig_emb = embeddings[0]       # shape: (hidden,)
+            cand_embs = embeddings[1:]     # shape: (N, hidden)
+
+            scores = F.cosine_similarity(
+                orig_emb.unsqueeze(0).expand_as(cand_embs),
+                cand_embs,
+                dim=1,
+            )
+
+            # Rebuild full result list with 0.0 for skipped entries
+            result = [0.0] * len(candidates)
+            for valid_idx, original_idx in enumerate(index_map):
+                result[original_idx] = round(scores[valid_idx].item(), 4)
+
+            return result
+
+        except Exception as e:
+            print(f"[ModelFunctions] BatchSimilarityScores failed: {e}")
+            return [0.0] * len(candidates)

static/looks.css

@@ -0,0 +1,1075 @@
+/* =========================================
+   FactCheck AI — Design System
+   Aesthetic: Dark Editorial / Intelligence Briefing
+   ========================================= */
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+    --bg-deep:        #0b0d0f;
+    --bg-surface:     #111418;
+    --bg-elevated:    #181d23;
+    --bg-hover:       #1e242c;
+    --border:         rgba(255,255,255,0.07);
+    --border-bright:  rgba(255,255,255,0.14);
+
+    --text-primary:   #e8e6e1;
+    --text-secondary: #7a8898;
+    --text-muted:     #4a5568;
+
+    --accent:         #e8c547;
+    --accent-dim:     rgba(232,197,71,0.12);
+    --accent-glow:    rgba(232,197,71,0.25);
+
+    --green:          #3ecf8e;
+    --red:            #e85d4a;
+    --blue:           #5b9cf6;
+
+    --font-display:   'Playfair Display', Georgia, serif;
+    --font-mono:      'IBM Plex Mono', 'Courier New', monospace;
+    --font-body:      'IBM Plex Sans', system-ui, sans-serif;
+
+    --radius-sm:      4px;
+    --radius-md:      8px;
+    --radius-lg:      14px;
+
+    --sidebar-w:      230px;
+    --transition:     0.18s ease;
+}
+
+html, body {
+    height: 100%;
+    background: var(--bg-deep);
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    font-size: 15px;
+    line-height: 1.6;
+    -webkit-font-smoothing: antialiased;
+}
+
+/* ── Background ── */
+.bg-grid {
+    position: fixed; inset: 0; z-index: -1; pointer-events: none;
+    background-image:
+        linear-gradient(rgba(255,255,255,0.025) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255,255,255,0.025) 1px, transparent 1px);
+    background-size: 48px 48px;
+    mask-image: radial-gradient(ellipse 80% 80% at 50% 0%, black 40%, transparent 100%);
+}
+
+.bg-noise {
+    position: fixed; inset: 0; z-index: -1; pointer-events: none; opacity: 0.025;
+    background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 256 256' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='noise'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23noise)'/%3E%3C/svg%3E");
+}
+
+/* ── Layout ── */
+.app-wrapper {
+    position: relative;
+    display: flex;
+    height: 100dvh;
+    max-width: 1400px;
+    margin: 0 auto;
+}
+
+/* =========================================
+   SIDEBAR
+   ========================================= */
+.sidebar {
+    width: var(--sidebar-w);
+    flex-shrink: 0;
+    background: var(--bg-surface);
+    border-right: 1px solid var(--border);
+    display: flex;
+    flex-direction: column;
+    padding: 24px 16px;
+    gap: 0;
+}
+
+.sidebar-brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 0 6px 20px;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 20px;
+}
+
+.brand-mark {
+    font-size: 22px;
+    color: var(--accent);
+    line-height: 1;
+}
+
+.brand-name {
+    font-family: var(--font-mono);
+    font-size: 13px;
+    font-weight: 600;
+    letter-spacing: 0.03em;
+    color: var(--text-primary);
+}
+
+.brand-name em { font-style: normal; color: var(--accent); }
+
+.sidebar-info {
+    margin-bottom: 24px;
+    padding: 0 4px;
+}
+
+.sidebar-desc {
+    font-size: 13px;
+    color: var(--text-secondary);
+    line-height: 1.65;
+}
+
+/* How it works tips */
+.sidebar-tips {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    padding: 16px 12px;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-md);
+    margin-bottom: 20px;
+}
+
+.tips-label {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    letter-spacing: 0.12em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    display: block;
+    margin-bottom: 2px;
+}
+
+.tip-item {
+    display: flex;
+    gap: 10px;
+    align-items: flex-start;
+    font-size: 12.5px;
+    color: var(--text-secondary);
+    line-height: 1.5;
+}
+
+.tip-icon { font-size: 13px; flex-shrink: 0; margin-top: 1px; }
+.tip-item strong { color: var(--text-primary); font-weight: 500; }
+
+/* Bottom */
+.sidebar-status {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px 12px;
+    margin-top: auto;
+}
+
+.status-dot {
+    width: 7px; height: 7px;
+    border-radius: 50%;
+    background: var(--red);
+    box-shadow: 0 0 8px var(--red);
+    animation: pulse-dot 2.5s ease-in-out infinite;
+    transition: background 0.3s ease, box-shadow 0.3s ease;
+}
+
+@keyframes pulse-dot {
+    0%, 100% { opacity: 1; }
+    50%       { opacity: 0.4; }
+}
+
+.status-text {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+    letter-spacing: 0.04em;
+}
+
+.sidebar-link {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 12px;
+    border-radius: var(--radius-md);
+    color: var(--text-muted);
+    text-decoration: none;
+    font-size: 12px;
+    font-family: var(--font-mono);
+    transition: color var(--transition);
+}
+
+.sidebar-link:hover { color: var(--text-secondary); }
+
+/* =========================================
+   CHAT AREA
+   ========================================= */
+.chat-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    background: var(--bg-deep);
+}
+
+.chat-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px 28px;
+    border-bottom: 1px solid var(--border);
+    background: rgba(11,13,15,0.8);
+    backdrop-filter: blur(12px);
+    flex-shrink: 0;
+}
+
+.header-left { display: flex; align-items: baseline; gap: 14px; }
+
+.header-title {
+    font-family: var(--font-display);
+    font-size: 20px;
+    font-weight: 700;
+    color: var(--text-primary);
+    letter-spacing: -0.01em;
+}
+
+.header-session {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+    letter-spacing: 0.06em;
+}
+
+.clear-btn {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 12px;
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    background: transparent;
+    color: var(--text-muted);
+    font-size: 12px;
+    font-family: var(--font-mono);
+    cursor: pointer;
+    transition: all var(--transition);
+    letter-spacing: 0.04em;
+}
+
+.clear-btn:hover {
+    border-color: var(--red);
+    color: var(--red);
+    background: rgba(232,93,74,0.08);
+}
+
+/* ── Messages ── */
+.messages-container {
+    flex: 1;
+    overflow-y: auto;
+    padding: 32px 28px;
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+}
+
+.messages-container::-webkit-scrollbar { width: 4px; }
+.messages-container::-webkit-scrollbar-track { background: transparent; }
+.messages-container::-webkit-scrollbar-thumb { background: var(--border-bright); border-radius: 2px; }
+
+.message {
+    max-width: 760px;
+    opacity: 0;
+    transform: translateY(8px);
+    transition: opacity 0.25s ease, transform 0.25s ease;
+}
+
+.message.visible,
+.intro-message { opacity: 1; transform: translateY(0); }
+
+.fade-out {
+    opacity: 0 !important;
+    transform: translateY(-6px) !important;
+    transition: opacity 0.25s ease, transform 0.25s ease !important;
+}
+
+.message-meta {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 6px;
+}
+
+.msg-sender {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+}
+
+.msg-time {
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-muted);
+}
+
+.message-body {
+    padding: 16px 20px;
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--border);
+    line-height: 1.7;
+    font-size: 14.5px;
+}
+
+.message-body p + p { margin-top: 10px; }
+
+.bot-message { align-self: flex-start; }
+.bot-message .msg-sender { color: var(--accent); }
+.bot-message .message-body {
+    background: var(--bg-elevated);
+    border-color: var(--border-bright);
+    color: var(--text-primary);
+}
+
+.user-message { align-self: flex-end; }
+.user-message .msg-sender { color: var(--blue); }
+.user-message .message-body {
+    background: rgba(91,156,246,0.08);
+    border-color: rgba(91,156,246,0.2);
+    color: var(--text-primary);
+}
+
+.error-message .message-body {
+    background: rgba(232,93,74,0.07);
+    border-color: rgba(232,93,74,0.25);
+}
+
+/* No-key message — amber tint to signal action needed */
+.no-key-message .message-body {
+    background: var(--accent-dim);
+    border-color: rgba(232,197,71,0.22);
+}
+
+/* ── "Enter API Key" inline button ── */
+.enter-key-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 7px;
+    margin-top: 14px;
+    padding: 8px 16px;
+    background: var(--accent);
+    color: var(--bg-deep);
+    border: none;
+    border-radius: var(--radius-md);
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    letter-spacing: 0.04em;
+    cursor: pointer;
+    transition: all var(--transition);
+}
+
+.enter-key-btn:hover {
+    background: #f0d060;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 14px var(--accent-glow);
+}
+
+.enter-key-btn:active { transform: translateY(0); }
+
+/* Loading */
+.loading-message .message-body {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 14px 20px;
+}
+
+.typing-indicator { display: flex; align-items: center; gap: 5px; }
+
+.typing-indicator span {
+    display: block;
+    width: 6px; height: 6px;
+    border-radius: 50%;
+    background: var(--accent);
+    animation: bounce-dot 1.2s ease-in-out infinite;
+}
+
+.typing-indicator span:nth-child(2) { animation-delay: 0.15s; }
+.typing-indicator span:nth-child(3) { animation-delay: 0.3s; }
+
+@keyframes bounce-dot {
+    0%, 80%, 100% { transform: scale(0.7); opacity: 0.4; }
+    40%            { transform: scale(1);   opacity: 1;   }
+}
+
+.loading-text {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    color: var(--text-muted);
+    letter-spacing: 0.06em;
+    animation: flicker 1.5s ease-in-out infinite;
+}
+
+@keyframes flicker {
+    0%, 100% { opacity: 1; }
+    50%       { opacity: 0.4; }
+}
+
+/* =========================================
+   INPUT AREA
+   ========================================= */
+.input-area {
+    padding: 16px 28px 20px;
+    border-top: 1px solid var(--border);
+    background: rgba(11,13,15,0.88);
+    backdrop-filter: blur(12px);
+    flex-shrink: 0;
+}
+
+/* ── The main input box ── */
+.input-form {
+    display: flex;
+    align-items: center;
+    gap: 0;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-lg);
+    padding: 8px 10px 8px 10px;
+    transition: border-color var(--transition), box-shadow var(--transition);
+}
+
+.input-form:focus-within {
+    border-color: rgba(232,197,71,0.35);
+    box-shadow: 0 0 0 3px var(--accent-glow);
+}
+
+/* ── Mode pill toggle (inside input box) ── */
+.mode-pill {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    background: var(--bg-hover);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 3px;
+    flex-shrink: 0;
+}
+
+.pill-btn {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    padding: 5px 10px;
+    border: none;
+    border-radius: 6px;
+    background: transparent;
+    color: var(--text-muted);
+    font-family: var(--font-mono);
+    font-size: 11px;
+    font-weight: 500;
+    letter-spacing: 0.04em;
+    cursor: pointer;
+    transition: all var(--transition);
+    white-space: nowrap;
+}
+
+.pill-btn:hover {
+    color: var(--text-secondary);
+    background: rgba(255,255,255,0.05);
+}
+
+.pill-btn.active {
+    background: var(--accent);
+    color: var(--bg-deep);
+}
+
+.pill-btn.active svg { opacity: 1; }
+.pill-btn svg { opacity: 0.6; }
+
+/* ── Vertical divider between pill and textarea ── */
+.input-divider {
+    width: 1px;
+    height: 28px;
+    background: var(--border-bright);
+    margin: 0 12px;
+    flex-shrink: 0;
+}
+
+.textarea-wrap { flex: 1; }
+
+textarea#user-input {
+    width: 100%;
+    background: transparent;
+    border: none;
+    outline: none;
+    resize: none;
+    color: var(--text-primary);
+    font-family: var(--font-body);
+    font-size: 14.5px;
+    line-height: 1.6;
+    min-height: 26px;
+    max-height: 160px;
+    overflow-y: auto;
+    caret-color: var(--accent);
+    padding: 2px 0;
+}
+
+textarea#user-input::placeholder { color: var(--text-muted); }
+
+/* ── Send button ── */
+#send-btn {
+    flex-shrink: 0;
+    width: 36px; height: 36px;
+    border-radius: var(--radius-md);
+    border: none;
+    background: var(--accent);
+    color: var(--bg-deep);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    margin-left: 10px;
+    transition: all var(--transition);
+}
+
+#send-btn:hover {
+    background: #f0d060;
+    transform: scale(1.06);
+    box-shadow: 0 4px 16px var(--accent-glow);
+}
+
+#send-btn:active { transform: scale(0.96); }
+
+.input-hint {
+    margin-top: 8px;
+    font-size: 11px;
+    font-family: var(--font-mono);
+    color: var(--text-muted);
+    letter-spacing: 0.03em;
+}
+
+kbd {
+    display: inline-block;
+    padding: 1px 5px;
+    background: var(--bg-hover);
+    border: 1px solid var(--border-bright);
+    border-radius: 3px;
+    font-family: var(--font-mono);
+    font-size: 10px;
+    color: var(--text-secondary);
+}
+
+/* =========================================
+   API KEY MODAL
+   ========================================= */
+.modal-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: 200;
+    background: rgba(11, 13, 15, 0.82);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 24px;
+    opacity: 0;
+    transition: opacity 0.25s ease;
+}
+
+.modal-overlay.visible { opacity: 1; }
+.modal-overlay.hidden  { display: none; }
+
+.modal-card {
+    position: relative;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-lg);
+    padding: 32px 30px 28px;
+    width: 100%;
+    max-width: 500px;
+    box-shadow: 0 32px 80px rgba(0,0,0,0.7), 0 0 0 1px rgba(232,197,71,0.06);
+    animation: modal-rise 0.28s ease forwards;
+}
+
+@keyframes modal-rise {
+    from { transform: translateY(12px); opacity: 0; }
+    to   { transform: translateY(0);    opacity: 1; }
+}
+
+/* Close button */
+.modal-close {
+    position: absolute;
+    top: 16px;
+    right: 16px;
+    width: 28px;
+    height: 28px;
+    background: var(--bg-hover);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    color: var(--text-muted);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all var(--transition);
+}
+
+.modal-close:hover {
+    border-color: var(--red);
+    color: var(--red);
+    background: rgba(232,93,74,0.08);
+}
+
+/* Header */
+.modal-header {
+    display: flex;
+    align-items: flex-start;
+    gap: 14px;
+    margin-bottom: 20px;
+}
+
+.modal-icon {
+    font-size: 26px;
+    line-height: 1;
+    margin-top: 2px;
+    flex-shrink: 0;
+}
+
+.modal-title {
+    font-family: var(--font-display);
+    font-size: 20px;
+    font-weight: 700;
+    color: var(--text-primary);
+    letter-spacing: -0.01em;
+    line-height: 1.2;
+}
+
+.modal-subtitle {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+    margin-top: 4px;
+    letter-spacing: 0.04em;
+}
+
+/* Divider */
+.modal-divider {
+    height: 1px;
+    background: var(--border);
+    margin-bottom: 20px;
+}
+
+/* Description text */
+.modal-desc {
+    font-size: 13.5px;
+    color: var(--text-secondary);
+    line-height: 1.65;
+    margin-bottom: 18px;
+}
+
+.modal-desc strong { color: var(--text-primary); font-weight: 500; }
+
+.modal-link {
+    color: var(--accent);
+    text-decoration: none;
+    border-bottom: 1px solid rgba(232,197,71,0.3);
+    transition: border-color var(--transition);
+}
+
+.modal-link:hover { border-color: var(--accent); }
+
+/* Input wrapper */
+.modal-input-wrap {
+    position: relative;
+    margin-bottom: 10px;
+}
+
+.modal-input {
+    width: 100%;
+    background: var(--bg-deep);
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-md);
+    padding: 11px 44px 11px 14px;
+    color: var(--text-primary);
+    font-family: var(--font-mono);
+    font-size: 13px;
+    letter-spacing: 0.04em;
+    outline: none;
+    transition: border-color var(--transition), box-shadow var(--transition);
+    caret-color: var(--accent);
+}
+
+.modal-input:focus {
+    border-color: rgba(232,197,71,0.4);
+    box-shadow: 0 0 0 3px var(--accent-glow);
+}
+
+.modal-input::placeholder { color: var(--text-muted); }
+
+/* Toggle visibility button */
+.modal-eye {
+    position: absolute;
+    right: 12px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: 4px;
+    display: flex;
+    align-items: center;
+    transition: color var(--transition);
+}
+
+.modal-eye:hover { color: var(--text-secondary); }
+
+/* Status message */
+.modal-status {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    letter-spacing: 0.03em;
+    line-height: 1.5;
+    min-height: 18px;
+    margin-bottom: 14px;
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+
+.modal-status--visible { opacity: 1; }
+.modal-status--error   { color: var(--red); }
+.modal-status--success { color: var(--green); }
+
+/* Privacy note */
+.modal-privacy {
+    display: flex;
+    align-items: flex-start;
+    gap: 8px;
+    padding: 10px 12px;
+    background: var(--bg-deep);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    margin-bottom: 20px;
+    color: var(--text-muted);
+    font-size: 12px;
+    font-family: var(--font-mono);
+    line-height: 1.5;
+    letter-spacing: 0.02em;
+}
+
+.modal-privacy svg { flex-shrink: 0; margin-top: 2px; color: var(--accent); opacity: 0.7; }
+
+/* Actions row */
+.modal-actions {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.modal-btn-skip {
+    flex: 0 0 auto;
+    padding: 9px 18px;
+    background: transparent;
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-md);
+    color: var(--text-muted);
+    font-family: var(--font-mono);
+    font-size: 12px;
+    cursor: pointer;
+    transition: all var(--transition);
+    letter-spacing: 0.04em;
+}
+
+.modal-btn-skip:hover {
+    color: var(--text-secondary);
+    border-color: rgba(255,255,255,0.2);
+}
+
+.modal-btn-submit {
+    flex: 1;
+    padding: 10px 20px;
+    background: var(--accent);
+    border: none;
+    border-radius: var(--radius-md);
+    color: var(--bg-deep);
+    font-family: var(--font-mono);
+    font-size: 12px;
+    font-weight: 600;
+    letter-spacing: 0.05em;
+    cursor: pointer;
+    transition: all var(--transition);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    min-height: 40px;
+}
+
+.modal-btn-submit:hover:not(:disabled) {
+    background: #f0d060;
+    box-shadow: 0 4px 18px var(--accent-glow);
+    transform: translateY(-1px);
+}
+
+.modal-btn-submit:disabled {
+    opacity: 0.65;
+    cursor: not-allowed;
+    transform: none;
+}
+
+/* Spinner (reuse typing-indicator style) */
+.modal-spinner {
+    display: none;
+    align-items: center;
+    gap: 4px;
+}
+
+.modal-spinner span {
+    display: block;
+    width: 5px; height: 5px;
+    border-radius: 50%;
+    background: var(--bg-deep);
+    animation: bounce-dot 1.2s ease-in-out infinite;
+}
+
+.modal-spinner span:nth-child(2) { animation-delay: 0.15s; }
+.modal-spinner span:nth-child(3) { animation-delay: 0.3s; }
+
+/* =========================================
+   TASK 1 — MODAL ADDITIONS (two-section)
+   ========================================= */
+
+/* Increase card width slightly for two sections */
+.modal-card {
+    max-width: 500px;
+    max-height: 92vh;
+    overflow-y: auto;
+    scrollbar-width: thin;
+    scrollbar-color: var(--border-bright) transparent;
+}
+
+.modal-card::-webkit-scrollbar { width: 4px; }
+.modal-card::-webkit-scrollbar-track { background: transparent; }
+.modal-card::-webkit-scrollbar-thumb { background: var(--border-bright); border-radius: 2px; }
+
+/* Section wrapper */
+.modal-section {
+    margin-bottom: 4px;
+}
+
+.modal-section-head {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 6px;
+}
+
+.modal-section-label {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.1em;
+    text-transform: uppercase;
+    color: var(--text-primary);
+}
+
+/* Badges */
+.modal-badge {
+    font-family: var(--font-mono);
+    font-size: 9px;
+    padding: 2px 7px;
+    border-radius: 3px;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    font-weight: 600;
+}
+
+.modal-badge--required {
+    background: rgba(232, 93, 74, 0.12);
+    color: var(--red);
+    border: 1px solid rgba(232, 93, 74, 0.25);
+}
+
+.modal-badge--indimodel {
+    background: rgba(91, 156, 246, 0.1);
+    color: var(--blue);
+    border: 1px solid rgba(91, 156, 246, 0.2);
+}
+
+/* Provider selector row */
+.provider-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    margin-bottom: 10px;
+}
+
+.provider-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    padding: 5px 11px;
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-sm);
+    background: var(--bg-deep);
+    color: var(--text-muted);
+    font-family: var(--font-mono);
+    font-size: 11px;
+    letter-spacing: 0.03em;
+    cursor: pointer;
+    transition: all var(--transition);
+    white-space: nowrap;
+}
+
+.provider-btn:hover {
+    color: var(--text-secondary);
+    border-color: rgba(255, 255, 255, 0.2);
+    background: var(--bg-hover);
+}
+
+.provider-btn.active {
+    background: var(--accent-dim);
+    border-color: rgba(232, 197, 71, 0.4);
+    color: var(--accent);
+}
+
+.rec-tag {
+    font-size: 9px;
+    padding: 1px 5px;
+    background: rgba(232, 197, 71, 0.14);
+    border: 1px solid rgba(232, 197, 71, 0.2);
+    border-radius: 3px;
+    color: var(--accent);
+    letter-spacing: 0.04em;
+    font-weight: 600;
+}
+
+/* =========================================
+   TASK 2 — MODEL SELECTOR
+   ========================================= */
+.model-selector {
+    display: flex;
+    align-items: center;
+    gap: 7px;
+}
+
+.model-selector-label {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+
+.model-select {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    background: var(--bg-elevated);
+    border: 1px solid var(--border-bright);
+    border-radius: var(--radius-sm);
+    color: var(--text-secondary);
+    padding: 4px 10px 4px 8px;
+    cursor: pointer;
+    outline: none;
+    letter-spacing: 0.04em;
+    transition: border-color var(--transition), box-shadow var(--transition);
+    appearance: auto;
+}
+
+.model-select:hover {
+    border-color: rgba(255, 255, 255, 0.2);
+}
+
+.model-select:focus {
+    border-color: rgba(232, 197, 71, 0.4);
+    box-shadow: 0 0 0 2px var(--accent-glow);
+}
+
+/* =========================================
+   RESPONSIVE
+   ========================================= */
+@media (max-width: 700px) {
+    /* ── Sidebar: hidden by default on mobile ── */
+    .sidebar {
+        display: none;
+    }
+
+    /* ── Task 3: sidebar slides in when .mobile-open is added ── */
+    .sidebar.mobile-open {
+        display: flex;
+        position: fixed;
+        top: 0;
+        left: 0;
+        bottom: 0;
+        width: var(--sidebar-w);
+        z-index: 9999;
+        box-shadow: 6px 0 32px rgba(0, 0, 0, 0.6);
+        animation: sidebar-slide-in 0.22s ease forwards;
+    }
+
+    .sidebar-backdrop.active {
+        display: block;
+        animation: backdrop-fade-in 0.22s ease forwards;
+    }
+
+    /* ── Task 3: make title look tappable ── */
+    .header-title {
+        cursor: pointer;
+        user-select: none;
+        -webkit-user-select: none;
+    }
+
+    .header-title::after {
+        content: ' \2630';
+        font-size: 13px;
+        opacity: 0.45;
+        margin-left: 4px;
+    }
+
+    /* ── General mobile tweaks ── */
+    .chat-header       { padding: 12px 16px; }
+    .messages-container { padding: 20px 16px; }
+    .input-area        { padding: 12px 16px 16px; }
+    .pill-btn          { padding: 5px 8px; font-size: 10px; }
+
+    .modal-card        { padding: 20px 18px 18px; max-width: 100%; }
+    .modal-title       { font-size: 18px; }
+
+    .provider-row      { gap: 5px; }
+    .provider-btn      { font-size: 10px; padding: 4px 8px; }
+    .rec-tag           { display: none; }
+}
+
+/* Desktop: hide backdrop always */
+@media (min-width: 701px) {
+    .sidebar-backdrop  { display: none !important; }
+    .header-title      { cursor: default; }
+}
+
+/* ── Sidebar slide animation (global — outside media query for browser compat) ── */
+@keyframes sidebar-slide-in {
+    from { transform: translateX(-100%); opacity: 0.6; }
+    to   { transform: translateX(0);     opacity: 1; }
+}
+
+@keyframes backdrop-fade-in {
+    from { opacity: 0; }
+    to   { opacity: 1; }
+}
+
+/* Backdrop base — hidden on all screens by default, activated via JS class */
+.sidebar-backdrop {
+    display: none;
+    position: fixed;
+    inset: 0;
+    z-index: 9998;
+    background: rgba(0, 0, 0, 0.55);
+    backdrop-filter: blur(3px);
+    -webkit-backdrop-filter: blur(3px);
+}
+
+.sidebar-backdrop.active {
+    display: block;
+    animation: backdrop-fade-in 0.22s ease forwards;
+}

templates/index.html

@@ -0,0 +1,771 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FactCheck AI — News Verification System</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=Playfair+Display:wght@700;900&family=IBM+Plex+Sans:wght@300;400;500&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="{{ url_for('static', path='/looks.css') }}">
+</head>
+<body>
+
+    <div class="bg-grid" aria-hidden="true"></div>
+    <div class="bg-noise" aria-hidden="true"></div>
+
+    <!-- ════════════════════════════════════════
+         API KEY MODAL  (Task 1 — two sections)
+         ════════════════════════════════════════ -->
+    <div class="modal-overlay" id="api-modal" role="dialog" aria-modal="true" aria-labelledby="modal-title">
+        <div class="modal-card">
+
+            <!-- Close / skip -->
+            <button class="modal-close" id="modal-skip" aria-label="Skip for now">
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+            </button>
+
+            <!-- Header -->
+            <div class="modal-header">
+                <span class="modal-icon">&#128273;</span>
+                <div>
+                    <h2 class="modal-title" id="modal-title">Configure API Keys</h2>
+                    <p class="modal-subtitle">Connect your Search and LLM APIs to enable verification</p>
+                </div>
+            </div>
+
+            <div class="modal-divider"></div>
+
+            <!-- ── SECTION 1: Search API ── -->
+            <div class="modal-section">
+                <div class="modal-section-head">
+                    <span class="modal-section-label">Search API</span>
+                    <span class="modal-badge modal-badge--required">Required</span>
+                </div>
+                <p class="modal-desc">
+                    Used to retrieve live sources for claim verification.
+                    Recommended: <a href="https://serper.dev" target="_blank" rel="noopener" class="modal-link">serper.dev</a> (free tier available).
+                </p>
+
+                <!-- Provider selector buttons -->
+                <div class="provider-row" id="search-provider-row">
+                    <button type="button" class="provider-btn active" data-provider="serper.dev">
+                        serper.dev<span class="rec-tag">Recommended</span>
+                    </button>
+                    <button type="button" class="provider-btn" data-provider="gnews">gnews</button>
+                    <button type="button" class="provider-btn" data-provider="publicapi.dev">publicapi.dev</button>
+                </div>
+
+                <!-- Key input -->
+                <div class="modal-input-wrap">
+                    <input
+                        type="password"
+                        id="search-key-input"
+                        class="modal-input"
+                        placeholder="Enter your Search API key&#8230;"
+                        autocomplete="off"
+                        spellcheck="false"
+                    />
+                    <button class="modal-eye" id="toggle-search-vis" aria-label="Toggle key visibility" type="button">
+                        <svg id="search-eye-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/>
+                        </svg>
+                    </button>
+                </div>
+                <div class="modal-status" id="search-modal-status" aria-live="polite"></div>
+            </div>
+
+            <div class="modal-divider"></div>
+
+            <!-- ── SECTION 2: LLM API ── -->
+            <div class="modal-section">
+                <div class="modal-section-head">
+                    <span class="modal-section-label">LLM API</span>
+                    <span class="modal-badge modal-badge--indimodel">Required</span>
+                </div>
+                <p class="modal-desc">
+                    Powers IndiModel's analysis and trust-scoring.
+                    Recommended: <a href="https://console.groq.com" target="_blank" rel="noopener" class="modal-link">groq</a> (fast inference, free tier).
+                </p>
+
+                <!-- Provider selector buttons -->
+                <div class="provider-row" id="llm-provider-row">
+                    <button type="button" class="provider-btn active" data-provider="groq">
+                        groq<span class="rec-tag">Recommended</span>
+                    </button>
+                    <button type="button" class="provider-btn" data-provider="anthropic">anthropic</button>
+                    <button type="button" class="provider-btn" data-provider="openai">openai</button>
+                    <button type="button" class="provider-btn" data-provider="google">google</button>
+                </div>
+
+                <!-- Key input -->
+                <div class="modal-input-wrap">
+                    <input
+                        type="password"
+                        id="llm-key-input"
+                        class="modal-input"
+                        placeholder="Enter your LLM API key&#8230;"
+                        autocomplete="off"
+                        spellcheck="false"
+                    />
+                    <button class="modal-eye" id="toggle-llm-vis" aria-label="Toggle key visibility" type="button">
+                        <svg id="llm-eye-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/>
+                        </svg>
+                    </button>
+                </div>
+                <div class="modal-status" id="llm-modal-status" aria-live="polite"></div>
+            </div>
+
+            <!-- Privacy note -->
+            <div class="modal-privacy">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>
+                <span>All keys stored in session memory only — cleared when you close or refresh this page</span>
+            </div>
+
+            <!-- Actions -->
+            <div class="modal-actions">
+                <button class="modal-btn-skip" id="modal-skip-2">Skip for now</button>
+                <button class="modal-btn-submit" id="modal-submit" type="button">
+                    <span id="submit-label">Validate &amp; Connect</span>
+                    <div class="modal-spinner" id="modal-spinner" aria-hidden="true">
+                        <span></span><span></span><span></span>
+                    </div>
+                </button>
+            </div>
+
+        </div>
+    </div>
+    <!-- ════ END MODAL ════ -->
+
+    <!-- Task 3 — Mobile sidebar backdrop overlay -->
+    <div class="sidebar-backdrop" id="sidebar-backdrop"></div>
+
+    <div class="app-wrapper">
+
+        <!-- ── Sidebar ── -->
+        <aside class="sidebar" id="sidebar">
+            <div class="sidebar-brand">
+                <span class="brand-mark">&#11041;</span>
+                <span class="brand-name">FactCheck<em>AI</em></span>
+            </div>
+
+            <div class="sidebar-info">
+                <p class="sidebar-desc">Submit a claim or paste an article URL. The AI will analyze the content and tell you whether you should trust it.</p>
+            </div>
+
+            <div class="sidebar-tips">
+                <span class="tips-label">How it works</span>
+                <div class="tip-item">
+                    <span class="tip-icon">&#128269;</span>
+                    <span>Use <strong>query</strong> for claims, headlines, or facts you want verified</span>
+                </div>
+                <div class="tip-item">
+                    <span class="tip-icon">&#128279;</span>
+                    <span>Use <strong>Article</strong> and paste a URL to analyze a full news article</span>
+                </div>
+                <div class="tip-item">
+                    <span class="tip-icon">&#9989;</span>
+                    <span>Get a trust verdict with reasoning and source context</span>
+                </div>
+            </div>
+
+            <div class="sidebar-status">
+                <span class="status-dot" id="api-status-dot"></span>
+                <span class="status-text" id="api-status-text">Awaiting API Key</span>
+            </div>
+
+            <a class="sidebar-link" href="https://github.com/vishwjeet71" target="_blank" rel="noopener noreferrer">
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor"><path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0 0 24 12c0-6.63-5.37-12-12-12z"/></svg>
+                Documentation
+            </a>
+        </aside>
+
+        <!-- ── Main chat ── -->
+        <main class="chat-area">
+
+            <header class="chat-header">
+                <div class="header-left">
+                    <!-- Task 3: clicking title on mobile opens sidebar -->
+                    <h1 class="header-title" id="header-title">News Verification</h1>
+                    <!-- Task 2: model dropdown replaces session ID -->
+                    <div class="model-selector">
+                        <span class="model-selector-label">Model</span>
+                        <select id="model-select" class="model-select" aria-label="Select model">
+                            <option value="prototype">Prototype</option>
+                            <option value="indimodel">IndiModel</option>
+                        </select>
+                    </div>
+                </div>
+                <button class="clear-btn" id="clear-chat" title="Clear conversation">
+                    <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14H6L5 6"/><path d="M10 11v6M14 11v6"/><path d="M9 6V4h6v2"/></svg>
+                    Clear
+                </button>
+            </header>
+
+            <div class="messages-container" id="chat-messages" role="log" aria-live="polite">
+                <div class="message bot-message intro-message">
+                    <div class="message-meta">
+                        <span class="msg-sender">FactCheck AI</span>
+                        <span class="msg-time" data-time="now"></span>
+                    </div>
+                    <div class="message-body">
+                        <p>Welcome. Use the <strong>query / Article</strong> toggle in the input box below to choose your mode, then submit your content. I'll analyze it and give you a clear trust verdict.</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ── Input Footer ── -->
+            <footer class="input-area">
+                <form id="chat-form" class="input-form" autocomplete="off">
+
+                    <div class="mode-pill">
+                        <button type="button" class="pill-btn active" id="btn-query">
+                            <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/></svg>
+                            query
+                        </button>
+                        <button type="button" class="pill-btn" id="btn-article">
+                            <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/></svg>
+                            Article
+                        </button>
+                    </div>
+
+                    <div class="input-divider" aria-hidden="true"></div>
+
+                    <div class="textarea-wrap">
+                        <textarea
+                            id="user-input"
+                            placeholder="Enter a claim or headline to verify..."
+                            rows="1"
+                            aria-label="Message input"
+                            required
+                        ></textarea>
+                    </div>
+
+                    <button type="submit" id="send-btn" aria-label="Send">
+                        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" width="17" height="17">
+                            <path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"/>
+                        </svg>
+                    </button>
+                </form>
+                <p class="input-hint"><kbd>Enter</kbd> to send &nbsp;&middot;&nbsp; <kbd>Shift+Enter</kbd> for new line</p>
+            </footer>
+
+        </main>
+    </div>
+
+    <script>
+    document.addEventListener('DOMContentLoaded', () => {
+
+        // ══════════════════════════════════════════
+        //  STATE  (all session memory — clears on refresh)
+        // ══════════════════════════════════════════
+        let searchApiKey      = null;
+        let searchApiProvider = 'serper.dev';
+        let llmApiKey         = null;
+        let llmApiProvider    = 'groq';
+
+        // ══════════════════════════════════════════
+        //  DOM REFS
+        // ══════════════════════════════════════════
+        const apiModal          = document.getElementById('api-modal');
+        const modalSubmit       = document.getElementById('modal-submit');
+        const modalSkip         = document.getElementById('modal-skip');
+        const modalSkip2        = document.getElementById('modal-skip-2');
+        const modalSpinner      = document.getElementById('modal-spinner');
+        const submitLabel       = document.getElementById('submit-label');
+
+        const searchKeyInput    = document.getElementById('search-key-input');
+        const llmKeyInput       = document.getElementById('llm-key-input');
+        const searchModalStatus = document.getElementById('search-modal-status');
+        const llmModalStatus    = document.getElementById('llm-modal-status');
+        const toggleSearchVis   = document.getElementById('toggle-search-vis');
+        const toggleLLMVis      = document.getElementById('toggle-llm-vis');
+        const searchEyeIcon     = document.getElementById('search-eye-icon');
+        const llmEyeIcon        = document.getElementById('llm-eye-icon');
+
+        const apiStatusDot      = document.getElementById('api-status-dot');
+        const apiStatusText     = document.getElementById('api-status-text');
+
+        const chatMessages      = document.getElementById('chat-messages');
+        const chatForm          = document.getElementById('chat-form');
+        const userInput         = document.getElementById('user-input');
+        const btnquery          = document.getElementById('btn-query');
+        const btnArticle        = document.getElementById('btn-article');
+        const clearBtn          = document.getElementById('clear-chat');
+        const modelSelect       = document.getElementById('model-select');
+
+        // Task 3
+        const sidebar           = document.getElementById('sidebar');
+        const sidebarBackdrop   = document.getElementById('sidebar-backdrop');
+        const headerTitle       = document.getElementById('header-title');
+
+        // ── Init ──
+        document.querySelectorAll('[data-time="now"]').forEach(el => el.textContent = getTime());
+
+        // ══════════════════════════════════════════
+        //  TASK 3 — MOBILE SIDEBAR TOGGLE
+        // ══════════════════════════════════════════
+        function isMobile() { return window.innerWidth <= 700; }
+
+        function openSidebar() {
+            sidebar.classList.add('mobile-open');
+            sidebarBackdrop.classList.add('active');
+        }
+
+        function closeSidebar() {
+            sidebar.classList.remove('mobile-open');
+            sidebarBackdrop.classList.remove('active');
+        }
+
+        headerTitle.addEventListener('click', () => {
+            if (!isMobile()) return;
+            sidebar.classList.contains('mobile-open') ? closeSidebar() : openSidebar();
+        });
+
+        sidebarBackdrop.addEventListener('click', closeSidebar);
+
+        window.addEventListener('resize', () => {
+            if (!isMobile()) closeSidebar();
+        });
+
+        // ══════════════════════════════════════════
+        //  MODAL — Open / Close
+        // ══════════════════════════════════════════
+        function openModal() {
+            apiModal.classList.remove('hidden');
+            requestAnimationFrame(() => apiModal.classList.add('visible'));
+            searchKeyInput.focus();
+            clearAllModalStatus();
+        }
+
+        function closeModal() {
+            apiModal.classList.remove('visible');
+            setTimeout(() => apiModal.classList.add('hidden'), 250);
+        }
+
+        openModal();
+
+        modalSkip.addEventListener('click',  handleSkip);
+        modalSkip2.addEventListener('click', handleSkip);
+
+        function handleSkip() {
+            searchApiKey = null;
+            llmApiKey    = null;
+            updateSidebarStatus(false, false);
+            closeModal();
+        }
+
+        apiModal.addEventListener('click', (e) => {
+            if (e.target === apiModal) handleSkip();
+        });
+
+        // ══════════════════════════════════════════
+        //  TASK 1 — PROVIDER BUTTONS
+        // ══════════════════════════════════════════
+        document.querySelectorAll('#search-provider-row .provider-btn').forEach(btn => {
+            btn.addEventListener('click', () => {
+                document.querySelectorAll('#search-provider-row .provider-btn')
+                    .forEach(b => b.classList.remove('active'));
+                btn.classList.add('active');
+                searchApiProvider = btn.dataset.provider;
+                clearSectionStatus('search');
+            });
+        });
+
+        document.querySelectorAll('#llm-provider-row .provider-btn').forEach(btn => {
+            btn.addEventListener('click', () => {
+                document.querySelectorAll('#llm-provider-row .provider-btn')
+                    .forEach(b => b.classList.remove('active'));
+                btn.classList.add('active');
+                llmApiProvider = btn.dataset.provider;
+                clearSectionStatus('llm');
+            });
+        });
+
+        // ── Eye icon toggles ──
+        toggleSearchVis.addEventListener('click', () => toggleEye(searchKeyInput, searchEyeIcon));
+        toggleLLMVis.addEventListener('click',    () => toggleEye(llmKeyInput,    llmEyeIcon));
+
+        function toggleEye(input, icon) {
+            const isPass  = input.type === 'password';
+            input.type    = isPass ? 'text' : 'password';
+            icon.innerHTML = isPass
+                ? '<path d="M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24"/><line x1="1" y1="1" x2="23" y2="23"/>'
+                : '<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/>';
+        }
+
+        // ══════════════════════════════════════════
+        //  TASK 1 — VALIDATE & SAVE
+        // ══════════════════════════════════════════
+        modalSubmit.addEventListener('click', validateAndSave);
+        searchKeyInput.addEventListener('keydown', e => { if (e.key === 'Enter') validateAndSave(); });
+        llmKeyInput.addEventListener('keydown',    e => { if (e.key === 'Enter') validateAndSave(); });
+
+        async function validateAndSave() {
+            const sKey = searchKeyInput.value.trim();
+            const lKey = llmKeyInput.value.trim();
+
+            if (!sKey) {
+                setSectionStatus('search', 'error', '&#9888;&#65039; Please enter a Search API key.');
+                return;
+            }
+            if (sKey.length < 20) {
+                setSectionStatus('search', 'error', '&#9888;&#65039; That key looks too short — check it and try again.');
+                return;
+            }
+            if (lKey && lKey.length < 20) {
+                setSectionStatus('llm', 'error', '&#9888;&#65039; That LLM key looks too short — check it and try again.');
+                return;
+            }
+
+            setLoading(true);
+            clearAllModalStatus();
+
+            const searchOk = await validateSearchKey(sKey, searchApiProvider);
+            if (!searchOk) { setLoading(false); return; }
+
+            if (lKey) {
+                const llmOk = await validateLLMKey(lKey, llmApiProvider);
+                if (!llmOk) { setLoading(false); return; }
+            }
+
+            setLoading(false);
+            updateSidebarStatus(true, !!llmApiKey);
+            setTimeout(() => closeModal(), 900);
+        }
+
+        async function validateSearchKey(key, provider) {
+            try {
+                let res;
+                if (provider === 'serper.dev') {
+                    res = await fetch('https://google.serper.dev/search', {
+                        method:  'POST',
+                        headers: { 'X-API-KEY': key, 'Content-Type': 'application/json' },
+                        body:    JSON.stringify({ q: 'test', num: 1 })
+                    });
+                } else if (provider === 'gnews') {
+                    res = await fetch(
+                        'https://gnews.io/api/v4/top-headlines?token=' + encodeURIComponent(key) + '&max=1&lang=en'
+                    );
+                } else if (provider === 'publicapi.dev') {
+                    // No CORS-friendly validation endpoint available — accept on format
+                    searchApiKey = key;
+                    setSectionStatus('search', 'success', '&#9989; Key saved for publicapi.dev.');
+                    return true;
+                }
+
+                if (res.ok) {
+                    searchApiKey = key;
+                    setSectionStatus('search', 'success', '&#9989; Search API key validated.');
+                    return true;
+                } else if (res.status === 401 || res.status === 403) {
+                    setSectionStatus('search', 'error', '&#10060; Invalid key — access denied. Double-check and retry.');
+                    return false;
+                } else if (res.status === 429) {
+                    setSectionStatus('search', 'error', '&#9888;&#65039; Rate limit hit on this key. Wait a moment then retry.');
+                    return false;
+                } else {
+                    setSectionStatus('search', 'error', '&#10060; Unexpected error (HTTP ' + res.status + ').');
+                    return false;
+                }
+            } catch (err) {
+                // CORS or network — save key, tested on first chat request
+                searchApiKey = key;
+                setSectionStatus('search', 'success', '&#9989; Key saved. Remote validation blocked by browser security — will be tested on first request.');
+                return true;
+            }
+        }
+
+        async function validateLLMKey(key, provider) {
+            try {
+                let res;
+                if (provider === 'groq') {
+                    res = await fetch('https://api.groq.com/openai/v1/models', {
+                        headers: { 'Authorization': 'Bearer ' + key }
+                    });
+                } else if (provider === 'openai') {
+                    res = await fetch('https://api.openai.com/v1/models', {
+                        headers: { 'Authorization': 'Bearer ' + key }
+                    });
+                } else if (provider === 'anthropic') {
+                    if (!key.startsWith('sk-ant-')) {
+                        setSectionStatus('llm', 'error', '&#9888;&#65039; Anthropic keys must start with "sk-ant-". Check your key.');
+                        return false;
+                    }
+                    llmApiKey = key;
+                    setSectionStatus('llm', 'success', '&#9989; Anthropic key format valid and saved.');
+                    return true;
+                } else if (provider === 'google') {
+                    if (!key.startsWith('AIza')) {
+                        setSectionStatus('llm', 'error', '&#9888;&#65039; Google API keys must start with "AIza". Check your key.');
+                        return false;
+                    }
+                    llmApiKey = key;
+                    setSectionStatus('llm', 'success', '&#9989; Google key format valid and saved.');
+                    return true;
+                }
+
+                if (res.ok) {
+                    llmApiKey = key;
+                    setSectionStatus('llm', 'success', '&#9989; LLM API key validated.');
+                    return true;
+                } else if (res.status === 401 || res.status === 403) {
+                    setSectionStatus('llm', 'error', '&#10060; Invalid LLM key — access denied. Double-check and retry.');
+                    return false;
+                } else {
+                    setSectionStatus('llm', 'error', '&#10060; Unexpected error (HTTP ' + res.status + ').');
+                    return false;
+                }
+            } catch (err) {
+                llmApiKey = key;
+                setSectionStatus('llm', 'success', '&#9989; Key saved. Remote validation blocked by browser security — will be tested on first request.');
+                return true;
+            }
+        }
+
+        function setLoading(on) {
+            modalSpinner.style.display = on ? 'flex' : 'none';
+            submitLabel.style.display  = on ? 'none' : 'inline';
+            modalSubmit.disabled       = on;
+            searchKeyInput.disabled    = on;
+            llmKeyInput.disabled       = on;
+        }
+
+        function setSectionStatus(section, type, msg) {
+            const el       = section === 'search' ? searchModalStatus : llmModalStatus;
+            el.innerHTML   = msg;
+            el.className   = 'modal-status modal-status--' + type + ' modal-status--visible';
+        }
+
+        function clearSectionStatus(section) {
+            const el     = section === 'search' ? searchModalStatus : llmModalStatus;
+            el.innerHTML = '';
+            el.className = 'modal-status';
+        }
+
+        function clearAllModalStatus() {
+            clearSectionStatus('search');
+            clearSectionStatus('llm');
+        }
+
+        function updateSidebarStatus(searchConnected, llmConnected) {
+            if (searchConnected && llmConnected) {
+                apiStatusDot.style.background = 'var(--green)';
+                apiStatusDot.style.boxShadow  = '0 0 8px var(--green)';
+                apiStatusText.textContent     = 'Search + LLM Connected';
+            } else if (searchConnected) {
+                apiStatusDot.style.background = 'var(--green)';
+                apiStatusDot.style.boxShadow  = '0 0 8px var(--green)';
+                apiStatusText.textContent     = 'Search Connected';
+            } else {
+                apiStatusDot.style.background = 'var(--red)';
+                apiStatusDot.style.boxShadow  = '0 0 8px var(--red)';
+                apiStatusText.textContent     = 'No API Key';
+            }
+        }
+
+        // ══════════════════════════════════════════
+        //  TASK 2 — MODEL SELECTOR
+        // ══════════════════════════════════════════
+        modelSelect.addEventListener('change', () => {
+            if (modelSelect.value === 'indimodel' && (!searchApiKey || !llmApiKey)) {
+                clearAllModalStatus();
+                openModal();
+            }
+        });
+
+        // ══════════════════════════════════════════
+        //  MODE TOGGLE  (query / Article)
+        // ══════════════════════════════════════════
+        let inputType = 'query';
+
+        function setMode(type) {
+            inputType = type;
+            const isquery = type === 'query';
+            btnquery.classList.toggle('active', isquery);
+            btnArticle.classList.toggle('active', !isquery);
+            userInput.placeholder = isquery
+                ? 'Enter a claim or headline to verify...'
+                : 'Paste an article URL here...';
+            userInput.focus();
+        }
+
+        btnquery.addEventListener('click',   () => setMode('query'));
+        btnArticle.addEventListener('click', () => setMode('article_link'));
+
+        clearBtn.addEventListener('click', () => {
+            chatMessages.querySelectorAll('.message:not(.intro-message)').forEach(m => {
+                m.classList.add('fade-out');
+                setTimeout(() => m.remove(), 280);
+            });
+        });
+
+        // ══════════════════════════════════════════
+        //  FORM SUBMIT
+        // ══════════════════════════════════════════
+        chatForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const text  = userInput.value.trim();
+            if (!text) return;
+
+            const model = modelSelect.value;
+
+            appendMessage(text, 'user');
+            userInput.value        = '';
+            userInput.style.height = 'auto';
+
+            // Block if no Search API key (both models need it)
+            if (!searchApiKey) {
+                appendNoKeyMessage('search');
+                return;
+            }
+
+            // IndiModel also needs LLM key
+            if (model === 'indimodel' && !llmApiKey) {
+                appendNoKeyMessage('llm');
+                return;
+            }
+
+            // IndiModel — coming soon
+            if (model === 'indimodel') {
+                const lid = appendLoading();
+                setTimeout(() => {
+                    replaceLoading(lid,
+                        'IndiModel — Coming Very Soon!\n\n' +
+                        'This model is currently in active development. It will use your connected LLM API (' + llmApiProvider + ') ' +
+                        'together with the Search API (' + searchApiProvider + ') to perform deep claim analysis, ' +
+                        'cross-reference sources, detect manipulation patterns, and deliver verified trust verdicts.\n\n' +
+                        'Your API keys are saved and ready. Switch to Prototype to use the current pipeline while IndiModel is being built.'
+                    );
+                }, 700);
+                return;
+            }
+
+            // Prototype — current pipeline
+            const loadingId = appendLoading();
+            try {
+                const res = await fetch('/chat', {
+                    method:  'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body:    JSON.stringify({ text, inputType, searchApiKey, searchProvider: searchApiProvider, llmApiKey, llmProvider: llmApiProvider }),
+                });
+                if (!res.ok) throw new Error('HTTP ' + res.status);
+                const data = await res.json();
+                replaceLoading(loadingId, data.response);
+            } catch (err) {
+                console.error(err);
+                replaceLoading(loadingId, 'Connection error. Please check your network and try again.', true);
+            }
+        });
+
+        // Textarea auto-resize
+        userInput.addEventListener('input', () => {
+            userInput.style.height = 'auto';
+            userInput.style.height = Math.min(userInput.scrollHeight, 160) + 'px';
+        });
+        userInput.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                chatForm.dispatchEvent(new Event('submit'));
+            }
+        });
+
+        // ══════════════════════════════════════════
+        //  HELPERS
+        // ══════════════════════════════════════════
+        function getTime() {
+            return new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+        }
+
+        function appendMessage(text, type) {
+            const div = document.createElement('div');
+            div.classList.add('message', type + '-message');
+            div.innerHTML =
+                '<div class="message-meta">' +
+                    '<span class="msg-sender">' + (type === 'user' ? 'You' : 'FactCheck AI') + '</span>' +
+                    '<span class="msg-time">' + getTime() + '</span>' +
+                '</div>' +
+                '<div class="message-body"><p>' + escapeHtml(text) + '</p></div>';
+            chatMessages.appendChild(div);
+            scrollToBottom();
+            requestAnimationFrame(() => div.classList.add('visible'));
+        }
+
+        function appendNoKeyMessage(keyType) {
+            const isLLM = keyType === 'llm';
+            const div   = document.createElement('div');
+            div.classList.add('message', 'bot-message', 'no-key-message');
+            div.innerHTML =
+                '<div class="message-meta">' +
+                    '<span class="msg-sender">FactCheck AI</span>' +
+                    '<span class="msg-time">' + getTime() + '</span>' +
+                '</div>' +
+                '<div class="message-body">' +
+                    '<p>&#128273; <strong>No ' + (isLLM ? 'LLM' : 'Search') + ' API key detected.</strong> ' +
+                    (isLLM
+                        ? 'IndiModel requires a connected LLM API key to function.'
+                        : 'Verification requires live search access — connect a Search API key to continue.'
+                    ) + '</p>' +
+                    '<p style="margin-top:10px">Please enter your API key' + (isLLM ? 's' : '') + ' to continue.</p>' +
+                    '<button class="enter-key-btn reopen-modal-btn">' +
+                        '<svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>' +
+                        'Enter API Key' + (isLLM ? 's' : '') +
+                    '</button>' +
+                '</div>';
+            chatMessages.appendChild(div);
+            scrollToBottom();
+            requestAnimationFrame(() => div.classList.add('visible'));
+            div.querySelector('.reopen-modal-btn').addEventListener('click', () => {
+                searchKeyInput.value = '';
+                llmKeyInput.value    = '';
+                clearAllModalStatus();
+                openModal();
+            });
+        }
+
+        function appendLoading() {
+            const id  = 'load-' + Date.now();
+            const div = document.createElement('div');
+            div.id    = id;
+            div.classList.add('message', 'bot-message', 'loading-message');
+            div.innerHTML =
+                '<div class="message-meta">' +
+                    '<span class="msg-sender">FactCheck AI</span>' +
+                    '<span class="msg-time">' + getTime() + '</span>' +
+                '</div>' +
+                '<div class="message-body">' +
+                    '<div class="typing-indicator"><span></span><span></span><span></span></div>' +
+                    '<span class="loading-text">Analyzing&#8230;</span>' +
+                '</div>';
+            chatMessages.appendChild(div);
+            requestAnimationFrame(() => div.classList.add('visible'));
+            scrollToBottom();
+            return id;
+        }
+
+        function replaceLoading(id, text, isError) {
+            const el = document.getElementById(id);
+            if (!el) return;
+            el.classList.remove('loading-message');
+            if (isError) el.classList.add('error-message');
+            const paras = text.split('\n\n').map(p => '<p>' + escapeHtml(p.trim()) + '</p>').join('');
+            el.querySelector('.message-body').innerHTML = paras;
+            scrollToBottom();
+        }
+
+        function escapeHtml(s) {
+            return s
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;');
+        }
+
+        function scrollToBottom() {
+            chatMessages.scrollTo({ top: chatMessages.scrollHeight, behavior: 'smooth' });
+        }
+    });
+    </script>
+</body>
+</html>