Upload 6 files

app.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Spaces entrypoint.
+
+HF Spaces looks for either:
+- app.py with a variable named `demo` or `app`, OR
+- a Gradio `Blocks` returned and launched.
+
+This file reuses your existing Gradio UI factory.
+"""
+
+import os
+
+# Optional: you can set defaults for HF here
+os.environ.setdefault("DB_XLSX", "database.xlsx")
+os.environ.setdefault("EMB_CACHE", "treatment_embeddings.pkl")
+
+# IMPORTANT: in HF we do NOT have Ollama. Use transformers backend.
+os.environ.setdefault("LOCAL_LLM_PROVIDER", "transformers")
+
+# Choose a CPU-friendly open model (no auth required).
+# Good default: TinyLlama (fast-ish on CPU).
+os.environ.setdefault("HF_LLM_MODEL", "TinyLlama/TinyLlama-1.1B-Chat-v1.0")
+
+from gradio_new_rag_app import make_app
+
+demo = make_app()
+
+if __name__ == "__main__":
+    demo.launch()

llm_client.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Local LLM client abstraction (NO OpenAI/Claude).
+
+Providers:
+- ollama        : calls a local Ollama server (your Windows dev)
+- transformers  : runs a local HF model in-process (best for Hugging Face Spaces CPU)
+
+Env:
+  LOCAL_LLM_PROVIDER=ollama|transformers
+
+Ollama:
+  OLLAMA_HOST=http://localhost:11434
+  OLLAMA_MODEL=llama3.2:1b
+
+Transformers:
+  HF_LLM_MODEL=TinyLlama/TinyLlama-1.1B-Chat-v1.0   (recommended CPU default)
+  HF_MAX_NEW_TOKENS=450
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any, Dict, Optional
+
+import requests
+
+
+class LocalLLMClient:
+    def __init__(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        host: Optional[str] = None,
+        timeout_sec: int = 120,
+    ):
+        self.provider = (provider or os.getenv("LOCAL_LLM_PROVIDER", "ollama")).lower().strip()
+        self.timeout_sec = int(os.getenv("LLM_TIMEOUT_SEC", str(timeout_sec)))
+
+        # Ollama settings
+        self.host = (host or os.getenv("OLLAMA_HOST", "http://localhost:11434")).strip()
+        self.model = (model or os.getenv("OLLAMA_MODEL", "llama3.2:1b")).strip()
+
+        # Transformers settings (HF Spaces)
+        self.hf_model_id = (os.getenv("HF_LLM_MODEL", "TinyLlama/TinyLlama-1.1B-Chat-v1.0")).strip()
+        self.hf_max_new_tokens = int(os.getenv("HF_MAX_NEW_TOKENS", "450"))
+
+        self._hf_pipe = None  # lazy init
+
+        if self.provider not in {"ollama", "transformers"}:
+            raise ValueError(
+                f"Unsupported LOCAL_LLM_PROVIDER='{self.provider}'. "
+                "Supported: ollama, transformers."
+            )
+
+    # --------------------------- Public API ---------------------------
+
+    def generate(self, prompt: str, temperature: float = 0.2, max_tokens: int = 900) -> str:
+        prompt = (prompt or "").strip()
+        if not prompt:
+            return ""
+
+        if self.provider == "ollama":
+            return self._generate_ollama(prompt, temperature=temperature, max_tokens=max_tokens)
+
+        # transformers
+        return self._generate_transformers(prompt, temperature=temperature, max_tokens=max_tokens)
+
+    # --------------------------- Ollama ---------------------------
+
+    def _generate_ollama(self, prompt: str, temperature: float, max_tokens: int) -> str:
+        url = self.host.rstrip("/") + "/api/generate"
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": float(temperature),
+                "num_predict": int(max_tokens),
+            },
+        }
+
+        try:
+            r = requests.post(url, json=payload, timeout=self.timeout_sec)
+        except requests.RequestException as e:
+            raise RuntimeError(
+                "Failed to connect to local Ollama.\n"
+                f"Tried: {url}\n"
+                "Fix:\n"
+                "  - Ensure Ollama is running\n"
+                "  - Confirm endpoint: iwr http://localhost:11434/api/tags -UseBasicParsing\n"
+                f"Error: {repr(e)}"
+            ) from e
+
+        if r.status_code != 200:
+            body = (r.text or "").strip()
+            msg = body
+            try:
+                j = r.json()
+                if isinstance(j, dict):
+                    msg = j.get("error") or j.get("message") or body
+            except Exception:
+                pass
+            raise RuntimeError(
+                "Ollama returned an error.\n"
+                f"URL: {url}\n"
+                f"HTTP: {r.status_code}\n"
+                f"Model: {self.model}\n"
+                f"Details: {msg}"
+            )
+
+        data = r.json()
+        return (data.get("response") or "").strip()
+
+    # --------------------------- Transformers (HF Spaces) ---------------------------
+
+    def _lazy_init_hf(self):
+        if self._hf_pipe is not None:
+            return
+
+        # Lazy import to keep local installs lighter
+        from transformers import pipeline
+
+        # CPU inference; use bfloat16 only if supported (some spaces may not)
+        # Keep it simple and robust.
+        self._hf_pipe = pipeline(
+            "text-generation",
+            model=self.hf_model_id,
+            device=-1,  # CPU
+        )
+
+    def _generate_transformers(self, prompt: str, temperature: float, max_tokens: int) -> str:
+        self._lazy_init_hf()
+
+        # Cap generation for HF CPU
+        max_new = min(int(max_tokens), int(self.hf_max_new_tokens))
+
+        # Many instruct/chat models work better with a simple instruction wrapper.
+        wrapped = (
+            "You are a helpful assistant.\n\n"
+            f"{prompt}\n\n"
+            "Answer:"
+        )
+
+        out = self._hf_pipe(
+            wrapped,
+            max_new_tokens=max_new,
+            do_sample=True,
+            temperature=float(max(0.05, temperature)),
+            top_p=0.9,
+            repetition_penalty=1.1,
+        )
+
+        if not out:
+            return ""
+
+        # pipeline returns list[{"generated_text": "..."}]
+        text = out[0].get("generated_text", "")
+        text = (text or "").strip()
+
+        # Remove the prompt prefix if the model echoed it
+        if text.startswith(wrapped):
+            text = text[len(wrapped):].strip()
+
+        return text
+
+    # --------------------------- JSON helpers ---------------------------
+
+    @staticmethod
+    def _strip_code_fences(text: str) -> str:
+        t = text.strip()
+        t = re.sub(r"^```(?:json)?\s*", "", t, flags=re.IGNORECASE)
+        t = re.sub(r"\s*```$", "", t)
+        return t.strip()
+
+    def safe_json_loads(self, text: str) -> Dict[str, Any]:
+        if not text:
+            return {}
+
+        t = self._strip_code_fences(text)
+
+        try:
+            out = json.loads(t)
+            return out if isinstance(out, dict) else {}
+        except Exception:
+            pass
+
+        m = re.search(r"\{.*\}", t, flags=re.DOTALL)
+        if m:
+            try:
+                out = json.loads(m.group(0))
+                return out if isinstance(out, dict) else {}
+            except Exception:
+                return {}
+
+        return {}

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=4.0.0
+pandas
+numpy
+openpyxl
+scikit-learn
+sentence-transformers
+torch
+transformers
+accelerate
+requests
+beautifulsoup4
+lxml

treatment_embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a91ab8b6879a80ecae1d39d1b36fda5b947db9a52b7ce0c651a55068d4f0cce
+size 1745225

web_retriever.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+WebRetriever: lightweight, keyless web search + fetch for local CPU RAG / HF Spaces.
+
+- Search: DuckDuckGo HTML endpoint (no API key)
+- Fetch: requests + BeautifulSoup
+- Extract: visible text + quick snippet, capped to keep prompts small
+
+UPDATED FOR HF / PUBLIC TESTING:
+- Graceful failure: never crash app when network blocks / 403 / 429 / timeouts occur
+- Basic retries with backoff
+- Canonicalize DuckDuckGo redirect URLs (uddg)
+- Better HTML cleanup and snippet construction
+"""
+
+from __future__ import annotations
+
+import random
+import re
+import time
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+from urllib.parse import quote_plus, urlparse, parse_qs, unquote
+
+import requests
+from bs4 import BeautifulSoup
+
+
+@dataclass
+class WebDoc:
+    title: str
+    url: str
+    snippet: str
+
+
+class WebRetriever:
+    def __init__(
+        self,
+        user_agent: Optional[str] = None,
+        timeout_sec: int = 15,
+        polite_delay_sec: float = 0.4,
+        max_retries: int = 2,
+        backoff_base_sec: float = 0.8,
+    ):
+        # Use a plausible UA; HF outbound can be sensitive to "bot" UAs.
+        self.user_agent = user_agent or (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/120.0.0.0 Safari/537.36"
+        )
+        self.timeout_sec = timeout_sec
+        self.polite_delay_sec = polite_delay_sec
+        self.max_retries = max_retries
+        self.backoff_base_sec = backoff_base_sec
+
+    # ------------------------------------------------------------------
+    # Internal: request with retries/backoff
+    # ------------------------------------------------------------------
+    def _request(self, method: str, url: str, **kwargs) -> Optional[requests.Response]:
+        headers = kwargs.pop("headers", {})
+        headers.setdefault("User-Agent", self.user_agent)
+        kwargs["headers"] = headers
+        kwargs.setdefault("timeout", self.timeout_sec)
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = requests.request(method, url, **kwargs)
+
+                # Some sites rate-limit aggressively; treat 429/403 as "soft fail"
+                if resp.status_code in (403, 429):
+                    # Backoff and retry; may still fail; eventually return None
+                    self._sleep_backoff(attempt)
+                    continue
+
+                resp.raise_for_status()
+                return resp
+
+            except Exception:
+                # Backoff then retry; if last attempt, return None
+                if attempt >= self.max_retries:
+                    return None
+                self._sleep_backoff(attempt)
+
+        return None
+
+    def _sleep_backoff(self, attempt: int) -> None:
+        # Exponential backoff with jitter
+        base = self.backoff_base_sec * (2 ** attempt)
+        jitter = random.uniform(0.0, 0.25)
+        time.sleep(min(6.0, base + jitter))
+
+    # ------------------------------------------------------------------
+    # URL cleaning: unwrap DuckDuckGo redirect links
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _unwrap_ddg_redirect(url: str) -> str:
+        try:
+            p = urlparse(url)
+            # Example: https://duckduckgo.com/l/?uddg=<encoded_url>
+            if "duckduckgo.com" in p.netloc.lower() and p.path.startswith("/l/"):
+                qs = parse_qs(p.query)
+                uddg = qs.get("uddg", [""])[0]
+                if uddg:
+                    return unquote(uddg)
+        except Exception:
+            pass
+        return url
+
+    @staticmethod
+    def _dedupe_key(url: str) -> str:
+        try:
+            p = urlparse(url)
+            netloc = (p.netloc or "").lower()
+            path = (p.path or "").lower()
+            # Drop fragments and most query params for dedupe
+            return f"{netloc}{path}"
+        except Exception:
+            return url
+
+    # ------------------------------------------------------------------
+    # Search using DuckDuckGo HTML
+    # ------------------------------------------------------------------
+    def search(self, query: str, max_results: int = 5) -> List[WebDoc]:
+        q = (query or "").strip()
+        if not q:
+            return []
+
+        url = f"https://duckduckgo.com/html/?q={quote_plus(q)}"
+
+        resp = self._request("GET", url)
+        if resp is None:
+            return []
+
+        soup = BeautifulSoup(resp.text, "html.parser")
+        results: List[WebDoc] = []
+
+        # DDG HTML results usually contain: a.result__a
+        for a in soup.select("a.result__a")[: max_results * 3]:
+            title = a.get_text(" ", strip=True)
+            href = a.get("href") or ""
+            if not href:
+                continue
+
+            href = self._unwrap_ddg_redirect(href)
+            results.append(WebDoc(title=title, url=href, snippet=""))
+
+            if len(results) >= max_results:
+                break
+
+        # Polite delay to reduce rate limiting
+        time.sleep(self.polite_delay_sec)
+        return results
+
+    # ------------------------------------------------------------------
+    # Fetch and extract snippet
+    # ------------------------------------------------------------------
+    def fetch_snippet(self, url: str, max_chars: int = 900) -> str:
+        url = (url or "").strip()
+        if not url:
+            return ""
+
+        resp = self._request("GET", url)
+        if resp is None:
+            return ""
+
+        soup = BeautifulSoup(resp.text, "html.parser")
+
+        # Remove scripts/styles/nav/common clutter
+        for tag in soup(["script", "style", "noscript", "header", "footer", "nav", "aside", "form", "svg"]):
+            try:
+                tag.decompose()
+            except Exception:
+                pass
+
+        # Prefer main/article if available
+        main = soup.find("main")
+        article = soup.find("article")
+        root = article or main or soup.body or soup
+
+        text = root.get_text(" ", strip=True)
+        text = re.sub(r"\s+", " ", text).strip()
+
+        if not text:
+            return ""
+
+        if len(text) > max_chars:
+            text = text[:max_chars].rsplit(" ", 1)[0] + "…"
+
+        time.sleep(self.polite_delay_sec)
+        return text
+
+    # ------------------------------------------------------------------
+    # Combined: multiple queries -> docs
+    # ------------------------------------------------------------------
+    def search_and_fetch(
+        self,
+        queries: List[str],
+        max_results_per_query: int = 3,
+        max_docs: int = 6,
+        max_chars_per_doc: int = 900,
+    ) -> List[WebDoc]:
+        docs: List[WebDoc] = []
+        seen = set()
+
+        for q in queries:
+            results = self.search(q, max_results=max_results_per_query)
+            if not results:
+                continue
+
+            for res in results:
+                url = self._unwrap_ddg_redirect(res.url)
+                key = self._dedupe_key(url)
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                snippet = self.fetch_snippet(url, max_chars=max_chars_per_doc)
+                docs.append(WebDoc(title=res.title, url=url, snippet=snippet))
+
+                if len(docs) >= max_docs:
+                    return docs
+
+        return docs