Initial API app, Dockerfile, and requirements for Space deployment

Dockerfile

@@ -0,0 +1,32 @@
+# Hugging Face Spaces - Docker runtime for Flask API
+# Using a slim Python base to keep image small
+FROM python:3.11-slim
+
+# Prevent Python from buffering stdout/stderr
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PORT=7860
+
+# System deps for chromadb and sentence-transformers
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python deps early for better layer caching
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install -r requirements.txt && pip install gunicorn
+
+# Copy application code
+COPY . .
+
+# Expose the port used by Hugging Face Spaces
+EXPOSE 7860
+
+# Run the Flask app with gunicorn for production-grade serving
+# Bind to 0.0.0.0:7860 and point to the WSGI entry point
+CMD ["gunicorn", "-w", "2", "-k", "gthread", "--threads", "8", "-b", "0.0.0.0:7860", "cve_factchecker.wsgi:application"]

cve_factchecker/README.md

@@ -0,0 +1,66 @@
+# CVE Fact Checker Flask API
+
+Production-oriented API layer exposing fact checking, Firebase ingestion, and semantic search.
+
+## Features
+- Firebase article ingestion -> vector store (Chroma)
+- Semantic similarity search
+- Claim fact-check endpoint (LLM backed if OPENROUTER_API_KEY present; graceful fallback otherwise)
+- Schema inspection & collection listing
+- Lightweight dummy embeddings fallback (no GPU / HF model required)
+
+## Environment Variables
+```
+OPENROUTER_API_KEY=your_key           # Optional (improves analysis)
+APP_DOMAIN=https://yourdomain.tld     # For OpenRouter headers (optional)
+APP_TITLE="Your App Title"            # For OpenRouter headers (optional)
+```
+
+## Install
+```
+python -m venv .venv
+.venv\Scripts\activate  # Windows
+pip install -r requirements.txt
+pip install flask
+```
+
+## Run
+```
+python -m cve_factchecker.app
+```
+Server listens on `http://0.0.0.0:8000`.
+
+## Endpoints
+| Method | Path | Description |
+| ------ | ---- | ----------- |
+| GET | / | Index + endpoint list |
+| GET | /health | Health & uptime |
+| POST | /ingest/firebase | Ingest from Firebase (paged) `{collection?, limit?}` |
+| POST | /ingest/firebase/full | Ingest ALL documents (pagination) `{collection?}` |
+| GET | /schema | Inspect collection schema `?collection=Articles` |
+| GET | /collections | List probable collections |
+| GET | /search | Semantic search `?q=term&k=5` |
+| POST | /fact-check | Fact check `{claim, auto_ingest?, ingest_limit?}` |
+
+## Example Requests (PowerShell)
+```
+# Health
+curl http://localhost:8000/health
+
+# Ingest sample (limited)
+curl -Method POST -Uri http://localhost:8000/ingest/firebase -Headers @{"Content-Type"="application/json"} -Body '{"limit":50}'
+
+# Full ingest (all)
+curl -Method POST -Uri http://localhost:8000/ingest/firebase/full -Headers @{"Content-Type"="application/json"} -Body '{}'
+
+# Search
+curl "http://localhost:8000/search?q=Pakistan"
+
+# Fact Check (with auto ingest)
+curl -Method POST -Uri http://localhost:8000/fact-check -Headers @{"Content-Type"="application/json"} -Body '{"claim":"Pakistan signed a new mineral deal","auto_ingest":true,"ingest_limit":80}'
+```
+
+## Notes
+- If you have no API key configured, verdicts will be `UNVERIFIED`; retrieval still works.
+- Adjust vector DB path by editing `FactCheckSystem` init in `orchestrator.py`.
+- Set `AUTO_INGEST_FIREBASE=true` (env var) to automatically ingest all articles on startup.

cve_factchecker/__init__.py

@@ -0,0 +1 @@
+"""Production-ready Flask integration package for the CVE Fact Checker."""

cve_factchecker/__main__.py

@@ -0,0 +1,4 @@
+from .app import app
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000)

cve_factchecker/analyzer.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import json, re
+from typing import List, Dict, Any
+from .config import OpenRouterConfig
+from .llm import build_openrouter_client, chat_complete
+from .models import normalize_result
+
+class QueryRewriter:
+    def __init__(self, cfg: OpenRouterConfig):
+        self.cfg = cfg
+        self.client = build_openrouter_client(cfg)
+    def rewrite(self, query: str) -> List[str]:
+        if not self.client:
+            return list({query, f"{query} Pakistan", f"{query} Urdu"})
+        prompt = ("Generate 3 diverse search queries for Pakistani news related to the user's query. "
+                  "Consider Urdu-English variations and synonyms. Return only the queries, one per line without numbering.\n\n"
+                  f"User query: {query}")
+        try:
+            out = chat_complete(self.client, self.cfg.model, prompt, temperature=self.cfg.temperature, max_tokens=min(400, self.cfg.max_tokens))
+            lines = [ln.strip(" -•\t").strip() for ln in out.splitlines()]
+            queries = [ln for ln in lines if ln]
+            return queries[:3] if queries else [query]
+        except Exception as e:
+            print(f"❌ Query rewriting error: {e}")
+            return [query]
+
+class ClaimAnalyzer:
+    def __init__(self, cfg: OpenRouterConfig):
+        self.cfg = cfg
+        self.client = build_openrouter_client(cfg)
+    def analyze(self, claim: str, articles: List[Dict[str, Any]]) -> Dict[str, Any]:
+        if not self.client:
+            # Heuristic fallback: simple keyword overlap scoring.
+            claim_lc = claim.lower()
+            keywords = {w for w in claim_lc.split() if len(w) > 4}
+            supporting: List[str] = []
+            score = 0
+            for a in articles:
+                text = (a.get('content','') or '').lower()
+                overlap = sum(1 for k in keywords if k in text)
+                if overlap:
+                    supporting.append(f"Match ({overlap}) in {a.get('url','')}")
+                    score += overlap
+            confidence = min(0.6, 0.1 * score) if supporting else 0.05
+            verdict = "POSSIBLY TRUE" if confidence > 0.3 else "UNVERIFIED"
+            return {
+                "verdict": verdict,
+                "confidence": confidence,
+                "reasoning": "Heuristic fallback (no LLM). Confidence based on keyword overlap in retrieved articles.",
+                "supporting_evidence": supporting[:5],
+                "contradicting_evidence": [],
+                "context_quality": "medium" if supporting else "low",
+            }
+        context = "\n\n".join([f"Article {i+1}:\nTitle: {a.get('title','Unknown')}\nSource: {a.get('source','Unknown')}\nURL: {a.get('url','')}\nContent: {a.get('content','')[:500]}..." for i,a in enumerate(articles)])
+        prompt = ("You are an expert Pakistani fact-checker. Analyze the claim against the retrieved context and return JSON only.\n\n"
+                  f"NEWS CLAIM: {claim}\n\nRETRIEVED CONTEXT:\n{context}\n\n"
+                  "Return strictly valid JSON with keys: verdict, confidence, reasoning, supporting_evidence, contradicting_evidence, context_quality.")
+        try:
+            content = chat_complete(self.client, self.cfg.model, prompt, temperature=self.cfg.temperature, max_tokens=self.cfg.max_tokens).strip()
+            if content.startswith("```"):
+                content = content.strip("`")
+                if "\n" in content:
+                    content = "\n".join(content.split("\n")[1:])
+            m = re.search(r"\{[\s\S]*\}", content)
+            if m:
+                content = m.group(0)
+            data = json.loads(content)
+        except Exception as e:
+            return {"verdict": "ERROR", "confidence": 0.0, "reasoning": f"Analysis failed: {e}", "supporting_evidence": [], "contradicting_evidence": [], "context_quality": "low"}
+        return normalize_result(data)

cve_factchecker/app.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+from flask import Flask, jsonify, request
+from typing import Any, Dict
+import time
+import threading
+from .orchestrator import FactCheckSystem
+from .firebase_service import FirebaseVectorSync
+try:
+    from flask_cors import CORS  # type: ignore
+except Exception:  # pragma: no cover
+    CORS = None  # type: ignore
+
+system = FactCheckSystem()
+firebase_sync = FirebaseVectorSync()
+
+import os
+AUTO_INGEST = True  # Always ingest on startup for seamless experience
+INGEST_STATUS: Dict[str, Any] = {"started": time.time(), "finished": False, "synced": 0}
+
+def _background_ingest() -> None:
+    try:
+        print("🚀 Performing full Firebase ingestion (background, startup)...")
+        ingest_res = firebase_sync.full_sync()
+        INGEST_STATUS.update({"finished": True, **ingest_res})
+        if not ingest_res.get("success"):
+            print("⚠️ Startup ingestion did not succeed:", ingest_res.get("error"))
+        else:
+            print(f"✅ Startup ingestion complete: {ingest_res.get('synced')} articles")
+        # Log LLM availability
+        if system.analyzer.client:
+            print(f"🤖 LLM active: model={system.cfg.model} max_tokens={system.cfg.max_tokens}")
+        else:
+            print("⚠️ No LLM API key detected. Using heuristic fallback.")
+    except Exception as e:
+        INGEST_STATUS.update({"finished": True, "error": str(e)})
+        print(f"❌ Startup ingestion failed: {e}")
+
+def _start_ingest_thread() -> None:
+    if not AUTO_INGEST:
+        return
+    t = threading.Thread(target=_background_ingest, name="firebase-ingest", daemon=True)
+    t.start()
+
+app = Flask(__name__)
+if CORS:
+    CORS(app, resources={r"/*": {"origins": "*"}})
+start_time = time.time()
+
+# Start ingestion in background as soon as the module is imported / app is created
+_start_ingest_thread()
+
+@app.route('/health')
+def health() -> Any:
+    return jsonify({"status": "ok", "uptime_sec": round(time.time()-start_time,2)})
+
+## Simplified API: only /health and /fact-check provided. Data ingestion occurs automatically on startup.
+
+def _run_fact_check(claim: str):  # internal helper
+    if not INGEST_STATUS.get("finished"):
+        return {"verdict": "INITIALIZING", "reasoning": "Ingestion still in progress. Try again soon.", "confidence": 0.0}, 503
+    result = system.fact_check(claim)
+    if result.get('verdict') == 'ERROR' and '402' in result.get('reasoning',''):
+        result['verdict'] = 'UNVERIFIED'
+        result['reasoning'] = 'LLM quota/credits insufficient. Retrieval performed; provide API key to enable full analysis.'
+    return result, 200
+
+@app.route('/fact-check', methods=['POST','GET'])
+def fact_check() -> Any:
+    claim: Any = None
+    if request.method == 'GET':
+        claim = request.args.get('claim') or request.args.get('text')
+    else:  # POST
+        payload = request.get_json(silent=True) or {}
+        # support form or query fallback
+        claim = (payload.get('claim') or payload.get('text') or
+                 request.form.get('claim') or request.args.get('claim'))
+    if not claim:
+        return jsonify({"error": "claim parameter or JSON field 'claim' required"}), 400
+    result, code = _run_fact_check(claim)
+    return jsonify(result), code
+
+@app.route('/')
+def index():
+    # Convenience: allow GET /?claim=... for Postman users
+    q_claim = request.args.get('claim')
+    if q_claim:
+        result, code = _run_fact_check(q_claim)
+        return jsonify(result), code
+    return jsonify({
+        "name": "CVE Fact Checker API (Simplified)",
+        "status": {
+            "ingestion_finished": INGEST_STATUS.get("finished"),
+            "synced_articles": INGEST_STATUS.get("synced"),
+            "ingestion_error": INGEST_STATUS.get("error")
+        },
+        "endpoints": [
+            "GET /health",
+            "GET /fact-check?claim=...",
+            "POST /fact-check {claim}" ,
+            "GET /?claim=... (alias)"
+        ]
+    })
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', '7860'))
+    app.run(host='0.0.0.0', port=port)

cve_factchecker/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional, Dict
+import os
+
+@dataclass
+class OpenRouterConfig:
+    api_key: Optional[str]
+    model: str = "deepseek/deepseek-r1-0528"
+    base_url: str = "https://openrouter.ai/api/v1"
+    temperature: float = 0.2
+    max_tokens: int = 800
+    headers: Optional[Dict[str, str]] = None
+
+def load_openrouter_config(api_key: Optional[str] = None) -> OpenRouterConfig:
+    key = api_key or os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENAI_API_KEY")
+    model = os.getenv("FACTCHECK_MODEL") or "deepseek/deepseek-r1-0528"
+    try:
+        max_tokens = int(os.getenv("FACTCHECK_MAX_TOKENS", "800"))
+    except ValueError:
+        max_tokens = 800
+    headers = {
+        "HTTP-Referer": os.getenv("APP_DOMAIN", "http://localhost"),
+        "X-Title": os.getenv("APP_TITLE", "CVE Fact Checker"),
+    }
+    return OpenRouterConfig(api_key=key, headers=headers, model=model, max_tokens=max_tokens)

cve_factchecker/embeddings.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import List, Any
+import os
+
+class SimpleDummyEmbeddings:
+    def __init__(self, dim: int = 384):
+        self.dimension = dim
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        vecs: List[List[float]] = []
+        for t in texts:
+            h = abs(hash(t.lower()))
+            v = [(float((h >> i) & 1)) for i in range(self.dimension)]
+            norm = sum(x * x for x in v) ** 0.5 or 1.0
+            vecs.append([x / norm for x in v])
+        return vecs
+    def embed_query(self, text: str) -> List[float]:
+        return self.embed_documents([text])[0]
+
+def build_embeddings() -> Any:
+    # Allow forcing lightweight embeddings to speed up cold starts (e.g., on Spaces)
+    if os.environ.get("USE_DUMMY_EMBEDDINGS", "").lower() in ("1", "true", "yes"):  # pragma: no cover
+        return SimpleDummyEmbeddings()
+    try:
+        from langchain_huggingface import HuggingFaceEmbeddings  # type: ignore
+    except Exception:
+        try:
+            from langchain_community.embeddings import HuggingFaceEmbeddings  # type: ignore
+        except Exception:
+            HuggingFaceEmbeddings = None  # type: ignore
+    if "HuggingFaceEmbeddings" in locals() and HuggingFaceEmbeddings is not None:  # type: ignore
+        try:
+            return HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2",
+                model_kwargs={"device": "cpu"},
+                encode_kwargs={"normalize_embeddings": True},
+            )
+        except Exception:
+            pass
+    return SimpleDummyEmbeddings()

cve_factchecker/firebase_loader.py

@@ -0,0 +1,146 @@
+import os
+import requests
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from datetime import datetime
+from .models import NewsArticle
+
+@dataclass
+class FirebaseConfig:
+    api_key: str
+    auth_domain: str
+    project_id: str
+    storage_bucket: str
+    messaging_sender_id: str
+    app_id: str
+
+FIREBASE_CONFIG = FirebaseConfig(
+    api_key=os.environ.get("FIREBASE_API_KEY", "AIzaSyAX2ZBIB5lkBEEgXydi__Qlb0WBpUmntCk"),
+    auth_domain=os.environ.get("FIREBASE_AUTH_DOMAIN", "cve-articles-b4f4f.firebaseapp.com"),
+    project_id=os.environ.get("FIREBASE_PROJECT_ID", "cve-articles-b4f4f"),
+    storage_bucket=os.environ.get("FIREBASE_STORAGE_BUCKET", "cve-articles-b4f4f.firebasestorage.app"),
+    messaging_sender_id=os.environ.get("FIREBASE_MESSAGING_SENDER_ID", "682945772298"),
+    app_id=os.environ.get("FIREBASE_APP_ID", "1:682945772298:web:b0d1dab0c7e07f83fad8f3")
+)
+
+class FirebaseNewsLoader:
+    def __init__(self, config: Optional[FirebaseConfig] = None):
+        self.config = config or FIREBASE_CONFIG
+        self.project_id = self.config.project_id
+        self.api_key = self.config.api_key
+
+    def fetch_articles(self, collection_name: str = "Articles", limit: Optional[int] = 100) -> List[NewsArticle]:
+        """Fetch articles with optional limit. If limit is None or <=0, fetch ALL via pagination."""
+        try:
+            base_url = f"https://firestore.googleapis.com/v1/projects/{self.project_id}/databases/(default)/documents/{collection_name}"
+            remaining = None if (limit is None or (isinstance(limit, int) and limit <= 0)) else int(limit)
+            page_token: Optional[str] = None
+            batch_size = 300  # Firestore max pageSize
+            articles: List[NewsArticle] = []
+            while True:
+                if remaining is not None and remaining <= 0:
+                    break
+                page_size = batch_size if remaining is None else min(batch_size, remaining)
+                params = {"key": self.api_key, "pageSize": page_size}
+                if page_token:
+                    params["pageToken"] = page_token
+                resp = requests.get(base_url, params=params, timeout=30)
+                if resp.status_code != 200:
+                    print(f"❌ Firebase API failed: {resp.status_code}")
+                    break
+                data = resp.json()
+                docs = data.get("documents", [])
+                if not docs:
+                    break
+                for d in docs:
+                    art = self._convert_doc(d)
+                    if art:
+                        articles.append(art)
+                if remaining is not None:
+                    remaining -= len(docs)
+                page_token = data.get("nextPageToken")
+                if not page_token:
+                    break
+            return articles
+        except Exception as e:
+            print(f"❌ Firebase error: {e}")
+            return []
+
+    def _convert_doc(self, doc: Dict[str, Any]) -> Optional[NewsArticle]:
+        try:
+            doc_name = doc.get("name", "")
+            doc_id = doc_name.split("/")[-1] if doc_name else "unknown"
+            fields = doc.get("fields", {})
+            data: Dict[str, Any] = {}
+            for fname, fval in fields.items():
+                if fval and isinstance(fval, dict):
+                    ftype = list(fval.keys())[0]
+                    data[fname] = fval[ftype]
+            return NewsArticle(
+                title=data.get("Title", data.get("title", "Untitled")),
+                content=data.get("Article_text", data.get("content", "")),
+                url=data.get("URL", data.get("url", f"firebase://doc/{doc_id}")),
+                source=data.get("source", "Firebase"),
+                published_date=data.get("Date", data.get("createdAt", datetime.now().isoformat())),
+                scraped_date=data.get("scrapedAt", data.get("createdAt", datetime.now().isoformat())),
+                article_id=doc_id,
+            )
+        except Exception as e:
+            print(f"⚠️ Conversion error: {e}")
+            return None
+
+    def load_news_articles(self, collection_name: str = "Articles", limit: int = 100) -> List[NewsArticle]:
+        return self.fetch_articles(collection_name, limit)
+
+    def analyze_schema(self, collection_name: str = "Articles") -> Dict[str, Any]:
+        try:
+            url = f"https://firestore.googleapis.com/v1/projects/{self.project_id}/databases/(default)/documents/{collection_name}"
+            params = {"key": self.api_key, "pageSize": 5}
+            response = requests.get(url, params=params, timeout=30)
+            if response.status_code == 200:
+                data = response.json()
+                documents = data.get("documents", [])
+                if not documents:
+                    return {"error": "empty", "collection": collection_name}
+                all_fields = set()
+                sample_data = []
+                for doc in documents:
+                    fields = doc.get("fields", {})
+                    field_names = list(fields.keys())
+                    all_fields.update(field_names)
+                    sample_values: Dict[str, Any] = {}
+                    for fname, fdata in fields.items():
+                        if fdata and isinstance(fdata, dict):
+                            ftype = list(fdata.keys())[0]
+                            sample_values[fname] = str(fdata[ftype])[:100]
+                    doc_id = doc.get("name", "").split("/")[-1]
+                    sample_data.append({"id": doc_id, "fields": field_names, "sample": sample_values})
+                return {
+                    "collection": collection_name,
+                    "document_count": len(documents),
+                    "unique_fields": sorted(list(all_fields)),
+                    "field_count": len(all_fields),
+                    "sample_documents": sample_data,
+                }
+            return {"error": f"status {response.status_code}", "collection": collection_name}
+        except Exception as e:
+            return {"error": str(e), "collection": collection_name}
+
+    def get_collections_info(self) -> List[Dict[str, Any]]:
+        possible = ["Articles", "articles"]
+        results: List[Dict[str, Any]] = []
+        seen = set()
+        for name in possible:
+            if name in seen:
+                continue
+            arts = self.fetch_articles(name, limit=5)
+            if arts:
+                results.append({
+                    "name": name,
+                    "document_count": "≥" + str(len(arts)),
+                    "sample_titles": [a.title for a in arts[:3]],
+                })
+                seen.add(name)
+        if not results:
+            results.append({"name": "Articles", "document_count": 0})
+        return results

cve_factchecker/firebase_service.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from typing import Dict, Any, Optional, List
+from .firebase_loader import FirebaseNewsLoader
+from .retriever import VectorNewsRetriever
+
+class FirebaseVectorSync:
+    def __init__(self, vector_persist_dir: str = "./vector_db"):
+        self.firebase_loader = FirebaseNewsLoader()
+        self.vector_retriever = VectorNewsRetriever(persist_directory=vector_persist_dir)
+    def analyze_firebase_schema(self, collection: str = "Articles") -> Dict[str, Any]:
+        schema = self.firebase_loader.analyze_schema(collection)
+        return schema
+    def sync_from_firebase(self, collection_name: str = "Articles", limit: Optional[int] = None) -> Dict[str, Any]:
+        # If limit is None => fetch ALL via pagination logic in loader.
+        arts = self.firebase_loader.load_news_articles(collection_name, limit if limit is not None else None)
+        if not arts and collection_name != "Articles":
+            arts = self.firebase_loader.load_news_articles("Articles", limit if limit is not None else None)
+            if arts:
+                collection_name = "Articles"
+        if not arts:
+            return {"error": "No articles found", "synced": 0, "success": False}
+        self.vector_retriever.store_articles_in_vector_db(arts)
+        return {"synced": len(arts), "collection": collection_name, "success": True}
+    def quick_sync(self, limit: int = 100) -> Dict[str, Any]:
+        return self.sync_from_firebase(limit=limit)
+    def full_sync(self) -> Dict[str, Any]:
+        return self.sync_from_firebase(limit=None)
+    def list_firebase_collections(self) -> List[Dict[str, Any]]:
+        return self.firebase_loader.get_collections_info()

cve_factchecker/llm.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import Optional
+from openai import OpenAI
+from .config import OpenRouterConfig
+
+def build_openrouter_client(cfg: OpenRouterConfig) -> Optional[OpenAI]:
+    if not cfg.api_key:
+        return None
+    try:
+        client = OpenAI(api_key=cfg.api_key, base_url=cfg.base_url, default_headers=cfg.headers or None)
+        return client
+    except Exception as e:
+        print(f"⚠️ LLM initialization failed: {e}")
+        return None
+
+def chat_complete(client: OpenAI, model: str, prompt: str, temperature: float = 0.0, max_tokens: int = 800) -> str:
+    resp = client.chat.completions.create(model=model, messages=[{"role": "user", "content": prompt}], temperature=temperature, max_tokens=max_tokens)
+    choice = resp.choices[0]
+    return getattr(getattr(choice, "message", None), "content", None) or getattr(choice, "text", "") or ""

cve_factchecker/models.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+
+@dataclass
+class NewsArticle:
+    title: str
+    content: str
+    url: str
+    source: str
+    published_date: str
+    scraped_date: str
+    article_id: str
+
+
+def normalize_result(result: Dict[str, Any]) -> Dict[str, Any]:
+    out = {
+        "verdict": result.get("verdict", "UNVERIFIED"),
+        "confidence": result.get("confidence", 0.0),
+        "reasoning": result.get("reasoning", ""),
+        "supporting_evidence": result.get("supporting_evidence", []) or [],
+        "contradicting_evidence": result.get("contradicting_evidence", []) or [],
+        "context_quality": result.get("context_quality", "unknown"),
+    }
+    c = out["confidence"]
+    try:
+        if isinstance(c, str):
+            c = float(c.strip().replace("%", ""))
+        c = float(c)
+        if c > 1.0:
+            c = c / 100.0
+        if c < 0:
+            c = 0.0
+        if c > 1:
+            c = 1.0
+    except Exception:
+        c = 0.0
+    out["confidence"] = c
+    if not isinstance(out["supporting_evidence"], list):
+        out["supporting_evidence"] = [str(out["supporting_evidence"])]
+    if not isinstance(out["contradicting_evidence"], list):
+        out["contradicting_evidence"] = [str(out["contradicting_evidence"])]
+    if isinstance(out["verdict"], str):
+        out["verdict"] = out["verdict"].upper()
+    return out

cve_factchecker/orchestrator.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Dict, Any, Optional
+from .config import load_openrouter_config
+from .retriever import VectorNewsRetriever
+from .analyzer import QueryRewriter, ClaimAnalyzer
+from .firebase_loader import FirebaseNewsLoader
+
+class FactCheckSystem:
+    def __init__(self, api_key: Optional[str] = None, vector_dir: str = "./vector_db"):
+        cfg = load_openrouter_config(api_key)
+        self.cfg = cfg
+        self.retriever = VectorNewsRetriever(persist_directory=vector_dir)
+        self.rewriter = QueryRewriter(cfg)
+        self.analyzer = ClaimAnalyzer(cfg)
+        self.firebase = FirebaseNewsLoader()
+    def ingest_firebase(self, collection: str = "Articles", limit: int = 200) -> Dict[str, Any]:
+        arts = self.firebase.load_news_articles(collection, limit)
+        if not arts:
+            return {"synced": 0, "collection": collection, "success": False}
+        self.retriever.store_articles_in_vector_db(arts)
+        return {"synced": len(arts), "collection": collection, "success": True}
+    def fact_check(self, claim: str, k: int = 5) -> Dict[str, Any]:
+        base = self.retriever.semantic_search(claim, k=k)
+        urls = {a.get("url", "") for a in base}
+        for q in self.rewriter.rewrite(claim):
+            more = self.retriever.semantic_search(q, k=3)
+            for m in more:
+                u = m.get("url", "")
+                if u and u not in urls:
+                    base.append(m)
+                    urls.add(u)
+        result = self.analyzer.analyze(claim, base[:8])
+        result["sources_used"] = len(base[:8])
+        result["retrieved_articles"] = [a.get("url", "") for a in base[:8]]
+        return result

cve_factchecker/retriever.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import os
+from typing import List, Dict, Any
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+try:
+    from langchain_chroma import Chroma  # type: ignore
+except Exception:
+    from langchain_community.vectorstores import Chroma  # type: ignore
+from .embeddings import build_embeddings
+from .models import NewsArticle
+
+class VectorNewsRetriever:
+    def __init__(self, persist_directory: str = "./vector_db"):
+        # Allow overriding persist directory via env (e.g., /data on Hugging Face Spaces)
+        env_dir = os.environ.get("VECTOR_PERSIST_DIR")
+        self.persist_directory = env_dir or persist_directory
+        self.embeddings = build_embeddings()
+        self.vector_store = self._initialize_vector_store()
+    def _initialize_vector_store(self) -> Chroma:
+        try:
+            os.makedirs(self.persist_directory, exist_ok=True)
+            vs = Chroma(persist_directory=self.persist_directory, embedding_function=self.embeddings, collection_name="news_articles")
+            try:
+                count = vs._collection.count()
+                print(f"✅ Loaded vector database with {count} documents")
+            except Exception:
+                print("✅ Vector database loaded")
+            return vs
+        except Exception as e:
+            print(f"❌ Error initializing vector store: {e}")
+            print("🔄 Using in-memory store")
+            return Chroma(embedding_function=self.embeddings, collection_name="news_articles_memory")
+    def store_articles_in_vector_db(self, articles: List[NewsArticle]) -> None:
+        if not articles:
+            print("ℹ️ No new articles to store")
+            return
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        docs: List[Document] = []
+        for art in articles:
+            chunks = splitter.split_text(art.content or "")
+            for chunk in chunks:
+                docs.append(Document(page_content=f"Title: {art.title}\n\n{chunk}", metadata={"url": art.url, "source": art.source, "published_date": art.published_date, "scraped_date": art.scraped_date, "id": art.article_id}))
+        if hasattr(self.vector_store, "add_documents"):
+            self.vector_store.add_documents(docs)
+        else:
+            self.vector_store.add_texts([d.page_content for d in docs], metadatas=[d.metadata for d in docs])
+        try:
+            self.vector_store.persist()
+        except Exception:
+            pass
+        print(f"💾 Stored {len(docs)} chunks from {len(articles)} articles")
+    def semantic_search(self, query: str, k: int = 5) -> List[Dict[str, Any]]:
+        try:
+            docs = self.vector_store.similarity_search(query, k=k)
+        except Exception as e:
+            print(f"❌ Vector search failed: {e}")
+            return []
+        results: List[Dict[str, Any]] = []
+        for d in docs:
+            meta = getattr(d, "metadata", {}) or {}
+            content = getattr(d, "page_content", "") or ""
+            title = "Unknown"
+            if content.startswith("Title: "):
+                line = content.splitlines()[0]
+                title = line.replace("Title: ", "").strip() or title
+            results.append({"title": title, "content": content, "url": meta.get("url", ""), "source": meta.get("source", "Unknown"), "metadata": meta})
+        return results

cve_factchecker/wsgi.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+from .app import app as application  # WSGI entry point
+
+# This file allows running with a production server like gunicorn/waitress:
+#   gunicorn -w 4 -b 0.0.0.0:8000 cve_factchecker.wsgi:application

requirements.txt

@@ -0,0 +1,28 @@
+requests==2.31.0
+beautifulsoup4==4.12.2
+openai==1.35.0
+lxml==4.9.3
+flask==2.3.3
+werkzeug==2.3.7
+flask-cors==4.0.0
+
+# LangChain and Vector Database dependencies
+langchain==0.1.20
+langchain-community==0.2.10
+langchain-openai==0.1.7
+langchain-chroma==0.1.2
+langchain-huggingface==0.0.3
+chromadb==0.4.18
+tiktoken==0.5.2
+sentence-transformers==2.2.2
+
+# Firebase integration
+firebase-admin
+
+# Additional dependencies for robust retrieval
+numpy
+pandas
+scikit-learn
+
+# Production WSGI server
+gunicorn==21.2.0