Update app.py

app.py

@@ -1,384 +1,382 @@
+# app.py
+"""
+Real-time Misinformation Detection FastAPI backend.
+
+Features:
+ - Accepts JSON input with any of: text, url, image_base64
+ - Fetches and sanitizes URL content
+ - Runs OCR on images (pytesseract)
+ - Detects language (langdetect)
+ - Uses HuggingFace zero-shot classification to tag categories:
+     ['fake_news','satire','conspiracy','propaganda','deepfake','clickbait','misleading','true']
+ - Calls Google Fact Check API and Google Custom Search (if API keys provided)
+ - Aggregates evidence and returns a JSON response with tags, confidences, and sources.
+
+Notes:
+ - Install Tesseract (system package) for OCR to work.
+ - Provide GOOGLE_API_KEY and GOOGLE_CSE_ID as env vars to enable Google queries.
+ - For production: convert models to ONNX/quantize for lower latency, add rate-limiting & caching (Redis).
+"""
+
 import os
-import json
-import re
-from typing import List, Dict, Any, Optional
+import io
+import base64
+import asyncio
+import logging
+from typing import Optional, List, Dict, Any
+
+import requests
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
-from dotenv import load_dotenv
-import requests
+from PIL import Image
+import pytesseract
+from langdetect import detect, LangDetectException
 from bs4 import BeautifulSoup
-from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
-from fastapi.middleware.cors import CORSMiddleware
-
-
-# ---------------- Lazy-loaded AI Models ----------------
-ZS_PIPE = None
-SENTE_MODEL = None
-GEMINI_CLIENT = None
-
-def get_zs_pipe():
-    global ZS_PIPE
-    if ZS_PIPE is None:
-        try:
-            from transformers import pipeline
-            # much smaller model (~250MB vs 1.3GB)
-            ZS_PIPE = pipeline("zero-shot-classification", model="typeform/distilbert-base-uncased-mnli")
-        except Exception:
-            ZS_PIPE = None
-    return ZS_PIPE
+from newspaper import Article
+
+from transformers import pipeline
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("misinfo-backend")
+
+# Load environment variables for optional integrations
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")        # Google API key
+GOOGLE_CSE_ID = os.environ.get("GOOGLE_CSE_ID")          # Programmable Search Engine ID
+GOOGLE_FACTCHECK_KEY = os.environ.get("GOOGLE_FACTCHECK_KEY")  # (if separate)
+
+# Initialize FastAPI
+app = FastAPI(title="Misinformation Detection API", version="0.1")
+
+# Initialize HF pipelines (zero-shot and claim detection)
+# Zero-shot classifier to tag categories. Candidate labels chosen for the task.
+LABELS = [
+    "fake_news",
+    "satire",
+    "conspiracy",
+    "propaganda",
+    "deepfake",
+    "clickbait",
+    "misleading",
+    "true"
+]
 
-def get_sente_model():
-    global SENTE_MODEL
-    if SENTE_MODEL is None:
-        try:
-            from sentence_transformers import SentenceTransformer
-            # smaller semantic similarity model (~80MB vs 400MB)
-            SENTE_MODEL = SentenceTransformer("all-MiniLM-L6-v2")
-        except Exception:
-            SENTE_MODEL = None
-    return SENTE_MODEL
+# One-time model loads - may take time on first import
+logger.info("Loading HuggingFace zero-shot classification pipeline...")
+zs_pipeline = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+
+# Optional: you can provide a lighter model string for faster inference:
+# zs_pipeline = pipeline("zero-shot-classification", model="typeform/distilbert-base-uncased-mnli")
+
+# Define request & response schemas
+class AnalyzeRequest(BaseModel):
+    text: Optional[str] = None
+    url: Optional[str] = None
+    image_base64: Optional[str] = None  # base64-encoded image (PNG/JPEG)
+
+class EvidenceItem(BaseModel):
+    source: str
+    title: Optional[str] = None
+    snippet: Optional[str] = None
+    url: Optional[str] = None
+    verdict: Optional[str] = None
+
+class AnalyzeResponse(BaseModel):
+    input_type: str
+    language: Optional[str]
+    text: Optional[str]
+    tags: Dict[str, float]
+    evidence: List[EvidenceItem]
+    notes: Optional[str] = None
+
+# -----------------------
+# Helper utilities
+# -----------------------
+def fetch_url_text(url: str, timeout: float = 8.0) -> str:
+    """
+    Fetches a URL and extracts main article text using newspaper3k as fallback to BeautifulSoup.
+    """
+    try:
+        logger.info("Fetching URL: %s", url)
+        article = Article(url)
+        article.download()
+        article.parse()
+        text = article.text
+        if text and len(text) > 50:
+            return text
+    except Exception as e:
+        logger.debug("Newspaper failed: %s", e)
 
+    # Fallback: simple fetch and extract <p> text
+    try:
+        resp = requests.get(url, timeout=timeout, headers={"User-Agent": "misinfo-bot/1.0"})
+        resp.raise_for_status()
+        soup = BeautifulSoup(resp.text, "html.parser")
+        paragraphs = [p.get_text(strip=True) for p in soup.find_all("p")]
+        joined = "\n\n".join([p for p in paragraphs if p])
+        return joined[:10000]  # limit to 10k chars
+    except Exception as e:
+        logger.exception("Failed to fetch or parse URL: %s", e)
+        raise
 
-def get_gemini_client():
-    global GEMINI_CLIENT
-    if GEMINI_CLIENT is None:
-        try:
-            from google import genai
-            GEMINI_CLIENT = genai.Client()  # uses GEMINI_API_KEY from environment
-        except Exception:
-            GEMINI_CLIENT = None
-    return GEMINI_CLIENT
-
-# ---------------- Env Vars ----------------
-load_dotenv()
-GNEWS_API_KEY = os.getenv("GNEWS_KEY")
-NEWSORG_API_KEY = os.getenv("NEWSORG_KEY")
-GEMINI_API_KEY = os.getenv("AI_API_KEY")
-
-app = FastAPI(title="Hybrid Misinformation Detector")
-# Define allowed origins
-origins = ["*"]
-
-# Add CORS middleware
-app.add_middleware(
-CORSMiddleware,
-allow_origins=origins, # List of allowed origins
-allow_credentials=True, # Allow cookies and credentials
-allow_methods=["*"], # Allow all HTTP methods (GET, POST, etc.)
-allow_headers=["*"], # Allow all headers
-)
-# ---------------- Models ----------------
-class VerifyRequest(BaseModel):
-    text: str
-    mode: Optional[str] = "fast"  # fast, deep, hybrid
-
-# ---------------- Utilities ----------------
-def safe_headers():
-    return {"User-Agent": "misinfo-tool/1.0 (+https://example.com)"}
-
-def domain_from_url(url: str) -> Optional[str]:
-    if not url: return None
+def ocr_image_from_base64(b64: str) -> str:
+    """
+    Decode base64 image and run OCR (pytesseract).
+    """
     try:
-        m = re.search(r"https?://(?:www\.)?([^/]+)/?", url)
-        if m:
-            domain = m.group(1).lower()
-            parts = domain.split('.')
-            if len(parts) > 2:
-                domain = ".".join(parts[-2:])
-            return domain
-    except Exception:
-        return None
-    return None
-
-# ---------------- Trusted / Blacklist ----------------
-TRUSTED_DOMAINS = {
-    "bbc.co.uk","bbc.com","cnn.com","nytimes.com","reuters.com","apnews.com",
-    "theguardian.com","npr.org","washingtonpost.com","wsj.com","usatoday.com",
-    "bloomberg.com","aljazeera.com","msnbc.com","cnbc.com","foxnews.com",
-    "scientificamerican.com","nature.com","sciencedaily.com"
-}
-
-BLACKLISTED_DOMAINS = {
-    "imdb.com","youtube.com","wikipedia.org","fandom.com","comicbook.com",
-    "rottentomatoes.com","hulu.com","netflix.com","ign.com","forbes.com"
-}
-
-UNWANTED_KEYWORDS = [
-    "movie","film","episode","tv show","trailer","comic","manga","fan","fandom",
-    "review","fiction","novel","fantasy","screenplay","actor","actress"
-]
+        image_data = base64.b64decode(b64)
+        img = Image.open(io.BytesIO(image_data)).convert("RGB")
+        # Optionally resize for better OCR
+        w, h = img.size
+        max_dim = 1600
+        if max(w, h) > max_dim:
+            scale = max_dim / max(w, h)
+            img = img.resize((int(w * scale), int(h * scale)))
+        text = pytesseract.image_to_string(img)
+        return text.strip()
+    except Exception as e:
+        logger.exception("OCR failed: %s", e)
+        return ""
 
-# ---------------- NLP classify ----------------
-def classify_text_type(text: str) -> Dict[str, Any]:
-    labels = ["news","rumor","fact","opinion","satire","unverifiable"]
-    pipe = get_zs_pipe()
-    if pipe:
-        try:
-            res = pipe(text, labels, multi_label=False, truncation=True)
-            label = res["labels"][0]
-            score = float(res["scores"][0])
-            return {"type": label, "score": round(score,3), "scores": dict(zip(res["labels"], res["scores"]))}
-        except Exception:
-            pass
-    t = text.lower()
-    if any(k in t for k in ["according to","reported","breaking","news","announced"]):
-        return {"type":"news","score":0.65,"scores":{}}
-    if any(k in t for k in ["i think","in my opinion","i believe","should"]):
-        return {"type":"opinion","score":0.7,"scores":{}}
-    if any(k in t for k in ["joke","satire","not real","parody"]):
-        return {"type":"satire","score":0.7,"scores":{}}
-    if any(k in t for k in ["study shows","research","published","peer-reviewed"]):
-        return {"type":"fact","score":0.6,"scores":{}}
-    return {"type":"rumor","score":0.45,"scores":{}}
-
-def summarize_text(text: str, max_len=300) -> str:
-    sentences = re.split(r'(?<=[.!?]) +', text.strip())
-    summary = sentences[0] if sentences else text
-    if len(summary) > max_len:
-        summary = summary[:max_len].rsplit(' ',1)[0] + "..."
-    return summary
-
-# ---------------- Search ----------------
-def fetch_gnews(query: str, max_results=6) -> List[Dict[str,str]]:
-    if not GNEWS_API_KEY:
-        return []
+def detect_language_of_text(text: str) -> Optional[str]:
     try:
-        url = "https://gnews.io/api/v4/search"
-        params = {"q": query, "token": GNEWS_API_KEY, "max": max_results, "lang":"en"}
-        r = requests.get(url, params=params, headers=safe_headers(), timeout=6)
-        r.raise_for_status()
-        js = r.json()
-        return [{"title": a.get("title"), "url": a.get("url"), "source": a.get("source",{}).get("name"), "snippet": a.get("description")} for a in js.get("articles", [])[:max_results]]
-    except Exception:
-        return []
+        lang = detect(text)
+        return lang
+    except LangDetectException:
+        return None
 
-def fetch_newsapi(query: str, max_results=6) -> List[Dict[str,str]]:
-    if not NEWSORG_API_KEY:
-        return []
+async def run_zero_shot(text: str, labels: List[str]) -> Dict[str, float]:
+    """
+    Run zero-shot classifier and return label->score mapping.
+    This is synchronous pipeline but we wrap it for consistency.
+    """
     try:
-        url = "https://newsapi.org/v2/everything"
-        params = {"q": query, "pageSize": max_results, "apiKey": NEWSORG_API_KEY, "language":"en"}
-        r = requests.get(url, params=params, headers=safe_headers(), timeout=6)
-        r.raise_for_status()
-        js = r.json()
-        return [{"title": a.get("title"), "url": a.get("url"), "source": a.get("source",{}).get("name"), "snippet": a.get("description")} for a in js.get("articles", [])[:max_results]]
-    except Exception:
+        res = zs_pipeline(text, candidate_labels=labels, multi_label=True)
+        # res: {'sequence':..., 'labels': [...], 'scores': [...]}
+        return {label: float(score) for label, score in zip(res["labels"], res["scores"])}
+    except Exception as e:
+        logger.exception("Zero-shot classification failed: %s", e)
+        return {label: 0.0 for label in labels}
+
+# -----------------------
+# External Fact-check / Search Integrations (optional)
+# -----------------------
+def query_google_factcheck(claim: str) -> List[Dict[str, Any]]:
+    """
+    Wrapper for Google Fact Check Tools API.
+    Returns a list of claimReview-like objects with {source, title, snippet, url, verdict}.
+    Requires GOOGLE_API_KEY (and optionally GOOGLE_FACTCHECK_KEY).
+    API docs: https://developers.google.com/fact-check/tools/api
+    """
+    key = GOOGLE_API_KEY or GOOGLE_FACTCHECK_KEY
+    if not key:
+        logger.debug("Google Fact Check key not configured.")
         return []
 
-def duckduckgo_search(query: str, max_results=8) -> List[Dict[str,str]]:
+    endpoint = "https://factchecktools.googleapis.com/v1alpha1/claims:search"
+    params = {"query": claim, "key": key}
     try:
-        url = "https://html.duckduckgo.com/html/"
-        r = requests.post(url, data={"q": query}, headers=safe_headers(), timeout=6)
+        r = requests.get(endpoint, params=params, timeout=6)
         r.raise_for_status()
-        soup = BeautifulSoup(r.text, "html.parser")
+        payload = r.json()
         results = []
-        for res in soup.select(".result__a")[:max_results]:
-            title = res.get_text()
-            href = res.get("href")
-            snippet_node = res.find_parent().select_one(".result__snippet")
-            snippet = snippet_node.get_text() if snippet_node else ""
-            results.append({"title": title, "url": href, "source":None, "snippet": snippet})
+        for item in payload.get("claims", []):
+            for review in item.get("claimReview", []):
+                results.append({
+                    "source": review.get("publisher", {}).get("name"),
+                    "title": item.get("text"),
+                    "snippet": review.get("title") or review.get("textualRating"),
+                    "url": review.get("url"),
+                    "verdict": review.get("textualRating") or review.get("title")
+                })
         return results
-    except Exception:
+    except Exception as e:
+        logger.exception("Google Fact Check API error: %s", e)
         return []
 
-# ---------------- Optimized fetch all sources ----------------
-def fetch_all_sources(query: str) -> List[Dict[str,str]]:
-    with ThreadPoolExecutor(max_workers=3) as executor:
-        futures = [
-            executor.submit(fetch_gnews, query),
-            executor.submit(fetch_newsapi, query),
-            executor.submit(duckduckgo_search, query)
-        ]
-        results = []
-        for f in futures:
-            try:
-                results.extend(f.result())
-            except:
-                pass
-    return results
-
-# ---------------- Filtering ----------------
-def is_unwanted_snippet(snippet: str) -> bool:
-    if not snippet: return False
-    s = snippet.lower()
-    return any(k in s for k in UNWANTED_KEYWORDS)
-
-def filter_sources(sources: List[Dict[str,str]]) -> List[Dict[str,str]]:
-    kept, seen = [], set()
-    for s in sources:
-        url = s.get("url") or ""
-        if not url or url in seen: continue
-        seen.add(url)
-        domain = domain_from_url(url)
-        s["domain"] = domain or ""
-        if not domain: continue
-        if domain in BLACKLISTED_DOMAINS: continue
-        if domain not in TRUSTED_DOMAINS: continue
-        if is_unwanted_snippet(s.get("snippet","")) or is_unwanted_snippet(s.get("title","")): continue
-        kept.append(s)
-    return kept
-
-# ---------------- Semantic filtering ----------------
-def compute_similarity(args):
-    claim_emb, snippet = args
-    model = get_sente_model()
-    if not model: return 0.0
-    snippet_emb = model.encode(snippet, convert_to_tensor=True)
-    from sentence_transformers import util
-    return util.cos_sim(claim_emb, snippet_emb).item()
-
-def semantic_filter_parallel(claim: str, sources: List[Dict[str,str]], threshold=0.3) -> List[Dict[str,str]]:
-    model = get_sente_model()
-    if not model or not sources:
-        return sources
-
-    claim_emb = model.encode(claim, convert_to_tensor=True)
-    args = [(claim_emb, s["snippet"]) for s in sources]
-
-    filtered = []
-    with ProcessPoolExecutor(max_workers=min(4, len(sources))) as executor:
-        sims = list(executor.map(compute_similarity, args))
-    
-    for s, sim in zip(sources, sims):
-        if sim >= threshold:
-            filtered.append(s)
-    return filtered
-
-# ---------------- Evidence summary ----------------
-def summarize_evidence(sources: List[Dict[str,str]], max_chars=800) -> str:
-    if not sources:
-        return "No credible news sources found."
-    parts = []
-    for s in sources[:8]:
-        t = s.get("title") or ""
-        snip = s.get("snippet") or ""
-        domain = s.get("domain") or domain_from_url(s.get("url","")) or ""
-        parts.append(f"{t} ({domain}) — {snip}")
-    res = "\n".join(parts)
-    if len(res) > max_chars:
-        return res[:max_chars].rsplit(" ",1)[0] + "..."
-    return res
-
-# ---------------- Fusion ----------------
-def fuse_scores(fast_conf: float, deep_outcome: Optional[str], evidence_count: int) -> Dict[str,Any]:
-    base = fast_conf*0.5 + min(evidence_count/5.0,1.0)*0.5
-    if deep_outcome and deep_outcome.lower() in ["false","misleading"]:
-        base *= 0.7
-    score = int(round(max(0, min(1, base)) * 100))
-    color = "green" if score >= 70 else "yellow" if score >= 40 else "red"
-    return {"score":score, "color":color}
-
-# ---------------- Fact Check API ----------------
-def factcheck_claim(claim: str) -> Dict[str,Any]:
-    api_key = "AIzaSyB0A-MIHs8qkjYTWE-TnoLw46KplX-Ihjs"
-    url = "https://factchecktools.googleapis.com/v1alpha1/claims:search"
-    params = {"query": claim, "key": api_key, "languageCode": "en", "pageSize": 5}
+def google_search_evidence(query: str, num: int = 3) -> List[Dict[str, Any]]:
+    """
+    Use Google Custom Search (Programmable Search Engine) to query news/fact-check sites.
+    Requires GOOGLE_API_KEY and GOOGLE_CSE_ID.
+    """
+    if not (GOOGLE_API_KEY and GOOGLE_CSE_ID):
+        logger.debug("Google Search/CSE not configured.")
+        return []
+
+    endpoint = "https://www.googleapis.com/customsearch/v1"
+    params = {
+        "key": GOOGLE_API_KEY,
+        "cx": GOOGLE_CSE_ID,
+        "q": query,
+        "num": num,
+    }
     try:
-        r = requests.get(url, params=params, headers=safe_headers(), timeout=6)
+        r = requests.get(endpoint, params=params, timeout=6)
         r.raise_for_status()
         js = r.json()
-        claims = js.get("claims", [])
-        results = []
-        for c in claims:
-            claimant = c.get("claimant", "Unknown")
-            text = c.get("text", "")
-            claimReview = c.get("claimReview", [])
-            for review in claimReview:
-                publisher = review.get("publisher", {}).get("name")
-                url = review.get("url")
-                title = review.get("title")
-                review_rating = review.get("textualRating")
-                results.append({
-                    "claimant": claimant,
-                    "text": text,
-                    "publisher": publisher,
-                    "url": url,
-                    "title": title,
-                    "rating": review_rating
-                })
-        outcome = "Unverified" if not results else results[0].get("rating", "Unverified")
-        return {"outcome": outcome, "source": results}
+        items = []
+        for it in js.get("items", []):
+            items.append({
+                "source": it.get("displayLink"),
+                "title": it.get("title"),
+                "snippet": it.get("snippet"),
+                "url": it.get("link"),
+            })
+        return items
     except Exception as e:
-        return {"outcome": "Error", "source": [], "error": str(e)}
-
-# ---------------- API ----------------
-@app.post("/verify")
-async def verify(req: VerifyRequest):
-    claim = (req.text or "").strip()
-    mode = (req.mode or "fast").lower()
-    if not claim:
-        raise HTTPException(status_code=400, detail="Empty claim")
-
-    # Step 1 classify
-    text_type_res = classify_text_type(claim)
-    stored_type = text_type_res["type"]
-
-    # Step 2 summarize
-    user_summary = summarize_text(claim)
-
-    # Step 3 search
-    query = f"{user_summary} site:bbc.com OR site:cnn.com OR site:reuters.com OR site:apnews.com"
-    all_raw = fetch_all_sources(query)
-
-    # Step 4 filter
-    filtered = filter_sources(all_raw)
+        logger.exception("Google Custom Search error: %s", e)
+        return []
 
-    # Step 4b semantic filter
-    filtered = semantic_filter_parallel(claim, filtered)
+# -----------------------
+# Simple deepfake image detector placeholder
+# -----------------------
+def detect_image_manipulation(image_base64: str) -> Dict[str, Any]:
+    """
+    Placeholder stub for image deepfake/manipulation detection.
+    For production: replace with a trained CV model (e.g. EfficientNet/TSA/ViT based).
+    Returns: {'deepfake_confidence': float, 'notes': str}
+    """
+    # TODO: integrate a real deepfake model (e.g., DFDC-trained classifier).
+    # Right now: always return low confidence.
+    return {"deepfake_confidence": 0.02, "notes": "placeholder detector; integrate a trained model for production."}
+
+# -----------------------
+# Main analysis orchestration
+# -----------------------
+async def analyze_text_pipeline(text: str) -> Dict[str, Any]:
+    """
+    Run language detection, claim extraction (simple split), zero-shot classification,
+    fact-check queries, and return aggregated results.
+    """
+    # Detect language
+    language = detect_language_of_text(text) or "unknown"
+
+    # (Simple) Claim extraction: split into sentences and pick top-N sentences by length
+    # In production, use a proper claim-detection model (ClaimBuster).
+    sentences = [s.strip() for s in text.split('.') if s.strip()]
+    # Heuristic: pick up to 3 longest sentences as "claims"
+    claims = sorted(sentences, key=lambda s: len(s), reverse=True)[:3]
+    if not claims:
+        claims = [text[:300]]
+
+    # Run zero-shot classification on the whole text
+    zs_scores = await run_zero_shot(text, LABELS)
+
+    # Query fact-check APIs for top claims (async runs)
+    loop = asyncio.get_event_loop()
+    tasks = [loop.run_in_executor(None, query_google_factcheck, claim) for claim in claims]
+    tasks += [loop.run_in_executor(None, google_search_evidence, claim) for claim in claims]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    evidence = []
+    # results structure: [fc_claim1, cs_claim1, fc_claim2, cs_claim2, ...]
+    for res in results:
+        if isinstance(res, Exception):
+            continue
+        for r in res:
+            evidence.append(r)
+
+    # Build summary trust/score: simple fusion of highest zs label for 'true' vs others
+    # Compute "misinfo_score" = max score of any misinfo label (not 'true')
+    misinfo_labels = [l for l in LABELS if l != "true"]
+    misinfo_score = max([zs_scores.get(l, 0.0) for l in misinfo_labels]) if zs_scores else 0.0
+    true_score = zs_scores.get("true", 0.0)
+
+    notes = f"Claims extracted: {len(claims)}. Misinfo_score={misinfo_score:.3f}, true_score={true_score:.3f}"
 
-    evidence_summary = summarize_evidence(filtered)
+    return {
+        "language": language,
+        "text": text,
+        "zs_scores": zs_scores,
+        "claims": claims,
+        "evidence": evidence,
+        "notes": notes
+    }
 
-    # Step 5 fast classification
-    fast_label, fast_conf = "Unverifiable", 0.4
-    pipe = get_zs_pipe()
-    if pipe:
+# -----------------------
+# API Endpoint
+# -----------------------
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze(req: AnalyzeRequest):
+    if not (req.text or req.url or req.image_base64):
+        raise HTTPException(status_code=400, detail="Provide at least one of text, url, or image_base64.")
+
+    # Determine input type and get primary text (if any)
+    input_text = None
+    input_type = "unknown"
+    evidence_items: List[EvidenceItem] = []
+
+    # 1) If URL provided, fetch and extract text
+    if req.url:
+        input_type = "url"
         try:
-            cls = pipe(claim, ["True","False","Misleading","Unverifiable"], multi_label=False, truncation=True)
-            fast_label = cls["labels"][0]
-            fast_conf = float(cls["scores"][0])
-        except:
-            pass
-
-    # Step 6 deep (Gemini AI)
-    deep_result = None
-    if mode in ["deep","hybrid"]:
-        client = get_gemini_client()
-        if client:
-            try:
-                prompt = f'Verify claim: "{claim}". Output JSON: outcome, explanation, comparison, takeaways.'
-                resp = client.models.generate_content(model="gemini-2.5-flash", contents=prompt)
-                deep_result = json.loads(resp.text)
-            except:
-                deep_result = {"outcome":"Unverifiable","explanation":"Gemini API error","takeaways":["Check credible sources"]}
+            input_text = fetch_url_text(req.url)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed fetching URL: {e}")
+
+    # 2) If image provided, run OCR and deepfake check
+    if req.image_base64:
+        # If both image and url/text provided, we will aggregate them.
+        input_type = "image" if input_type == "unknown" else input_type + "+image"
+        ocr_text = ocr_image_from_base64(req.image_base64)
+        df_result = detect_image_manipulation(req.image_base64)
+        # Add an evidence entry for image analysis
+        evidence_items.append(EvidenceItem(source="local_image_analysis", title="Image analysis", snippet=str(df_result), url=None))
+        # Merge OCR text with overall text (if none yet, use OCR)
+        if ocr_text:
+            # Append OCR text to input_text (prefer original text if already present)
+            if input_text:
+                input_text = input_text + "\n\n[OCR TEXT]\n" + ocr_text
+            else:
+                input_text = ocr_text
+
+    # 3) If direct text provided
+    if req.text:
+        input_type = "text" if input_type == "unknown" else input_type + "+text"
+        if input_text:
+            input_text = input_text + "\n\n" + req.text
         else:
-            deep_result = {"outcome":"Unverifiable","explanation":"Demo mode: API missing","takeaways":["Check credible sources"]}
-
-    # Step 7 fact-check API
-    factcheck = factcheck_claim(claim)
+            input_text = req.text
 
-    # Step 8 fuse scores
-    deep_outcome = deep_result.get("outcome") if deep_result else None
-    fuse = fuse_scores(fast_conf, deep_outcome, len(filtered))
+    # If still no text (e.g., image had no OCR), set to empty string
+    if not input_text:
+        input_text = ""
 
-    return {
-        "claim": claim,
-        "text_type": stored_type,
-        "text_type_scores": text_type_res.get("scores", {}),
-        "user_summary": user_summary,
-        "fast": {"label": fast_label, "confidence": round(fast_conf,3)},
-        "evidence_count_raw": len(all_raw),
-        "evidence_count_filtered": len(filtered),
-        "evidence": filtered,
-        "evidence_summary": evidence_summary,
-        "deep": deep_result or {},
-        "factcheck": factcheck,
-        "credibility": fuse
-    }
+    # Run the main text pipeline
+    pipeline_result = await analyze_text_pipeline(input_text)
 
-# ---------------- Frontend ----------------
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT","1748")))
+    # Convert evidence dictionaries to EvidenceItem dataclass list
+    for ev in pipeline_result.get("evidence", []):
+        try:
+            evidence_items.append(EvidenceItem(
+                source=ev.get("source") or "unknown",
+                title=ev.get("title"),
+                snippet=ev.get("snippet"),
+                url=ev.get("url"),
+                verdict=ev.get("verdict")
+            ))
+        except Exception:
+            continue
+
+    # Assemble tag scores (HuggingFace labels -> mapping)
+    zscores = pipeline_result.get("zs_scores", {})
+    # Normalize to include all labels with default 0.0
+    tags = {label: float(zscores.get(label, 0.0)) for label in LABELS}
+
+    # Response
+    resp = AnalyzeResponse(
+        input_type=input_type,
+        language=pipeline_result.get("language"),
+        text=(pipeline_result.get("text")[:10000] if pipeline_result.get("text") else None),
+        tags=tags,
+        evidence=evidence_items,
+        notes=pipeline_result.get("notes")
+    )
+    return resp
+
+# -----------------------
+# Simple root health endpoint
+# -----------------------
+@app.get("/")
+def root():
+    return {"status": "ok", "service": "misinfo-detector", "version": "0.1"}